From 73be0e1747234d69a4fe9ef03f2096f905dd6d44 Mon Sep 17 00:00:00 2001 From: elenatorrecilla Date: Sat, 29 Dec 2018 16:29:29 +0100 Subject: [PATCH 1/6] Soluciono problemas de estilo de Position test --- test/Position_test.cpp | 102 +++++++++++++++++++++++++++++++++-------- 1 file changed, 82 insertions(+), 20 deletions(-) diff --git a/test/Position_test.cpp b/test/Position_test.cpp index 91e769a..3ec376a 100644 --- a/test/Position_test.cpp +++ b/test/Position_test.cpp @@ -2,35 +2,97 @@ #include "gtest/gtest.h" #include "Position.h" +using namespace atcsim; + +TEST(PositionTest, empty_constructor) +{ + Position pos; + ASSERT_EQ(pos.get_x(), 0.0); + ASSERT_EQ(pos.get_y(), 0.0); + ASSERT_EQ(pos.get_z(), MAINTAIN_ALT); +} + + +TEST(PositionTest, constructor) +{ + Position pos(1,2,3); + ASSERT_EQ(pos.get_x(), 1.0); + ASSERT_EQ(pos.get_y(), 2.0); + ASSERT_EQ(pos.get_z(), 3.0); +} + TEST(PositionTest, setters_getters) { - atcsim::Position pos; - pos.set_x(1.0); - pos.set_y(2.0); - pos.set_z(3.0); - ASSERT_EQ(pos.get_x(), 1.0); - ASSERT_EQ(pos.get_y(), 2.0); - ASSERT_EQ(pos.get_z(), 3.0); + Position pos; + pos.set_x(1.0); + pos.set_y(2.0); + pos.set_z(3.0); + ASSERT_EQ(pos.get_x(), 1.0); + ASSERT_EQ(pos.get_y(), 2.0); + ASSERT_EQ(pos.get_z(), 3.0); +} - pos.set_name("WPT01"); - ASSERT_STREQ(pos.get_name().c_str(), "WPT01"); - pos.set_name("WPT"); - ASSERT_STREQ(pos.get_name().c_str(), "WPT00"); - pos.set_name("WAYPOINT"); - ASSERT_STREQ(pos.get_name().c_str(), "WAYPO"); +TEST(PositionTest, short_distance) +{ + Position pos1(1, 0, 0); + Position pos2(2, 0, 0); + ASSERT_EQ(pos1.distance(pos2), 1.0); } -TEST(PositionTest, distance) + +TEST(PositionTest, long_distance) { - atcsim::Position pos1(1, 0, 0); - atcsim::Position pos2(2, 0, 0); - ASSERT_EQ(pos1.distance(pos2), 1.0); + Position pos1(1, 0, 0); + Position pos2(200, 1500, 300); + ASSERT_FLOAT_EQ(pos1.distance(pos2), 1542.5956); } -int main(int argc, char* argv[]) + +TEST(PositionTest, zero_distance) { - ::testing::InitGoogleTest(&argc, argv); + Position pos1(2, 0, 0); + Position pos2(2, 0, 0); + ASSERT_EQ(pos1.distance(pos2), 0.0); +} + - return RUN_ALL_TESTS(); +TEST(PositionTest, positive_angles) +{ + Position pos1(1, 0, 1); + Position pos2(2, 0, 5); + float bearing, inclination; + pos1.angles(pos2, bearing, inclination); + ASSERT_FLOAT_EQ(bearing, 3.1415927); + ASSERT_FLOAT_EQ(inclination, 1.325818); +} + + +TEST(PositionTest, negative_angles) +{ + Position pos1(10, -10, 10); + Position pos2(0, 0, 0); + float bearing, inclination; + pos1.angles(pos2, bearing, inclination); + ASSERT_FLOAT_EQ(bearing, -0.785398); + ASSERT_FLOAT_EQ(inclination, -0.61547971); + +} + +TEST(PositionTest, zero_angles) +{ + Position pos1(2, 0, 0); + Position pos2(2, 0, 0); + float bearing, inclination; + pos1.angles(pos2, bearing, inclination); + ASSERT_EQ(bearing, 0.0); + ASSERT_EQ(inclination, 0.0); +} + + +int main(int argc, char* argv[]) +{ + ::testing::InitGoogleTest(&argc, argv); + + return RUN_ALL_TESTS(); } From ddfed805d6b2d5d9adef4e4ed343498754c8ec7a Mon Sep 17 00:00:00 2001 From: elenatorrecilla Date: Thu, 10 Jan 2019 19:13:27 +0100 Subject: [PATCH 2/6] Practica final Raquel Delgado --- src/ICE/cpp/ATCDisplay.cpp | 960 +++++++++++++++ src/ICE/cpp/ATCDisplay.h | 1969 +++++++++++++++++++++++++++++++ src/simulator/AirController.cpp | 120 +- 3 files changed, 3007 insertions(+), 42 deletions(-) create mode 100644 src/ICE/cpp/ATCDisplay.cpp create mode 100644 src/ICE/cpp/ATCDisplay.h diff --git a/src/ICE/cpp/ATCDisplay.cpp b/src/ICE/cpp/ATCDisplay.cpp new file mode 100644 index 0000000..b7adb67 --- /dev/null +++ b/src/ICE/cpp/ATCDisplay.cpp @@ -0,0 +1,960 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2017 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.0 +// +// +// +// Generated from file `ATCDisplay.ice' +// +// Warning: do not edit this file. +// +// +// + +#include +#include +#include +#include +#include +#include +#include +#include + +#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 < 0 +# error Ice patch level mismatch! +# endif +#endif + +#ifdef ICE_CPP11_MAPPING // C++11 mapping + +namespace +{ + +const ::std::string iceC_ATCDisplay_AirportInterface_ids[2] = +{ + "::ATCDisplay::AirportInterface", + "::Ice::Object" +}; +const ::std::string iceC_ATCDisplay_AirportInterface_ops[] = +{ + "NextFocus", + "UpdateSimT", + "getAirportInfo", + "getFlights", + "getMaxFlights", + "getPoints", + "getSimT", + "getStorm", + "ice_id", + "ice_ids", + "ice_isA", + "ice_ping" +}; +const ::std::string iceC_ATCDisplay_AirportInterface_getFlights_name = "getFlights"; +const ::std::string iceC_ATCDisplay_AirportInterface_getStorm_name = "getStorm"; +const ::std::string iceC_ATCDisplay_AirportInterface_getAirportInfo_name = "getAirportInfo"; +const ::std::string iceC_ATCDisplay_AirportInterface_UpdateSimT_name = "UpdateSimT"; +const ::std::string iceC_ATCDisplay_AirportInterface_NextFocus_name = "NextFocus"; +const ::std::string iceC_ATCDisplay_AirportInterface_getSimT_name = "getSimT"; +const ::std::string iceC_ATCDisplay_AirportInterface_getMaxFlights_name = "getMaxFlights"; +const ::std::string iceC_ATCDisplay_AirportInterface_getPoints_name = "getPoints"; + +} + +bool +ATCDisplay::AirportInterface::ice_isA(::std::string s, const ::Ice::Current&) const +{ + return ::std::binary_search(iceC_ATCDisplay_AirportInterface_ids, iceC_ATCDisplay_AirportInterface_ids + 2, s); +} + +::std::vector<::std::string> +ATCDisplay::AirportInterface::ice_ids(const ::Ice::Current&) const +{ + return ::std::vector<::std::string>(&iceC_ATCDisplay_AirportInterface_ids[0], &iceC_ATCDisplay_AirportInterface_ids[2]); +} + +::std::string +ATCDisplay::AirportInterface::ice_id(const ::Ice::Current&) const +{ + return ice_staticId(); +} + +const ::std::string& +ATCDisplay::AirportInterface::ice_staticId() +{ + static const ::std::string typeId = "::ATCDisplay::AirportInterface"; + return typeId; +} + +bool +ATCDisplay::AirportInterface::_iceD_getFlights(::IceInternal::Incoming& inS, const ::Ice::Current& current) +{ + _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode); + inS.readEmptyParams(); + ::ATCDisplay::ATCDFlights ret = this->getFlights(current); + auto ostr = inS.startWriteParams(); + ostr->writeAll(ret); + inS.endWriteParams(); + return true; +} + +bool +ATCDisplay::AirportInterface::_iceD_getStorm(::IceInternal::Incoming& inS, const ::Ice::Current& current) +{ + _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode); + inS.readEmptyParams(); + ::ATCDisplay::ATCDStorm ret = this->getStorm(current); + auto ostr = inS.startWriteParams(); + ostr->writeAll(ret); + inS.endWriteParams(); + return true; +} + +bool +ATCDisplay::AirportInterface::_iceD_getAirportInfo(::IceInternal::Incoming& inS, const ::Ice::Current& current) +{ + _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode); + inS.readEmptyParams(); + ::ATCDisplay::ATCDAirport ret = this->getAirportInfo(current); + auto ostr = inS.startWriteParams(); + ostr->writeAll(ret); + inS.endWriteParams(); + return true; +} + +bool +ATCDisplay::AirportInterface::_iceD_UpdateSimT(::IceInternal::Incoming& inS, const ::Ice::Current& current) +{ + _iceCheckMode(::Ice::OperationMode::Normal, current.mode); + auto istr = inS.startReadParams(); + float iceP_inc; + istr->readAll(iceP_inc); + inS.endReadParams(); + this->UpdateSimT(iceP_inc, current); + inS.writeEmptyParams(); + return true; +} + +bool +ATCDisplay::AirportInterface::_iceD_NextFocus(::IceInternal::Incoming& inS, const ::Ice::Current& current) +{ + _iceCheckMode(::Ice::OperationMode::Normal, current.mode); + inS.readEmptyParams(); + this->NextFocus(current); + inS.writeEmptyParams(); + return true; +} + +bool +ATCDisplay::AirportInterface::_iceD_getSimT(::IceInternal::Incoming& inS, const ::Ice::Current& current) +{ + _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode); + inS.readEmptyParams(); + float ret = this->getSimT(current); + auto ostr = inS.startWriteParams(); + ostr->writeAll(ret); + inS.endWriteParams(); + return true; +} + +bool +ATCDisplay::AirportInterface::_iceD_getMaxFlights(::IceInternal::Incoming& inS, const ::Ice::Current& current) +{ + _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode); + inS.readEmptyParams(); + int ret = this->getMaxFlights(current); + auto ostr = inS.startWriteParams(); + ostr->writeAll(ret); + inS.endWriteParams(); + return true; +} + +bool +ATCDisplay::AirportInterface::_iceD_getPoints(::IceInternal::Incoming& inS, const ::Ice::Current& current) +{ + _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode); + inS.readEmptyParams(); + int ret = this->getPoints(current); + auto ostr = inS.startWriteParams(); + ostr->writeAll(ret); + inS.endWriteParams(); + return true; +} + +bool +ATCDisplay::AirportInterface::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current) +{ + ::std::pair r = ::std::equal_range(iceC_ATCDisplay_AirportInterface_ops, iceC_ATCDisplay_AirportInterface_ops + 12, current.operation); + if(r.first == r.second) + { + throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation); + } + + switch(r.first - iceC_ATCDisplay_AirportInterface_ops) + { + case 0: + { + return _iceD_NextFocus(in, current); + } + case 1: + { + return _iceD_UpdateSimT(in, current); + } + case 2: + { + return _iceD_getAirportInfo(in, current); + } + case 3: + { + return _iceD_getFlights(in, current); + } + case 4: + { + return _iceD_getMaxFlights(in, current); + } + case 5: + { + return _iceD_getPoints(in, current); + } + case 6: + { + return _iceD_getSimT(in, current); + } + case 7: + { + return _iceD_getStorm(in, current); + } + case 8: + { + return _iceD_ice_id(in, current); + } + case 9: + { + return _iceD_ice_ids(in, current); + } + case 10: + { + return _iceD_ice_isA(in, current); + } + case 11: + { + return _iceD_ice_ping(in, current); + } + default: + { + assert(false); + throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation); + } + } +} + +void +ATCDisplay::AirportInterfacePrx::_iceI_getFlights(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::ATCDisplay::ATCDFlights>>& outAsync, const ::Ice::Context& context) +{ + _checkTwowayOnly(iceC_ATCDisplay_AirportInterface_getFlights_name); + outAsync->invoke(iceC_ATCDisplay_AirportInterface_getFlights_name, ::Ice::OperationMode::Idempotent, ::Ice::FormatType::DefaultFormat, context, + nullptr, + nullptr); +} + +void +ATCDisplay::AirportInterfacePrx::_iceI_getStorm(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::ATCDisplay::ATCDStorm>>& outAsync, const ::Ice::Context& context) +{ + _checkTwowayOnly(iceC_ATCDisplay_AirportInterface_getStorm_name); + outAsync->invoke(iceC_ATCDisplay_AirportInterface_getStorm_name, ::Ice::OperationMode::Idempotent, ::Ice::FormatType::DefaultFormat, context, + nullptr, + nullptr); +} + +void +ATCDisplay::AirportInterfacePrx::_iceI_getAirportInfo(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::ATCDisplay::ATCDAirport>>& outAsync, const ::Ice::Context& context) +{ + _checkTwowayOnly(iceC_ATCDisplay_AirportInterface_getAirportInfo_name); + outAsync->invoke(iceC_ATCDisplay_AirportInterface_getAirportInfo_name, ::Ice::OperationMode::Idempotent, ::Ice::FormatType::DefaultFormat, context, + nullptr, + nullptr); +} + +void +ATCDisplay::AirportInterfacePrx::_iceI_UpdateSimT(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT>& outAsync, float iceP_inc, const ::Ice::Context& context) +{ + outAsync->invoke(iceC_ATCDisplay_AirportInterface_UpdateSimT_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::DefaultFormat, context, + [&](::Ice::OutputStream* ostr) + { + ostr->writeAll(iceP_inc); + }, + nullptr); +} + +void +ATCDisplay::AirportInterfacePrx::_iceI_NextFocus(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT>& outAsync, const ::Ice::Context& context) +{ + outAsync->invoke(iceC_ATCDisplay_AirportInterface_NextFocus_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::DefaultFormat, context, + nullptr, + nullptr); +} + +void +ATCDisplay::AirportInterfacePrx::_iceI_getSimT(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT>& outAsync, const ::Ice::Context& context) +{ + _checkTwowayOnly(iceC_ATCDisplay_AirportInterface_getSimT_name); + outAsync->invoke(iceC_ATCDisplay_AirportInterface_getSimT_name, ::Ice::OperationMode::Idempotent, ::Ice::FormatType::DefaultFormat, context, + nullptr, + nullptr); +} + +void +ATCDisplay::AirportInterfacePrx::_iceI_getMaxFlights(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT>& outAsync, const ::Ice::Context& context) +{ + _checkTwowayOnly(iceC_ATCDisplay_AirportInterface_getMaxFlights_name); + outAsync->invoke(iceC_ATCDisplay_AirportInterface_getMaxFlights_name, ::Ice::OperationMode::Idempotent, ::Ice::FormatType::DefaultFormat, context, + nullptr, + nullptr); +} + +void +ATCDisplay::AirportInterfacePrx::_iceI_getPoints(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT>& outAsync, const ::Ice::Context& context) +{ + _checkTwowayOnly(iceC_ATCDisplay_AirportInterface_getPoints_name); + outAsync->invoke(iceC_ATCDisplay_AirportInterface_getPoints_name, ::Ice::OperationMode::Idempotent, ::Ice::FormatType::DefaultFormat, context, + nullptr, + nullptr); +} + +::std::shared_ptr<::Ice::ObjectPrx> +ATCDisplay::AirportInterfacePrx::_newInstance() const +{ + return ::IceInternal::createProxy(); +} + +const ::std::string& +ATCDisplay::AirportInterfacePrx::ice_staticId() +{ + return ATCDisplay::AirportInterface::ice_staticId(); +} + +namespace Ice +{ +} + +#else // C++98 mapping + +namespace +{ + +const ::std::string iceC_ATCDisplay_AirportInterface_getFlights_name = "getFlights"; + +const ::std::string iceC_ATCDisplay_AirportInterface_getStorm_name = "getStorm"; + +const ::std::string iceC_ATCDisplay_AirportInterface_getAirportInfo_name = "getAirportInfo"; + +const ::std::string iceC_ATCDisplay_AirportInterface_UpdateSimT_name = "UpdateSimT"; + +const ::std::string iceC_ATCDisplay_AirportInterface_NextFocus_name = "NextFocus"; + +const ::std::string iceC_ATCDisplay_AirportInterface_getSimT_name = "getSimT"; + +const ::std::string iceC_ATCDisplay_AirportInterface_getMaxFlights_name = "getMaxFlights"; + +const ::std::string iceC_ATCDisplay_AirportInterface_getPoints_name = "getPoints"; + +} +::IceProxy::Ice::Object* ::IceProxy::ATCDisplay::upCast(::IceProxy::ATCDisplay::AirportInterface* p) { return p; } + +void +::IceProxy::ATCDisplay::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::ATCDisplay::AirportInterface>& v) +{ + ::Ice::ObjectPrx proxy; + istr->read(proxy); + if(!proxy) + { + v = 0; + } + else + { + v = new ::IceProxy::ATCDisplay::AirportInterface; + v->_copyFrom(proxy); + } +} + +::Ice::AsyncResultPtr +IceProxy::ATCDisplay::AirportInterface::_iceI_begin_getFlights(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync) +{ + _checkTwowayOnly(iceC_ATCDisplay_AirportInterface_getFlights_name, sync); + ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_ATCDisplay_AirportInterface_getFlights_name, del, cookie, sync); + try + { + result->prepare(iceC_ATCDisplay_AirportInterface_getFlights_name, ::Ice::Idempotent, context); + result->writeEmptyParams(); + result->invoke(iceC_ATCDisplay_AirportInterface_getFlights_name); + } + catch(const ::Ice::Exception& ex) + { + result->abort(ex); + } + return result; +} + +::ATCDisplay::ATCDFlights +IceProxy::ATCDisplay::AirportInterface::end_getFlights(const ::Ice::AsyncResultPtr& result) +{ + ::Ice::AsyncResult::_check(result, this, iceC_ATCDisplay_AirportInterface_getFlights_name); + ::ATCDisplay::ATCDFlights ret; + if(!result->_waitForResponse()) + { + try + { + result->_throwUserException(); + } + catch(const ::Ice::UserException& ex) + { + throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id()); + } + } + ::Ice::InputStream* istr = result->_startReadParams(); + istr->read(ret); + result->_endReadParams(); + return ret; +} + +::Ice::AsyncResultPtr +IceProxy::ATCDisplay::AirportInterface::_iceI_begin_getStorm(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync) +{ + _checkTwowayOnly(iceC_ATCDisplay_AirportInterface_getStorm_name, sync); + ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_ATCDisplay_AirportInterface_getStorm_name, del, cookie, sync); + try + { + result->prepare(iceC_ATCDisplay_AirportInterface_getStorm_name, ::Ice::Idempotent, context); + result->writeEmptyParams(); + result->invoke(iceC_ATCDisplay_AirportInterface_getStorm_name); + } + catch(const ::Ice::Exception& ex) + { + result->abort(ex); + } + return result; +} + +::ATCDisplay::ATCDStorm +IceProxy::ATCDisplay::AirportInterface::end_getStorm(const ::Ice::AsyncResultPtr& result) +{ + ::Ice::AsyncResult::_check(result, this, iceC_ATCDisplay_AirportInterface_getStorm_name); + ::ATCDisplay::ATCDStorm ret; + if(!result->_waitForResponse()) + { + try + { + result->_throwUserException(); + } + catch(const ::Ice::UserException& ex) + { + throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id()); + } + } + ::Ice::InputStream* istr = result->_startReadParams(); + istr->read(ret); + result->_endReadParams(); + return ret; +} + +::Ice::AsyncResultPtr +IceProxy::ATCDisplay::AirportInterface::_iceI_begin_getAirportInfo(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync) +{ + _checkTwowayOnly(iceC_ATCDisplay_AirportInterface_getAirportInfo_name, sync); + ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_ATCDisplay_AirportInterface_getAirportInfo_name, del, cookie, sync); + try + { + result->prepare(iceC_ATCDisplay_AirportInterface_getAirportInfo_name, ::Ice::Idempotent, context); + result->writeEmptyParams(); + result->invoke(iceC_ATCDisplay_AirportInterface_getAirportInfo_name); + } + catch(const ::Ice::Exception& ex) + { + result->abort(ex); + } + return result; +} + +::ATCDisplay::ATCDAirport +IceProxy::ATCDisplay::AirportInterface::end_getAirportInfo(const ::Ice::AsyncResultPtr& result) +{ + ::Ice::AsyncResult::_check(result, this, iceC_ATCDisplay_AirportInterface_getAirportInfo_name); + ::ATCDisplay::ATCDAirport ret; + if(!result->_waitForResponse()) + { + try + { + result->_throwUserException(); + } + catch(const ::Ice::UserException& ex) + { + throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id()); + } + } + ::Ice::InputStream* istr = result->_startReadParams(); + istr->read(ret); + result->_endReadParams(); + return ret; +} + +::Ice::AsyncResultPtr +IceProxy::ATCDisplay::AirportInterface::_iceI_begin_UpdateSimT(::Ice::Float iceP_inc, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync) +{ + ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_ATCDisplay_AirportInterface_UpdateSimT_name, del, cookie, sync); + try + { + result->prepare(iceC_ATCDisplay_AirportInterface_UpdateSimT_name, ::Ice::Normal, context); + ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::DefaultFormat); + ostr->write(iceP_inc); + result->endWriteParams(); + result->invoke(iceC_ATCDisplay_AirportInterface_UpdateSimT_name); + } + catch(const ::Ice::Exception& ex) + { + result->abort(ex); + } + return result; +} + +void +IceProxy::ATCDisplay::AirportInterface::end_UpdateSimT(const ::Ice::AsyncResultPtr& result) +{ + _end(result, iceC_ATCDisplay_AirportInterface_UpdateSimT_name); +} + +::Ice::AsyncResultPtr +IceProxy::ATCDisplay::AirportInterface::_iceI_begin_NextFocus(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync) +{ + ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_ATCDisplay_AirportInterface_NextFocus_name, del, cookie, sync); + try + { + result->prepare(iceC_ATCDisplay_AirportInterface_NextFocus_name, ::Ice::Normal, context); + result->writeEmptyParams(); + result->invoke(iceC_ATCDisplay_AirportInterface_NextFocus_name); + } + catch(const ::Ice::Exception& ex) + { + result->abort(ex); + } + return result; +} + +void +IceProxy::ATCDisplay::AirportInterface::end_NextFocus(const ::Ice::AsyncResultPtr& result) +{ + _end(result, iceC_ATCDisplay_AirportInterface_NextFocus_name); +} + +::Ice::AsyncResultPtr +IceProxy::ATCDisplay::AirportInterface::_iceI_begin_getSimT(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync) +{ + _checkTwowayOnly(iceC_ATCDisplay_AirportInterface_getSimT_name, sync); + ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_ATCDisplay_AirportInterface_getSimT_name, del, cookie, sync); + try + { + result->prepare(iceC_ATCDisplay_AirportInterface_getSimT_name, ::Ice::Idempotent, context); + result->writeEmptyParams(); + result->invoke(iceC_ATCDisplay_AirportInterface_getSimT_name); + } + catch(const ::Ice::Exception& ex) + { + result->abort(ex); + } + return result; +} + +::Ice::Float +IceProxy::ATCDisplay::AirportInterface::end_getSimT(const ::Ice::AsyncResultPtr& result) +{ + ::Ice::AsyncResult::_check(result, this, iceC_ATCDisplay_AirportInterface_getSimT_name); + ::Ice::Float ret; + if(!result->_waitForResponse()) + { + try + { + result->_throwUserException(); + } + catch(const ::Ice::UserException& ex) + { + throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id()); + } + } + ::Ice::InputStream* istr = result->_startReadParams(); + istr->read(ret); + result->_endReadParams(); + return ret; +} + +::Ice::AsyncResultPtr +IceProxy::ATCDisplay::AirportInterface::_iceI_begin_getMaxFlights(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync) +{ + _checkTwowayOnly(iceC_ATCDisplay_AirportInterface_getMaxFlights_name, sync); + ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_ATCDisplay_AirportInterface_getMaxFlights_name, del, cookie, sync); + try + { + result->prepare(iceC_ATCDisplay_AirportInterface_getMaxFlights_name, ::Ice::Idempotent, context); + result->writeEmptyParams(); + result->invoke(iceC_ATCDisplay_AirportInterface_getMaxFlights_name); + } + catch(const ::Ice::Exception& ex) + { + result->abort(ex); + } + return result; +} + +::Ice::Int +IceProxy::ATCDisplay::AirportInterface::end_getMaxFlights(const ::Ice::AsyncResultPtr& result) +{ + ::Ice::AsyncResult::_check(result, this, iceC_ATCDisplay_AirportInterface_getMaxFlights_name); + ::Ice::Int ret; + if(!result->_waitForResponse()) + { + try + { + result->_throwUserException(); + } + catch(const ::Ice::UserException& ex) + { + throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id()); + } + } + ::Ice::InputStream* istr = result->_startReadParams(); + istr->read(ret); + result->_endReadParams(); + return ret; +} + +::Ice::AsyncResultPtr +IceProxy::ATCDisplay::AirportInterface::_iceI_begin_getPoints(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync) +{ + _checkTwowayOnly(iceC_ATCDisplay_AirportInterface_getPoints_name, sync); + ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_ATCDisplay_AirportInterface_getPoints_name, del, cookie, sync); + try + { + result->prepare(iceC_ATCDisplay_AirportInterface_getPoints_name, ::Ice::Idempotent, context); + result->writeEmptyParams(); + result->invoke(iceC_ATCDisplay_AirportInterface_getPoints_name); + } + catch(const ::Ice::Exception& ex) + { + result->abort(ex); + } + return result; +} + +::Ice::Int +IceProxy::ATCDisplay::AirportInterface::end_getPoints(const ::Ice::AsyncResultPtr& result) +{ + ::Ice::AsyncResult::_check(result, this, iceC_ATCDisplay_AirportInterface_getPoints_name); + ::Ice::Int ret; + if(!result->_waitForResponse()) + { + try + { + result->_throwUserException(); + } + catch(const ::Ice::UserException& ex) + { + throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id()); + } + } + ::Ice::InputStream* istr = result->_startReadParams(); + istr->read(ret); + result->_endReadParams(); + return ret; +} + +::IceProxy::Ice::Object* +IceProxy::ATCDisplay::AirportInterface::_newInstance() const +{ + return new AirportInterface; +} + +const ::std::string& +IceProxy::ATCDisplay::AirportInterface::ice_staticId() +{ + return ::ATCDisplay::AirportInterface::ice_staticId(); +} + +ATCDisplay::AirportInterface::~AirportInterface() +{ +} + +::Ice::Object* ATCDisplay::upCast(::ATCDisplay::AirportInterface* p) { return p; } + + +namespace +{ +const ::std::string iceC_ATCDisplay_AirportInterface_ids[2] = +{ + "::ATCDisplay::AirportInterface", + "::Ice::Object" +}; + +} + +bool +ATCDisplay::AirportInterface::ice_isA(const ::std::string& s, const ::Ice::Current&) const +{ + return ::std::binary_search(iceC_ATCDisplay_AirportInterface_ids, iceC_ATCDisplay_AirportInterface_ids + 2, s); +} + +::std::vector< ::std::string> +ATCDisplay::AirportInterface::ice_ids(const ::Ice::Current&) const +{ + return ::std::vector< ::std::string>(&iceC_ATCDisplay_AirportInterface_ids[0], &iceC_ATCDisplay_AirportInterface_ids[2]); +} + +const ::std::string& +ATCDisplay::AirportInterface::ice_id(const ::Ice::Current&) const +{ + return ice_staticId(); +} + +const ::std::string& +ATCDisplay::AirportInterface::ice_staticId() +{ +#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC + static const ::std::string typeId = "::ATCDisplay::AirportInterface"; + return typeId; +#else + return iceC_ATCDisplay_AirportInterface_ids[0]; +#endif +} + +bool +ATCDisplay::AirportInterface::_iceD_getFlights(::IceInternal::Incoming& inS, const ::Ice::Current& current) +{ + _iceCheckMode(::Ice::Idempotent, current.mode); + inS.readEmptyParams(); + ::ATCDisplay::ATCDFlights ret = this->getFlights(current); + ::Ice::OutputStream* ostr = inS.startWriteParams(); + ostr->write(ret); + inS.endWriteParams(); + return true; +} + +bool +ATCDisplay::AirportInterface::_iceD_getStorm(::IceInternal::Incoming& inS, const ::Ice::Current& current) +{ + _iceCheckMode(::Ice::Idempotent, current.mode); + inS.readEmptyParams(); + ::ATCDisplay::ATCDStorm ret = this->getStorm(current); + ::Ice::OutputStream* ostr = inS.startWriteParams(); + ostr->write(ret); + inS.endWriteParams(); + return true; +} + +bool +ATCDisplay::AirportInterface::_iceD_getAirportInfo(::IceInternal::Incoming& inS, const ::Ice::Current& current) +{ + _iceCheckMode(::Ice::Idempotent, current.mode); + inS.readEmptyParams(); + ::ATCDisplay::ATCDAirport ret = this->getAirportInfo(current); + ::Ice::OutputStream* ostr = inS.startWriteParams(); + ostr->write(ret); + inS.endWriteParams(); + return true; +} + +bool +ATCDisplay::AirportInterface::_iceD_UpdateSimT(::IceInternal::Incoming& inS, const ::Ice::Current& current) +{ + _iceCheckMode(::Ice::Normal, current.mode); + ::Ice::InputStream* istr = inS.startReadParams(); + ::Ice::Float iceP_inc; + istr->read(iceP_inc); + inS.endReadParams(); + this->UpdateSimT(iceP_inc, current); + inS.writeEmptyParams(); + return true; +} + +bool +ATCDisplay::AirportInterface::_iceD_NextFocus(::IceInternal::Incoming& inS, const ::Ice::Current& current) +{ + _iceCheckMode(::Ice::Normal, current.mode); + inS.readEmptyParams(); + this->NextFocus(current); + inS.writeEmptyParams(); + return true; +} + +bool +ATCDisplay::AirportInterface::_iceD_getSimT(::IceInternal::Incoming& inS, const ::Ice::Current& current) +{ + _iceCheckMode(::Ice::Idempotent, current.mode); + inS.readEmptyParams(); + ::Ice::Float ret = this->getSimT(current); + ::Ice::OutputStream* ostr = inS.startWriteParams(); + ostr->write(ret); + inS.endWriteParams(); + return true; +} + +bool +ATCDisplay::AirportInterface::_iceD_getMaxFlights(::IceInternal::Incoming& inS, const ::Ice::Current& current) +{ + _iceCheckMode(::Ice::Idempotent, current.mode); + inS.readEmptyParams(); + ::Ice::Int ret = this->getMaxFlights(current); + ::Ice::OutputStream* ostr = inS.startWriteParams(); + ostr->write(ret); + inS.endWriteParams(); + return true; +} + +bool +ATCDisplay::AirportInterface::_iceD_getPoints(::IceInternal::Incoming& inS, const ::Ice::Current& current) +{ + _iceCheckMode(::Ice::Idempotent, current.mode); + inS.readEmptyParams(); + ::Ice::Int ret = this->getPoints(current); + ::Ice::OutputStream* ostr = inS.startWriteParams(); + ostr->write(ret); + inS.endWriteParams(); + return true; +} + +namespace +{ +const ::std::string iceC_ATCDisplay_AirportInterface_all[] = +{ + "NextFocus", + "UpdateSimT", + "getAirportInfo", + "getFlights", + "getMaxFlights", + "getPoints", + "getSimT", + "getStorm", + "ice_id", + "ice_ids", + "ice_isA", + "ice_ping" +}; + +} + +bool +ATCDisplay::AirportInterface::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current) +{ + ::std::pair r = ::std::equal_range(iceC_ATCDisplay_AirportInterface_all, iceC_ATCDisplay_AirportInterface_all + 12, current.operation); + if(r.first == r.second) + { + throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation); + } + + switch(r.first - iceC_ATCDisplay_AirportInterface_all) + { + case 0: + { + return _iceD_NextFocus(in, current); + } + case 1: + { + return _iceD_UpdateSimT(in, current); + } + case 2: + { + return _iceD_getAirportInfo(in, current); + } + case 3: + { + return _iceD_getFlights(in, current); + } + case 4: + { + return _iceD_getMaxFlights(in, current); + } + case 5: + { + return _iceD_getPoints(in, current); + } + case 6: + { + return _iceD_getSimT(in, current); + } + case 7: + { + return _iceD_getStorm(in, current); + } + case 8: + { + return _iceD_ice_id(in, current); + } + case 9: + { + return _iceD_ice_ids(in, current); + } + case 10: + { + return _iceD_ice_isA(in, current); + } + case 11: + { + return _iceD_ice_ping(in, current); + } + default: + { + assert(false); + throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation); + } + } +} + +void +ATCDisplay::AirportInterface::_iceWriteImpl(::Ice::OutputStream* ostr) const +{ + ostr->startSlice(ice_staticId(), -1, true); + Ice::StreamWriter< ::ATCDisplay::AirportInterface, ::Ice::OutputStream>::write(ostr, *this); + ostr->endSlice(); +} + +void +ATCDisplay::AirportInterface::_iceReadImpl(::Ice::InputStream* istr) +{ + istr->startSlice(); + Ice::StreamReader< ::ATCDisplay::AirportInterface, ::Ice::InputStream>::read(istr, *this); + istr->endSlice(); +} + +void +ATCDisplay::_icePatchObjectPtr(AirportInterfacePtr& handle, const ::Ice::ObjectPtr& v) +{ + handle = ::ATCDisplay::AirportInterfacePtr::dynamicCast(v); + if(v && !handle) + { + IceInternal::Ex::throwUOE(::ATCDisplay::AirportInterface::ice_staticId(), v); + } +} + +namespace Ice +{ +} + +#endif diff --git a/src/ICE/cpp/ATCDisplay.h b/src/ICE/cpp/ATCDisplay.h new file mode 100644 index 0000000..a22c556 --- /dev/null +++ b/src/ICE/cpp/ATCDisplay.h @@ -0,0 +1,1969 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2017 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.0 +// +// +// +// Generated from file `ATCDisplay.ice' +// +// Warning: do not edit this file. +// +// +// + +#ifndef __ATCDisplay_h__ +#define __ATCDisplay_h__ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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 < 0 +# error Ice patch level mismatch! +# endif +#endif + +#ifdef ICE_CPP11_MAPPING // C++11 mapping + +namespace ATCDisplay +{ + +class AirportInterface; +class AirportInterfacePrx; + +} + +namespace ATCDisplay +{ + +struct ATCDPosition +{ + ::std::string name; + float x; + float y; + float z; + + std::tuple ice_tuple() const + { + return std::tie(name, x, y, z); + } +}; + +using ATCDRoute = ::std::vector<::ATCDisplay::ATCDPosition>; + +struct ATCDStorm +{ + bool valid; + float speed; + ::ATCDisplay::ATCDPosition pos; + float bearing; + float radious; + float height; + + std::tuple ice_tuple() const + { + return std::tie(valid, speed, pos, bearing, radious, height); + } +}; + +struct ATCDFlight +{ + float points; + float speed; + bool focused; + ::std::string id; + ::ATCDisplay::ATCDPosition pos; + float inclination; + float bearing; + float collisionRadious; + ::ATCDisplay::ATCDRoute flightRoute; + + std::tuple ice_tuple() const + { + return std::tie(points, speed, focused, id, pos, inclination, bearing, collisionRadious, flightRoute); + } +}; + +using ATCDFlights = ::std::vector<::ATCDisplay::ATCDFlight>; + +struct ATCDLandStrip +{ + ::ATCDisplay::ATCDPosition pos; + float width; + float length; + float orientation; + + std::tuple ice_tuple() const + { + return std::tie(pos, width, length, orientation); + } +}; + +using ATCDLandStrips = ::std::vector<::ATCDisplay::ATCDLandStrip>; + +struct ATCDAirport +{ + ::ATCDisplay::ATCDLandStrips airportLandstrips; + float radious; + + std::tuple ice_tuple() const + { + return std::tie(airportLandstrips, radious); + } +}; + +using Ice::operator<; +using Ice::operator<=; +using Ice::operator>; +using Ice::operator>=; +using Ice::operator==; +using Ice::operator!=; + +} + +namespace ATCDisplay +{ + +class AirportInterface : public virtual ::Ice::Object +{ +public: + + using ProxyType = AirportInterfacePrx; + + virtual bool ice_isA(::std::string, const ::Ice::Current&) const override; + virtual ::std::vector<::std::string> ice_ids(const ::Ice::Current&) const override; + virtual ::std::string ice_id(const ::Ice::Current&) const override; + + static const ::std::string& ice_staticId(); + + virtual ::ATCDisplay::ATCDFlights getFlights(const ::Ice::Current&) = 0; + bool _iceD_getFlights(::IceInternal::Incoming&, const ::Ice::Current&); + + virtual ::ATCDisplay::ATCDStorm getStorm(const ::Ice::Current&) = 0; + bool _iceD_getStorm(::IceInternal::Incoming&, const ::Ice::Current&); + + virtual ::ATCDisplay::ATCDAirport getAirportInfo(const ::Ice::Current&) = 0; + bool _iceD_getAirportInfo(::IceInternal::Incoming&, const ::Ice::Current&); + + virtual void UpdateSimT(float, const ::Ice::Current&) = 0; + bool _iceD_UpdateSimT(::IceInternal::Incoming&, const ::Ice::Current&); + + virtual void NextFocus(const ::Ice::Current&) = 0; + bool _iceD_NextFocus(::IceInternal::Incoming&, const ::Ice::Current&); + + virtual float getSimT(const ::Ice::Current&) = 0; + bool _iceD_getSimT(::IceInternal::Incoming&, const ::Ice::Current&); + + virtual int getMaxFlights(const ::Ice::Current&) = 0; + bool _iceD_getMaxFlights(::IceInternal::Incoming&, const ::Ice::Current&); + + virtual int getPoints(const ::Ice::Current&) = 0; + bool _iceD_getPoints(::IceInternal::Incoming&, const ::Ice::Current&); + + virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override; +}; + +} + +namespace ATCDisplay +{ + +class AirportInterfacePrx : public virtual ::Ice::Proxy +{ +public: + + ::ATCDisplay::ATCDFlights getFlights(const ::Ice::Context& context = Ice::noExplicitContext) + { + return _makePromiseOutgoing<::ATCDisplay::ATCDFlights>(true, this, &ATCDisplay::AirportInterfacePrx::_iceI_getFlights, context).get(); + } + + template class P = ::std::promise> + auto getFlightsAsync(const ::Ice::Context& context = Ice::noExplicitContext) + -> decltype(::std::declval>().get_future()) + { + return _makePromiseOutgoing<::ATCDisplay::ATCDFlights, P>(false, this, &ATCDisplay::AirportInterfacePrx::_iceI_getFlights, context); + } + + ::std::function + getFlightsAsync(::std::function response, + ::std::function ex = nullptr, + ::std::function sent = nullptr, + const ::Ice::Context& context = Ice::noExplicitContext) + { + return _makeLamdaOutgoing<::ATCDisplay::ATCDFlights>(response, ex, sent, this, &ATCDisplay::AirportInterfacePrx::_iceI_getFlights, context); + } + + void _iceI_getFlights(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::ATCDisplay::ATCDFlights>>&, const ::Ice::Context&); + + ::ATCDisplay::ATCDStorm getStorm(const ::Ice::Context& context = Ice::noExplicitContext) + { + return _makePromiseOutgoing<::ATCDisplay::ATCDStorm>(true, this, &ATCDisplay::AirportInterfacePrx::_iceI_getStorm, context).get(); + } + + template class P = ::std::promise> + auto getStormAsync(const ::Ice::Context& context = Ice::noExplicitContext) + -> decltype(::std::declval>().get_future()) + { + return _makePromiseOutgoing<::ATCDisplay::ATCDStorm, P>(false, this, &ATCDisplay::AirportInterfacePrx::_iceI_getStorm, context); + } + + ::std::function + getStormAsync(::std::function response, + ::std::function ex = nullptr, + ::std::function sent = nullptr, + const ::Ice::Context& context = Ice::noExplicitContext) + { + return _makeLamdaOutgoing<::ATCDisplay::ATCDStorm>(response, ex, sent, this, &ATCDisplay::AirportInterfacePrx::_iceI_getStorm, context); + } + + void _iceI_getStorm(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::ATCDisplay::ATCDStorm>>&, const ::Ice::Context&); + + ::ATCDisplay::ATCDAirport getAirportInfo(const ::Ice::Context& context = Ice::noExplicitContext) + { + return _makePromiseOutgoing<::ATCDisplay::ATCDAirport>(true, this, &ATCDisplay::AirportInterfacePrx::_iceI_getAirportInfo, context).get(); + } + + template class P = ::std::promise> + auto getAirportInfoAsync(const ::Ice::Context& context = Ice::noExplicitContext) + -> decltype(::std::declval>().get_future()) + { + return _makePromiseOutgoing<::ATCDisplay::ATCDAirport, P>(false, this, &ATCDisplay::AirportInterfacePrx::_iceI_getAirportInfo, context); + } + + ::std::function + getAirportInfoAsync(::std::function response, + ::std::function ex = nullptr, + ::std::function sent = nullptr, + const ::Ice::Context& context = Ice::noExplicitContext) + { + return _makeLamdaOutgoing<::ATCDisplay::ATCDAirport>(response, ex, sent, this, &ATCDisplay::AirportInterfacePrx::_iceI_getAirportInfo, context); + } + + void _iceI_getAirportInfo(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::ATCDisplay::ATCDAirport>>&, const ::Ice::Context&); + + void UpdateSimT(float iceP_inc, const ::Ice::Context& context = Ice::noExplicitContext) + { + _makePromiseOutgoing(true, this, &ATCDisplay::AirportInterfacePrx::_iceI_UpdateSimT, iceP_inc, context).get(); + } + + template class P = ::std::promise> + auto UpdateSimTAsync(float iceP_inc, const ::Ice::Context& context = Ice::noExplicitContext) + -> decltype(::std::declval>().get_future()) + { + return _makePromiseOutgoing(false, this, &ATCDisplay::AirportInterfacePrx::_iceI_UpdateSimT, iceP_inc, context); + } + + ::std::function + UpdateSimTAsync(float iceP_inc, + ::std::function response, + ::std::function ex = nullptr, + ::std::function sent = nullptr, + const ::Ice::Context& context = Ice::noExplicitContext) + { + return _makeLamdaOutgoing(response, ex, sent, this, &ATCDisplay::AirportInterfacePrx::_iceI_UpdateSimT, iceP_inc, context); + } + + void _iceI_UpdateSimT(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT>&, float, const ::Ice::Context&); + + void NextFocus(const ::Ice::Context& context = Ice::noExplicitContext) + { + _makePromiseOutgoing(true, this, &ATCDisplay::AirportInterfacePrx::_iceI_NextFocus, context).get(); + } + + template class P = ::std::promise> + auto NextFocusAsync(const ::Ice::Context& context = Ice::noExplicitContext) + -> decltype(::std::declval>().get_future()) + { + return _makePromiseOutgoing(false, this, &ATCDisplay::AirportInterfacePrx::_iceI_NextFocus, context); + } + + ::std::function + NextFocusAsync(::std::function response, + ::std::function ex = nullptr, + ::std::function sent = nullptr, + const ::Ice::Context& context = Ice::noExplicitContext) + { + return _makeLamdaOutgoing(response, ex, sent, this, &ATCDisplay::AirportInterfacePrx::_iceI_NextFocus, context); + } + + void _iceI_NextFocus(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT>&, const ::Ice::Context&); + + float getSimT(const ::Ice::Context& context = Ice::noExplicitContext) + { + return _makePromiseOutgoing(true, this, &ATCDisplay::AirportInterfacePrx::_iceI_getSimT, context).get(); + } + + template class P = ::std::promise> + auto getSimTAsync(const ::Ice::Context& context = Ice::noExplicitContext) + -> decltype(::std::declval>().get_future()) + { + return _makePromiseOutgoing(false, this, &ATCDisplay::AirportInterfacePrx::_iceI_getSimT, context); + } + + ::std::function + getSimTAsync(::std::function response, + ::std::function ex = nullptr, + ::std::function sent = nullptr, + const ::Ice::Context& context = Ice::noExplicitContext) + { + return _makeLamdaOutgoing(response, ex, sent, this, &ATCDisplay::AirportInterfacePrx::_iceI_getSimT, context); + } + + void _iceI_getSimT(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT>&, const ::Ice::Context&); + + int getMaxFlights(const ::Ice::Context& context = Ice::noExplicitContext) + { + return _makePromiseOutgoing(true, this, &ATCDisplay::AirportInterfacePrx::_iceI_getMaxFlights, context).get(); + } + + template class P = ::std::promise> + auto getMaxFlightsAsync(const ::Ice::Context& context = Ice::noExplicitContext) + -> decltype(::std::declval>().get_future()) + { + return _makePromiseOutgoing(false, this, &ATCDisplay::AirportInterfacePrx::_iceI_getMaxFlights, context); + } + + ::std::function + getMaxFlightsAsync(::std::function response, + ::std::function ex = nullptr, + ::std::function sent = nullptr, + const ::Ice::Context& context = Ice::noExplicitContext) + { + return _makeLamdaOutgoing(response, ex, sent, this, &ATCDisplay::AirportInterfacePrx::_iceI_getMaxFlights, context); + } + + void _iceI_getMaxFlights(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT>&, const ::Ice::Context&); + + int getPoints(const ::Ice::Context& context = Ice::noExplicitContext) + { + return _makePromiseOutgoing(true, this, &ATCDisplay::AirportInterfacePrx::_iceI_getPoints, context).get(); + } + + template class P = ::std::promise> + auto getPointsAsync(const ::Ice::Context& context = Ice::noExplicitContext) + -> decltype(::std::declval>().get_future()) + { + return _makePromiseOutgoing(false, this, &ATCDisplay::AirportInterfacePrx::_iceI_getPoints, context); + } + + ::std::function + getPointsAsync(::std::function response, + ::std::function ex = nullptr, + ::std::function sent = nullptr, + const ::Ice::Context& context = Ice::noExplicitContext) + { + return _makeLamdaOutgoing(response, ex, sent, this, &ATCDisplay::AirportInterfacePrx::_iceI_getPoints, context); + } + + void _iceI_getPoints(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT>&, const ::Ice::Context&); + + static const ::std::string& ice_staticId(); + +protected: + + AirportInterfacePrx() = default; + friend ::std::shared_ptr IceInternal::createProxy(); + + virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override; +}; + +} + +namespace Ice +{ + +template<> +struct StreamableTraits<::ATCDisplay::ATCDPosition> +{ + static const StreamHelperCategory helper = StreamHelperCategoryStruct; + static const int minWireSize = 13; + static const bool fixedLength = false; +}; + +template +struct StreamReader<::ATCDisplay::ATCDPosition, S> +{ + static void read(S* istr, ::ATCDisplay::ATCDPosition& v) + { + istr->readAll(v.name, v.x, v.y, v.z); + } +}; + +template<> +struct StreamableTraits<::ATCDisplay::ATCDStorm> +{ + static const StreamHelperCategory helper = StreamHelperCategoryStruct; + static const int minWireSize = 30; + static const bool fixedLength = false; +}; + +template +struct StreamReader<::ATCDisplay::ATCDStorm, S> +{ + static void read(S* istr, ::ATCDisplay::ATCDStorm& v) + { + istr->readAll(v.valid, v.speed, v.pos, v.bearing, v.radious, v.height); + } +}; + +template<> +struct StreamableTraits<::ATCDisplay::ATCDFlight> +{ + static const StreamHelperCategory helper = StreamHelperCategoryStruct; + static const int minWireSize = 36; + static const bool fixedLength = false; +}; + +template +struct StreamReader<::ATCDisplay::ATCDFlight, S> +{ + static void read(S* istr, ::ATCDisplay::ATCDFlight& v) + { + istr->readAll(v.points, v.speed, v.focused, v.id, v.pos, v.inclination, v.bearing, v.collisionRadious, v.flightRoute); + } +}; + +template<> +struct StreamableTraits<::ATCDisplay::ATCDLandStrip> +{ + static const StreamHelperCategory helper = StreamHelperCategoryStruct; + static const int minWireSize = 25; + static const bool fixedLength = false; +}; + +template +struct StreamReader<::ATCDisplay::ATCDLandStrip, S> +{ + static void read(S* istr, ::ATCDisplay::ATCDLandStrip& v) + { + istr->readAll(v.pos, v.width, v.length, v.orientation); + } +}; + +template<> +struct StreamableTraits<::ATCDisplay::ATCDAirport> +{ + static const StreamHelperCategory helper = StreamHelperCategoryStruct; + static const int minWireSize = 5; + static const bool fixedLength = false; +}; + +template +struct StreamReader<::ATCDisplay::ATCDAirport, S> +{ + static void read(S* istr, ::ATCDisplay::ATCDAirport& v) + { + istr->readAll(v.airportLandstrips, v.radious); + } +}; + +} + +namespace ATCDisplay +{ + +using AirportInterfacePtr = ::std::shared_ptr; +using AirportInterfacePrxPtr = ::std::shared_ptr; + +} + +#else // C++98 mapping + +namespace IceProxy +{ + +namespace ATCDisplay +{ + +class AirportInterface; +void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< ::IceProxy::ATCDisplay::AirportInterface>&); +::IceProxy::Ice::Object* upCast(::IceProxy::ATCDisplay::AirportInterface*); + +} + +} + +namespace ATCDisplay +{ + +class AirportInterface; +::Ice::Object* upCast(::ATCDisplay::AirportInterface*); +typedef ::IceInternal::Handle< ::ATCDisplay::AirportInterface> AirportInterfacePtr; +typedef ::IceInternal::ProxyHandle< ::IceProxy::ATCDisplay::AirportInterface> AirportInterfacePrx; +typedef AirportInterfacePrx AirportInterfacePrxPtr; +void _icePatchObjectPtr(AirportInterfacePtr&, const ::Ice::ObjectPtr&); + +} + +namespace ATCDisplay +{ + +struct ATCDPosition +{ + ::std::string name; + ::Ice::Float x; + ::Ice::Float y; + ::Ice::Float z; +}; + +typedef ::std::vector< ::ATCDisplay::ATCDPosition> ATCDRoute; + +struct ATCDStorm +{ + bool valid; + ::Ice::Float speed; + ::ATCDisplay::ATCDPosition pos; + ::Ice::Float bearing; + ::Ice::Float radious; + ::Ice::Float height; +}; + +struct ATCDFlight +{ + ::Ice::Float points; + ::Ice::Float speed; + bool focused; + ::std::string id; + ::ATCDisplay::ATCDPosition pos; + ::Ice::Float inclination; + ::Ice::Float bearing; + ::Ice::Float collisionRadious; + ::ATCDisplay::ATCDRoute flightRoute; +}; + +typedef ::std::vector< ::ATCDisplay::ATCDFlight> ATCDFlights; + +struct ATCDLandStrip +{ + ::ATCDisplay::ATCDPosition pos; + ::Ice::Float width; + ::Ice::Float length; + ::Ice::Float orientation; +}; + +typedef ::std::vector< ::ATCDisplay::ATCDLandStrip> ATCDLandStrips; + +struct ATCDAirport +{ + ::ATCDisplay::ATCDLandStrips airportLandstrips; + ::Ice::Float radious; +}; + +} + +namespace ATCDisplay +{ + +class Callback_AirportInterface_getFlights_Base : public virtual ::IceInternal::CallbackBase { }; +typedef ::IceUtil::Handle< Callback_AirportInterface_getFlights_Base> Callback_AirportInterface_getFlightsPtr; + +class Callback_AirportInterface_getStorm_Base : public virtual ::IceInternal::CallbackBase { }; +typedef ::IceUtil::Handle< Callback_AirportInterface_getStorm_Base> Callback_AirportInterface_getStormPtr; + +class Callback_AirportInterface_getAirportInfo_Base : public virtual ::IceInternal::CallbackBase { }; +typedef ::IceUtil::Handle< Callback_AirportInterface_getAirportInfo_Base> Callback_AirportInterface_getAirportInfoPtr; + +class Callback_AirportInterface_UpdateSimT_Base : public virtual ::IceInternal::CallbackBase { }; +typedef ::IceUtil::Handle< Callback_AirportInterface_UpdateSimT_Base> Callback_AirportInterface_UpdateSimTPtr; + +class Callback_AirportInterface_NextFocus_Base : public virtual ::IceInternal::CallbackBase { }; +typedef ::IceUtil::Handle< Callback_AirportInterface_NextFocus_Base> Callback_AirportInterface_NextFocusPtr; + +class Callback_AirportInterface_getSimT_Base : public virtual ::IceInternal::CallbackBase { }; +typedef ::IceUtil::Handle< Callback_AirportInterface_getSimT_Base> Callback_AirportInterface_getSimTPtr; + +class Callback_AirportInterface_getMaxFlights_Base : public virtual ::IceInternal::CallbackBase { }; +typedef ::IceUtil::Handle< Callback_AirportInterface_getMaxFlights_Base> Callback_AirportInterface_getMaxFlightsPtr; + +class Callback_AirportInterface_getPoints_Base : public virtual ::IceInternal::CallbackBase { }; +typedef ::IceUtil::Handle< Callback_AirportInterface_getPoints_Base> Callback_AirportInterface_getPointsPtr; + +} + +namespace IceProxy +{ + +namespace ATCDisplay +{ + +class AirportInterface : public virtual ::Ice::Proxy +{ +public: + + ::ATCDisplay::ATCDFlights getFlights(const ::Ice::Context& context = ::Ice::noExplicitContext) + { + return end_getFlights(_iceI_begin_getFlights(context, ::IceInternal::dummyCallback, 0, true)); + } + + ::Ice::AsyncResultPtr begin_getFlights(const ::Ice::Context& context = ::Ice::noExplicitContext) + { + return _iceI_begin_getFlights(context, ::IceInternal::dummyCallback, 0); + } + + ::Ice::AsyncResultPtr begin_getFlights(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getFlights(::Ice::noExplicitContext, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getFlights(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getFlights(context, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getFlights(const ::ATCDisplay::Callback_AirportInterface_getFlightsPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getFlights(::Ice::noExplicitContext, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getFlights(const ::Ice::Context& context, const ::ATCDisplay::Callback_AirportInterface_getFlightsPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getFlights(context, del, cookie); + } + + ::ATCDisplay::ATCDFlights end_getFlights(const ::Ice::AsyncResultPtr&); + +private: + + ::Ice::AsyncResultPtr _iceI_begin_getFlights(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false); + +public: + + ::ATCDisplay::ATCDStorm getStorm(const ::Ice::Context& context = ::Ice::noExplicitContext) + { + return end_getStorm(_iceI_begin_getStorm(context, ::IceInternal::dummyCallback, 0, true)); + } + + ::Ice::AsyncResultPtr begin_getStorm(const ::Ice::Context& context = ::Ice::noExplicitContext) + { + return _iceI_begin_getStorm(context, ::IceInternal::dummyCallback, 0); + } + + ::Ice::AsyncResultPtr begin_getStorm(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getStorm(::Ice::noExplicitContext, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getStorm(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getStorm(context, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getStorm(const ::ATCDisplay::Callback_AirportInterface_getStormPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getStorm(::Ice::noExplicitContext, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getStorm(const ::Ice::Context& context, const ::ATCDisplay::Callback_AirportInterface_getStormPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getStorm(context, del, cookie); + } + + ::ATCDisplay::ATCDStorm end_getStorm(const ::Ice::AsyncResultPtr&); + +private: + + ::Ice::AsyncResultPtr _iceI_begin_getStorm(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false); + +public: + + ::ATCDisplay::ATCDAirport getAirportInfo(const ::Ice::Context& context = ::Ice::noExplicitContext) + { + return end_getAirportInfo(_iceI_begin_getAirportInfo(context, ::IceInternal::dummyCallback, 0, true)); + } + + ::Ice::AsyncResultPtr begin_getAirportInfo(const ::Ice::Context& context = ::Ice::noExplicitContext) + { + return _iceI_begin_getAirportInfo(context, ::IceInternal::dummyCallback, 0); + } + + ::Ice::AsyncResultPtr begin_getAirportInfo(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getAirportInfo(::Ice::noExplicitContext, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getAirportInfo(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getAirportInfo(context, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getAirportInfo(const ::ATCDisplay::Callback_AirportInterface_getAirportInfoPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getAirportInfo(::Ice::noExplicitContext, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getAirportInfo(const ::Ice::Context& context, const ::ATCDisplay::Callback_AirportInterface_getAirportInfoPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getAirportInfo(context, del, cookie); + } + + ::ATCDisplay::ATCDAirport end_getAirportInfo(const ::Ice::AsyncResultPtr&); + +private: + + ::Ice::AsyncResultPtr _iceI_begin_getAirportInfo(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false); + +public: + + void UpdateSimT(::Ice::Float iceP_inc, const ::Ice::Context& context = ::Ice::noExplicitContext) + { + end_UpdateSimT(_iceI_begin_UpdateSimT(iceP_inc, context, ::IceInternal::dummyCallback, 0, true)); + } + + ::Ice::AsyncResultPtr begin_UpdateSimT(::Ice::Float iceP_inc, const ::Ice::Context& context = ::Ice::noExplicitContext) + { + return _iceI_begin_UpdateSimT(iceP_inc, context, ::IceInternal::dummyCallback, 0); + } + + ::Ice::AsyncResultPtr begin_UpdateSimT(::Ice::Float iceP_inc, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_UpdateSimT(iceP_inc, ::Ice::noExplicitContext, del, cookie); + } + + ::Ice::AsyncResultPtr begin_UpdateSimT(::Ice::Float iceP_inc, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_UpdateSimT(iceP_inc, context, del, cookie); + } + + ::Ice::AsyncResultPtr begin_UpdateSimT(::Ice::Float iceP_inc, const ::ATCDisplay::Callback_AirportInterface_UpdateSimTPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_UpdateSimT(iceP_inc, ::Ice::noExplicitContext, del, cookie); + } + + ::Ice::AsyncResultPtr begin_UpdateSimT(::Ice::Float iceP_inc, const ::Ice::Context& context, const ::ATCDisplay::Callback_AirportInterface_UpdateSimTPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_UpdateSimT(iceP_inc, context, del, cookie); + } + + void end_UpdateSimT(const ::Ice::AsyncResultPtr&); + +private: + + ::Ice::AsyncResultPtr _iceI_begin_UpdateSimT(::Ice::Float, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false); + +public: + + void NextFocus(const ::Ice::Context& context = ::Ice::noExplicitContext) + { + end_NextFocus(_iceI_begin_NextFocus(context, ::IceInternal::dummyCallback, 0, true)); + } + + ::Ice::AsyncResultPtr begin_NextFocus(const ::Ice::Context& context = ::Ice::noExplicitContext) + { + return _iceI_begin_NextFocus(context, ::IceInternal::dummyCallback, 0); + } + + ::Ice::AsyncResultPtr begin_NextFocus(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_NextFocus(::Ice::noExplicitContext, del, cookie); + } + + ::Ice::AsyncResultPtr begin_NextFocus(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_NextFocus(context, del, cookie); + } + + ::Ice::AsyncResultPtr begin_NextFocus(const ::ATCDisplay::Callback_AirportInterface_NextFocusPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_NextFocus(::Ice::noExplicitContext, del, cookie); + } + + ::Ice::AsyncResultPtr begin_NextFocus(const ::Ice::Context& context, const ::ATCDisplay::Callback_AirportInterface_NextFocusPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_NextFocus(context, del, cookie); + } + + void end_NextFocus(const ::Ice::AsyncResultPtr&); + +private: + + ::Ice::AsyncResultPtr _iceI_begin_NextFocus(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false); + +public: + + ::Ice::Float getSimT(const ::Ice::Context& context = ::Ice::noExplicitContext) + { + return end_getSimT(_iceI_begin_getSimT(context, ::IceInternal::dummyCallback, 0, true)); + } + + ::Ice::AsyncResultPtr begin_getSimT(const ::Ice::Context& context = ::Ice::noExplicitContext) + { + return _iceI_begin_getSimT(context, ::IceInternal::dummyCallback, 0); + } + + ::Ice::AsyncResultPtr begin_getSimT(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getSimT(::Ice::noExplicitContext, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getSimT(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getSimT(context, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getSimT(const ::ATCDisplay::Callback_AirportInterface_getSimTPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getSimT(::Ice::noExplicitContext, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getSimT(const ::Ice::Context& context, const ::ATCDisplay::Callback_AirportInterface_getSimTPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getSimT(context, del, cookie); + } + + ::Ice::Float end_getSimT(const ::Ice::AsyncResultPtr&); + +private: + + ::Ice::AsyncResultPtr _iceI_begin_getSimT(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false); + +public: + + ::Ice::Int getMaxFlights(const ::Ice::Context& context = ::Ice::noExplicitContext) + { + return end_getMaxFlights(_iceI_begin_getMaxFlights(context, ::IceInternal::dummyCallback, 0, true)); + } + + ::Ice::AsyncResultPtr begin_getMaxFlights(const ::Ice::Context& context = ::Ice::noExplicitContext) + { + return _iceI_begin_getMaxFlights(context, ::IceInternal::dummyCallback, 0); + } + + ::Ice::AsyncResultPtr begin_getMaxFlights(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getMaxFlights(::Ice::noExplicitContext, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getMaxFlights(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getMaxFlights(context, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getMaxFlights(const ::ATCDisplay::Callback_AirportInterface_getMaxFlightsPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getMaxFlights(::Ice::noExplicitContext, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getMaxFlights(const ::Ice::Context& context, const ::ATCDisplay::Callback_AirportInterface_getMaxFlightsPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getMaxFlights(context, del, cookie); + } + + ::Ice::Int end_getMaxFlights(const ::Ice::AsyncResultPtr&); + +private: + + ::Ice::AsyncResultPtr _iceI_begin_getMaxFlights(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false); + +public: + + ::Ice::Int getPoints(const ::Ice::Context& context = ::Ice::noExplicitContext) + { + return end_getPoints(_iceI_begin_getPoints(context, ::IceInternal::dummyCallback, 0, true)); + } + + ::Ice::AsyncResultPtr begin_getPoints(const ::Ice::Context& context = ::Ice::noExplicitContext) + { + return _iceI_begin_getPoints(context, ::IceInternal::dummyCallback, 0); + } + + ::Ice::AsyncResultPtr begin_getPoints(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getPoints(::Ice::noExplicitContext, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getPoints(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getPoints(context, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getPoints(const ::ATCDisplay::Callback_AirportInterface_getPointsPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getPoints(::Ice::noExplicitContext, del, cookie); + } + + ::Ice::AsyncResultPtr begin_getPoints(const ::Ice::Context& context, const ::ATCDisplay::Callback_AirportInterface_getPointsPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) + { + return _iceI_begin_getPoints(context, del, cookie); + } + + ::Ice::Int end_getPoints(const ::Ice::AsyncResultPtr&); + +private: + + ::Ice::AsyncResultPtr _iceI_begin_getPoints(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false); + +public: + + static const ::std::string& ice_staticId(); + +protected: + + virtual ::IceProxy::Ice::Object* _newInstance() const; +}; + +} + +} + +namespace ATCDisplay +{ + +class AirportInterface : public virtual ::Ice::Object +{ +public: + + typedef AirportInterfacePrx ProxyType; + typedef AirportInterfacePtr PointerType; + + virtual ~AirportInterface(); + + virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::emptyCurrent) const; + virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::emptyCurrent) const; + virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::emptyCurrent) const; + + static const ::std::string& ice_staticId(); + + virtual ::ATCDisplay::ATCDFlights getFlights(const ::Ice::Current& = ::Ice::emptyCurrent) = 0; + bool _iceD_getFlights(::IceInternal::Incoming&, const ::Ice::Current&); + + virtual ::ATCDisplay::ATCDStorm getStorm(const ::Ice::Current& = ::Ice::emptyCurrent) = 0; + bool _iceD_getStorm(::IceInternal::Incoming&, const ::Ice::Current&); + + virtual ::ATCDisplay::ATCDAirport getAirportInfo(const ::Ice::Current& = ::Ice::emptyCurrent) = 0; + bool _iceD_getAirportInfo(::IceInternal::Incoming&, const ::Ice::Current&); + + virtual void UpdateSimT(::Ice::Float, const ::Ice::Current& = ::Ice::emptyCurrent) = 0; + bool _iceD_UpdateSimT(::IceInternal::Incoming&, const ::Ice::Current&); + + virtual void NextFocus(const ::Ice::Current& = ::Ice::emptyCurrent) = 0; + bool _iceD_NextFocus(::IceInternal::Incoming&, const ::Ice::Current&); + + virtual ::Ice::Float getSimT(const ::Ice::Current& = ::Ice::emptyCurrent) = 0; + bool _iceD_getSimT(::IceInternal::Incoming&, const ::Ice::Current&); + + virtual ::Ice::Int getMaxFlights(const ::Ice::Current& = ::Ice::emptyCurrent) = 0; + bool _iceD_getMaxFlights(::IceInternal::Incoming&, const ::Ice::Current&); + + virtual ::Ice::Int getPoints(const ::Ice::Current& = ::Ice::emptyCurrent) = 0; + bool _iceD_getPoints(::IceInternal::Incoming&, const ::Ice::Current&); + + virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&); + +protected: + + virtual void _iceWriteImpl(::Ice::OutputStream*) const; + virtual void _iceReadImpl(::Ice::InputStream*); +}; + +inline bool operator==(const AirportInterface& lhs, const AirportInterface& rhs) +{ + return static_cast(lhs) == static_cast(rhs); +} + +inline bool operator<(const AirportInterface& lhs, const AirportInterface& rhs) +{ + return static_cast(lhs) < static_cast(rhs); +} + +} + +namespace Ice +{ + +template<> +struct StreamableTraits< ::ATCDisplay::ATCDPosition> +{ + static const StreamHelperCategory helper = StreamHelperCategoryStruct; + static const int minWireSize = 13; + static const bool fixedLength = false; +}; + +template +struct StreamWriter< ::ATCDisplay::ATCDPosition, S> +{ + static void write(S* ostr, const ::ATCDisplay::ATCDPosition& v) + { + ostr->write(v.name); + ostr->write(v.x); + ostr->write(v.y); + ostr->write(v.z); + } +}; + +template +struct StreamReader< ::ATCDisplay::ATCDPosition, S> +{ + static void read(S* istr, ::ATCDisplay::ATCDPosition& v) + { + istr->read(v.name); + istr->read(v.x); + istr->read(v.y); + istr->read(v.z); + } +}; + +template<> +struct StreamableTraits< ::ATCDisplay::ATCDStorm> +{ + static const StreamHelperCategory helper = StreamHelperCategoryStruct; + static const int minWireSize = 30; + static const bool fixedLength = false; +}; + +template +struct StreamWriter< ::ATCDisplay::ATCDStorm, S> +{ + static void write(S* ostr, const ::ATCDisplay::ATCDStorm& v) + { + ostr->write(v.valid); + ostr->write(v.speed); + ostr->write(v.pos); + ostr->write(v.bearing); + ostr->write(v.radious); + ostr->write(v.height); + } +}; + +template +struct StreamReader< ::ATCDisplay::ATCDStorm, S> +{ + static void read(S* istr, ::ATCDisplay::ATCDStorm& v) + { + istr->read(v.valid); + istr->read(v.speed); + istr->read(v.pos); + istr->read(v.bearing); + istr->read(v.radious); + istr->read(v.height); + } +}; + +template<> +struct StreamableTraits< ::ATCDisplay::ATCDFlight> +{ + static const StreamHelperCategory helper = StreamHelperCategoryStruct; + static const int minWireSize = 36; + static const bool fixedLength = false; +}; + +template +struct StreamWriter< ::ATCDisplay::ATCDFlight, S> +{ + static void write(S* ostr, const ::ATCDisplay::ATCDFlight& v) + { + ostr->write(v.points); + ostr->write(v.speed); + ostr->write(v.focused); + ostr->write(v.id); + ostr->write(v.pos); + ostr->write(v.inclination); + ostr->write(v.bearing); + ostr->write(v.collisionRadious); + ostr->write(v.flightRoute); + } +}; + +template +struct StreamReader< ::ATCDisplay::ATCDFlight, S> +{ + static void read(S* istr, ::ATCDisplay::ATCDFlight& v) + { + istr->read(v.points); + istr->read(v.speed); + istr->read(v.focused); + istr->read(v.id); + istr->read(v.pos); + istr->read(v.inclination); + istr->read(v.bearing); + istr->read(v.collisionRadious); + istr->read(v.flightRoute); + } +}; + +template<> +struct StreamableTraits< ::ATCDisplay::ATCDLandStrip> +{ + static const StreamHelperCategory helper = StreamHelperCategoryStruct; + static const int minWireSize = 25; + static const bool fixedLength = false; +}; + +template +struct StreamWriter< ::ATCDisplay::ATCDLandStrip, S> +{ + static void write(S* ostr, const ::ATCDisplay::ATCDLandStrip& v) + { + ostr->write(v.pos); + ostr->write(v.width); + ostr->write(v.length); + ostr->write(v.orientation); + } +}; + +template +struct StreamReader< ::ATCDisplay::ATCDLandStrip, S> +{ + static void read(S* istr, ::ATCDisplay::ATCDLandStrip& v) + { + istr->read(v.pos); + istr->read(v.width); + istr->read(v.length); + istr->read(v.orientation); + } +}; + +template<> +struct StreamableTraits< ::ATCDisplay::ATCDAirport> +{ + static const StreamHelperCategory helper = StreamHelperCategoryStruct; + static const int minWireSize = 5; + static const bool fixedLength = false; +}; + +template +struct StreamWriter< ::ATCDisplay::ATCDAirport, S> +{ + static void write(S* ostr, const ::ATCDisplay::ATCDAirport& v) + { + ostr->write(v.airportLandstrips); + ostr->write(v.radious); + } +}; + +template +struct StreamReader< ::ATCDisplay::ATCDAirport, S> +{ + static void read(S* istr, ::ATCDisplay::ATCDAirport& v) + { + istr->read(v.airportLandstrips); + istr->read(v.radious); + } +}; + +} + +namespace ATCDisplay +{ + +template +class CallbackNC_AirportInterface_getFlights : public Callback_AirportInterface_getFlights_Base, public ::IceInternal::TwowayCallbackNC +{ +public: + + typedef IceUtil::Handle TPtr; + + typedef void (T::*Exception)(const ::Ice::Exception&); + typedef void (T::*Sent)(bool); + typedef void (T::*Response)(const ::ATCDisplay::ATCDFlights&); + + CallbackNC_AirportInterface_getFlights(const TPtr& obj, Response cb, Exception excb, Sent sentcb) + : ::IceInternal::TwowayCallbackNC(obj, cb != 0, excb, sentcb), _response(cb) + { + } + + virtual void completed(const ::Ice::AsyncResultPtr& result) const + { + ::ATCDisplay::AirportInterfacePrx proxy = ::ATCDisplay::AirportInterfacePrx::uncheckedCast(result->getProxy()); + ::ATCDisplay::ATCDFlights ret; + try + { + ret = proxy->end_getFlights(result); + } + catch(const ::Ice::Exception& ex) + { + ::IceInternal::CallbackNC::exception(result, ex); + return; + } + if(_response) + { + (::IceInternal::CallbackNC::_callback.get()->*_response)(ret); + } + } + +private: + + Response _response; +}; + +template Callback_AirportInterface_getFlightsPtr +newCallback_AirportInterface_getFlights(const IceUtil::Handle& instance, void (T::*cb)(const ::ATCDisplay::ATCDFlights&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_getFlights(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_getFlightsPtr +newCallback_AirportInterface_getFlights(T* instance, void (T::*cb)(const ::ATCDisplay::ATCDFlights&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_getFlights(instance, cb, excb, sentcb); +} + +template +class Callback_AirportInterface_getFlights : public Callback_AirportInterface_getFlights_Base, public ::IceInternal::TwowayCallback +{ +public: + + typedef IceUtil::Handle TPtr; + + typedef void (T::*Exception)(const ::Ice::Exception& , const CT&); + typedef void (T::*Sent)(bool , const CT&); + typedef void (T::*Response)(const ::ATCDisplay::ATCDFlights&, const CT&); + + Callback_AirportInterface_getFlights(const TPtr& obj, Response cb, Exception excb, Sent sentcb) + : ::IceInternal::TwowayCallback(obj, cb != 0, excb, sentcb), _response(cb) + { + } + + virtual void completed(const ::Ice::AsyncResultPtr& result) const + { + ::ATCDisplay::AirportInterfacePrx proxy = ::ATCDisplay::AirportInterfacePrx::uncheckedCast(result->getProxy()); + ::ATCDisplay::ATCDFlights ret; + try + { + ret = proxy->end_getFlights(result); + } + catch(const ::Ice::Exception& ex) + { + ::IceInternal::Callback::exception(result, ex); + return; + } + if(_response) + { + (::IceInternal::Callback::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie())); + } + } + +private: + + Response _response; +}; + +template Callback_AirportInterface_getFlightsPtr +newCallback_AirportInterface_getFlights(const IceUtil::Handle& instance, void (T::*cb)(const ::ATCDisplay::ATCDFlights&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_getFlights(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_getFlightsPtr +newCallback_AirportInterface_getFlights(T* instance, void (T::*cb)(const ::ATCDisplay::ATCDFlights&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_getFlights(instance, cb, excb, sentcb); +} + +template +class CallbackNC_AirportInterface_getStorm : public Callback_AirportInterface_getStorm_Base, public ::IceInternal::TwowayCallbackNC +{ +public: + + typedef IceUtil::Handle TPtr; + + typedef void (T::*Exception)(const ::Ice::Exception&); + typedef void (T::*Sent)(bool); + typedef void (T::*Response)(const ::ATCDisplay::ATCDStorm&); + + CallbackNC_AirportInterface_getStorm(const TPtr& obj, Response cb, Exception excb, Sent sentcb) + : ::IceInternal::TwowayCallbackNC(obj, cb != 0, excb, sentcb), _response(cb) + { + } + + virtual void completed(const ::Ice::AsyncResultPtr& result) const + { + ::ATCDisplay::AirportInterfacePrx proxy = ::ATCDisplay::AirportInterfacePrx::uncheckedCast(result->getProxy()); + ::ATCDisplay::ATCDStorm ret; + try + { + ret = proxy->end_getStorm(result); + } + catch(const ::Ice::Exception& ex) + { + ::IceInternal::CallbackNC::exception(result, ex); + return; + } + if(_response) + { + (::IceInternal::CallbackNC::_callback.get()->*_response)(ret); + } + } + +private: + + Response _response; +}; + +template Callback_AirportInterface_getStormPtr +newCallback_AirportInterface_getStorm(const IceUtil::Handle& instance, void (T::*cb)(const ::ATCDisplay::ATCDStorm&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_getStorm(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_getStormPtr +newCallback_AirportInterface_getStorm(T* instance, void (T::*cb)(const ::ATCDisplay::ATCDStorm&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_getStorm(instance, cb, excb, sentcb); +} + +template +class Callback_AirportInterface_getStorm : public Callback_AirportInterface_getStorm_Base, public ::IceInternal::TwowayCallback +{ +public: + + typedef IceUtil::Handle TPtr; + + typedef void (T::*Exception)(const ::Ice::Exception& , const CT&); + typedef void (T::*Sent)(bool , const CT&); + typedef void (T::*Response)(const ::ATCDisplay::ATCDStorm&, const CT&); + + Callback_AirportInterface_getStorm(const TPtr& obj, Response cb, Exception excb, Sent sentcb) + : ::IceInternal::TwowayCallback(obj, cb != 0, excb, sentcb), _response(cb) + { + } + + virtual void completed(const ::Ice::AsyncResultPtr& result) const + { + ::ATCDisplay::AirportInterfacePrx proxy = ::ATCDisplay::AirportInterfacePrx::uncheckedCast(result->getProxy()); + ::ATCDisplay::ATCDStorm ret; + try + { + ret = proxy->end_getStorm(result); + } + catch(const ::Ice::Exception& ex) + { + ::IceInternal::Callback::exception(result, ex); + return; + } + if(_response) + { + (::IceInternal::Callback::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie())); + } + } + +private: + + Response _response; +}; + +template Callback_AirportInterface_getStormPtr +newCallback_AirportInterface_getStorm(const IceUtil::Handle& instance, void (T::*cb)(const ::ATCDisplay::ATCDStorm&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_getStorm(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_getStormPtr +newCallback_AirportInterface_getStorm(T* instance, void (T::*cb)(const ::ATCDisplay::ATCDStorm&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_getStorm(instance, cb, excb, sentcb); +} + +template +class CallbackNC_AirportInterface_getAirportInfo : public Callback_AirportInterface_getAirportInfo_Base, public ::IceInternal::TwowayCallbackNC +{ +public: + + typedef IceUtil::Handle TPtr; + + typedef void (T::*Exception)(const ::Ice::Exception&); + typedef void (T::*Sent)(bool); + typedef void (T::*Response)(const ::ATCDisplay::ATCDAirport&); + + CallbackNC_AirportInterface_getAirportInfo(const TPtr& obj, Response cb, Exception excb, Sent sentcb) + : ::IceInternal::TwowayCallbackNC(obj, cb != 0, excb, sentcb), _response(cb) + { + } + + virtual void completed(const ::Ice::AsyncResultPtr& result) const + { + ::ATCDisplay::AirportInterfacePrx proxy = ::ATCDisplay::AirportInterfacePrx::uncheckedCast(result->getProxy()); + ::ATCDisplay::ATCDAirport ret; + try + { + ret = proxy->end_getAirportInfo(result); + } + catch(const ::Ice::Exception& ex) + { + ::IceInternal::CallbackNC::exception(result, ex); + return; + } + if(_response) + { + (::IceInternal::CallbackNC::_callback.get()->*_response)(ret); + } + } + +private: + + Response _response; +}; + +template Callback_AirportInterface_getAirportInfoPtr +newCallback_AirportInterface_getAirportInfo(const IceUtil::Handle& instance, void (T::*cb)(const ::ATCDisplay::ATCDAirport&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_getAirportInfo(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_getAirportInfoPtr +newCallback_AirportInterface_getAirportInfo(T* instance, void (T::*cb)(const ::ATCDisplay::ATCDAirport&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_getAirportInfo(instance, cb, excb, sentcb); +} + +template +class Callback_AirportInterface_getAirportInfo : public Callback_AirportInterface_getAirportInfo_Base, public ::IceInternal::TwowayCallback +{ +public: + + typedef IceUtil::Handle TPtr; + + typedef void (T::*Exception)(const ::Ice::Exception& , const CT&); + typedef void (T::*Sent)(bool , const CT&); + typedef void (T::*Response)(const ::ATCDisplay::ATCDAirport&, const CT&); + + Callback_AirportInterface_getAirportInfo(const TPtr& obj, Response cb, Exception excb, Sent sentcb) + : ::IceInternal::TwowayCallback(obj, cb != 0, excb, sentcb), _response(cb) + { + } + + virtual void completed(const ::Ice::AsyncResultPtr& result) const + { + ::ATCDisplay::AirportInterfacePrx proxy = ::ATCDisplay::AirportInterfacePrx::uncheckedCast(result->getProxy()); + ::ATCDisplay::ATCDAirport ret; + try + { + ret = proxy->end_getAirportInfo(result); + } + catch(const ::Ice::Exception& ex) + { + ::IceInternal::Callback::exception(result, ex); + return; + } + if(_response) + { + (::IceInternal::Callback::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie())); + } + } + +private: + + Response _response; +}; + +template Callback_AirportInterface_getAirportInfoPtr +newCallback_AirportInterface_getAirportInfo(const IceUtil::Handle& instance, void (T::*cb)(const ::ATCDisplay::ATCDAirport&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_getAirportInfo(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_getAirportInfoPtr +newCallback_AirportInterface_getAirportInfo(T* instance, void (T::*cb)(const ::ATCDisplay::ATCDAirport&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_getAirportInfo(instance, cb, excb, sentcb); +} + +template +class CallbackNC_AirportInterface_UpdateSimT : public Callback_AirportInterface_UpdateSimT_Base, public ::IceInternal::OnewayCallbackNC +{ +public: + + typedef IceUtil::Handle TPtr; + + typedef void (T::*Exception)(const ::Ice::Exception&); + typedef void (T::*Sent)(bool); + typedef void (T::*Response)(); + + CallbackNC_AirportInterface_UpdateSimT(const TPtr& obj, Response cb, Exception excb, Sent sentcb) + : ::IceInternal::OnewayCallbackNC(obj, cb, excb, sentcb) + { + } +}; + +template Callback_AirportInterface_UpdateSimTPtr +newCallback_AirportInterface_UpdateSimT(const IceUtil::Handle& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_UpdateSimT(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_UpdateSimTPtr +newCallback_AirportInterface_UpdateSimT(const IceUtil::Handle& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_UpdateSimT(instance, 0, excb, sentcb); +} + +template Callback_AirportInterface_UpdateSimTPtr +newCallback_AirportInterface_UpdateSimT(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_UpdateSimT(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_UpdateSimTPtr +newCallback_AirportInterface_UpdateSimT(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_UpdateSimT(instance, 0, excb, sentcb); +} + +template +class Callback_AirportInterface_UpdateSimT : public Callback_AirportInterface_UpdateSimT_Base, public ::IceInternal::OnewayCallback +{ +public: + + typedef IceUtil::Handle TPtr; + + typedef void (T::*Exception)(const ::Ice::Exception& , const CT&); + typedef void (T::*Sent)(bool , const CT&); + typedef void (T::*Response)(const CT&); + + Callback_AirportInterface_UpdateSimT(const TPtr& obj, Response cb, Exception excb, Sent sentcb) + : ::IceInternal::OnewayCallback(obj, cb, excb, sentcb) + { + } +}; + +template Callback_AirportInterface_UpdateSimTPtr +newCallback_AirportInterface_UpdateSimT(const IceUtil::Handle& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_UpdateSimT(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_UpdateSimTPtr +newCallback_AirportInterface_UpdateSimT(const IceUtil::Handle& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_UpdateSimT(instance, 0, excb, sentcb); +} + +template Callback_AirportInterface_UpdateSimTPtr +newCallback_AirportInterface_UpdateSimT(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_UpdateSimT(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_UpdateSimTPtr +newCallback_AirportInterface_UpdateSimT(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_UpdateSimT(instance, 0, excb, sentcb); +} + +template +class CallbackNC_AirportInterface_NextFocus : public Callback_AirportInterface_NextFocus_Base, public ::IceInternal::OnewayCallbackNC +{ +public: + + typedef IceUtil::Handle TPtr; + + typedef void (T::*Exception)(const ::Ice::Exception&); + typedef void (T::*Sent)(bool); + typedef void (T::*Response)(); + + CallbackNC_AirportInterface_NextFocus(const TPtr& obj, Response cb, Exception excb, Sent sentcb) + : ::IceInternal::OnewayCallbackNC(obj, cb, excb, sentcb) + { + } +}; + +template Callback_AirportInterface_NextFocusPtr +newCallback_AirportInterface_NextFocus(const IceUtil::Handle& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_NextFocus(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_NextFocusPtr +newCallback_AirportInterface_NextFocus(const IceUtil::Handle& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_NextFocus(instance, 0, excb, sentcb); +} + +template Callback_AirportInterface_NextFocusPtr +newCallback_AirportInterface_NextFocus(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_NextFocus(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_NextFocusPtr +newCallback_AirportInterface_NextFocus(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_NextFocus(instance, 0, excb, sentcb); +} + +template +class Callback_AirportInterface_NextFocus : public Callback_AirportInterface_NextFocus_Base, public ::IceInternal::OnewayCallback +{ +public: + + typedef IceUtil::Handle TPtr; + + typedef void (T::*Exception)(const ::Ice::Exception& , const CT&); + typedef void (T::*Sent)(bool , const CT&); + typedef void (T::*Response)(const CT&); + + Callback_AirportInterface_NextFocus(const TPtr& obj, Response cb, Exception excb, Sent sentcb) + : ::IceInternal::OnewayCallback(obj, cb, excb, sentcb) + { + } +}; + +template Callback_AirportInterface_NextFocusPtr +newCallback_AirportInterface_NextFocus(const IceUtil::Handle& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_NextFocus(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_NextFocusPtr +newCallback_AirportInterface_NextFocus(const IceUtil::Handle& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_NextFocus(instance, 0, excb, sentcb); +} + +template Callback_AirportInterface_NextFocusPtr +newCallback_AirportInterface_NextFocus(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_NextFocus(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_NextFocusPtr +newCallback_AirportInterface_NextFocus(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_NextFocus(instance, 0, excb, sentcb); +} + +template +class CallbackNC_AirportInterface_getSimT : public Callback_AirportInterface_getSimT_Base, public ::IceInternal::TwowayCallbackNC +{ +public: + + typedef IceUtil::Handle TPtr; + + typedef void (T::*Exception)(const ::Ice::Exception&); + typedef void (T::*Sent)(bool); + typedef void (T::*Response)(::Ice::Float); + + CallbackNC_AirportInterface_getSimT(const TPtr& obj, Response cb, Exception excb, Sent sentcb) + : ::IceInternal::TwowayCallbackNC(obj, cb != 0, excb, sentcb), _response(cb) + { + } + + virtual void completed(const ::Ice::AsyncResultPtr& result) const + { + ::ATCDisplay::AirportInterfacePrx proxy = ::ATCDisplay::AirportInterfacePrx::uncheckedCast(result->getProxy()); + ::Ice::Float ret; + try + { + ret = proxy->end_getSimT(result); + } + catch(const ::Ice::Exception& ex) + { + ::IceInternal::CallbackNC::exception(result, ex); + return; + } + if(_response) + { + (::IceInternal::CallbackNC::_callback.get()->*_response)(ret); + } + } + +private: + + Response _response; +}; + +template Callback_AirportInterface_getSimTPtr +newCallback_AirportInterface_getSimT(const IceUtil::Handle& instance, void (T::*cb)(::Ice::Float), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_getSimT(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_getSimTPtr +newCallback_AirportInterface_getSimT(T* instance, void (T::*cb)(::Ice::Float), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_getSimT(instance, cb, excb, sentcb); +} + +template +class Callback_AirportInterface_getSimT : public Callback_AirportInterface_getSimT_Base, public ::IceInternal::TwowayCallback +{ +public: + + typedef IceUtil::Handle TPtr; + + typedef void (T::*Exception)(const ::Ice::Exception& , const CT&); + typedef void (T::*Sent)(bool , const CT&); + typedef void (T::*Response)(::Ice::Float, const CT&); + + Callback_AirportInterface_getSimT(const TPtr& obj, Response cb, Exception excb, Sent sentcb) + : ::IceInternal::TwowayCallback(obj, cb != 0, excb, sentcb), _response(cb) + { + } + + virtual void completed(const ::Ice::AsyncResultPtr& result) const + { + ::ATCDisplay::AirportInterfacePrx proxy = ::ATCDisplay::AirportInterfacePrx::uncheckedCast(result->getProxy()); + ::Ice::Float ret; + try + { + ret = proxy->end_getSimT(result); + } + catch(const ::Ice::Exception& ex) + { + ::IceInternal::Callback::exception(result, ex); + return; + } + if(_response) + { + (::IceInternal::Callback::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie())); + } + } + +private: + + Response _response; +}; + +template Callback_AirportInterface_getSimTPtr +newCallback_AirportInterface_getSimT(const IceUtil::Handle& instance, void (T::*cb)(::Ice::Float, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_getSimT(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_getSimTPtr +newCallback_AirportInterface_getSimT(T* instance, void (T::*cb)(::Ice::Float, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_getSimT(instance, cb, excb, sentcb); +} + +template +class CallbackNC_AirportInterface_getMaxFlights : public Callback_AirportInterface_getMaxFlights_Base, public ::IceInternal::TwowayCallbackNC +{ +public: + + typedef IceUtil::Handle TPtr; + + typedef void (T::*Exception)(const ::Ice::Exception&); + typedef void (T::*Sent)(bool); + typedef void (T::*Response)(::Ice::Int); + + CallbackNC_AirportInterface_getMaxFlights(const TPtr& obj, Response cb, Exception excb, Sent sentcb) + : ::IceInternal::TwowayCallbackNC(obj, cb != 0, excb, sentcb), _response(cb) + { + } + + virtual void completed(const ::Ice::AsyncResultPtr& result) const + { + ::ATCDisplay::AirportInterfacePrx proxy = ::ATCDisplay::AirportInterfacePrx::uncheckedCast(result->getProxy()); + ::Ice::Int ret; + try + { + ret = proxy->end_getMaxFlights(result); + } + catch(const ::Ice::Exception& ex) + { + ::IceInternal::CallbackNC::exception(result, ex); + return; + } + if(_response) + { + (::IceInternal::CallbackNC::_callback.get()->*_response)(ret); + } + } + +private: + + Response _response; +}; + +template Callback_AirportInterface_getMaxFlightsPtr +newCallback_AirportInterface_getMaxFlights(const IceUtil::Handle& instance, void (T::*cb)(::Ice::Int), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_getMaxFlights(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_getMaxFlightsPtr +newCallback_AirportInterface_getMaxFlights(T* instance, void (T::*cb)(::Ice::Int), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_getMaxFlights(instance, cb, excb, sentcb); +} + +template +class Callback_AirportInterface_getMaxFlights : public Callback_AirportInterface_getMaxFlights_Base, public ::IceInternal::TwowayCallback +{ +public: + + typedef IceUtil::Handle TPtr; + + typedef void (T::*Exception)(const ::Ice::Exception& , const CT&); + typedef void (T::*Sent)(bool , const CT&); + typedef void (T::*Response)(::Ice::Int, const CT&); + + Callback_AirportInterface_getMaxFlights(const TPtr& obj, Response cb, Exception excb, Sent sentcb) + : ::IceInternal::TwowayCallback(obj, cb != 0, excb, sentcb), _response(cb) + { + } + + virtual void completed(const ::Ice::AsyncResultPtr& result) const + { + ::ATCDisplay::AirportInterfacePrx proxy = ::ATCDisplay::AirportInterfacePrx::uncheckedCast(result->getProxy()); + ::Ice::Int ret; + try + { + ret = proxy->end_getMaxFlights(result); + } + catch(const ::Ice::Exception& ex) + { + ::IceInternal::Callback::exception(result, ex); + return; + } + if(_response) + { + (::IceInternal::Callback::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie())); + } + } + +private: + + Response _response; +}; + +template Callback_AirportInterface_getMaxFlightsPtr +newCallback_AirportInterface_getMaxFlights(const IceUtil::Handle& instance, void (T::*cb)(::Ice::Int, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_getMaxFlights(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_getMaxFlightsPtr +newCallback_AirportInterface_getMaxFlights(T* instance, void (T::*cb)(::Ice::Int, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_getMaxFlights(instance, cb, excb, sentcb); +} + +template +class CallbackNC_AirportInterface_getPoints : public Callback_AirportInterface_getPoints_Base, public ::IceInternal::TwowayCallbackNC +{ +public: + + typedef IceUtil::Handle TPtr; + + typedef void (T::*Exception)(const ::Ice::Exception&); + typedef void (T::*Sent)(bool); + typedef void (T::*Response)(::Ice::Int); + + CallbackNC_AirportInterface_getPoints(const TPtr& obj, Response cb, Exception excb, Sent sentcb) + : ::IceInternal::TwowayCallbackNC(obj, cb != 0, excb, sentcb), _response(cb) + { + } + + virtual void completed(const ::Ice::AsyncResultPtr& result) const + { + ::ATCDisplay::AirportInterfacePrx proxy = ::ATCDisplay::AirportInterfacePrx::uncheckedCast(result->getProxy()); + ::Ice::Int ret; + try + { + ret = proxy->end_getPoints(result); + } + catch(const ::Ice::Exception& ex) + { + ::IceInternal::CallbackNC::exception(result, ex); + return; + } + if(_response) + { + (::IceInternal::CallbackNC::_callback.get()->*_response)(ret); + } + } + +private: + + Response _response; +}; + +template Callback_AirportInterface_getPointsPtr +newCallback_AirportInterface_getPoints(const IceUtil::Handle& instance, void (T::*cb)(::Ice::Int), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_getPoints(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_getPointsPtr +newCallback_AirportInterface_getPoints(T* instance, void (T::*cb)(::Ice::Int), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0) +{ + return new CallbackNC_AirportInterface_getPoints(instance, cb, excb, sentcb); +} + +template +class Callback_AirportInterface_getPoints : public Callback_AirportInterface_getPoints_Base, public ::IceInternal::TwowayCallback +{ +public: + + typedef IceUtil::Handle TPtr; + + typedef void (T::*Exception)(const ::Ice::Exception& , const CT&); + typedef void (T::*Sent)(bool , const CT&); + typedef void (T::*Response)(::Ice::Int, const CT&); + + Callback_AirportInterface_getPoints(const TPtr& obj, Response cb, Exception excb, Sent sentcb) + : ::IceInternal::TwowayCallback(obj, cb != 0, excb, sentcb), _response(cb) + { + } + + virtual void completed(const ::Ice::AsyncResultPtr& result) const + { + ::ATCDisplay::AirportInterfacePrx proxy = ::ATCDisplay::AirportInterfacePrx::uncheckedCast(result->getProxy()); + ::Ice::Int ret; + try + { + ret = proxy->end_getPoints(result); + } + catch(const ::Ice::Exception& ex) + { + ::IceInternal::Callback::exception(result, ex); + return; + } + if(_response) + { + (::IceInternal::Callback::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie())); + } + } + +private: + + Response _response; +}; + +template Callback_AirportInterface_getPointsPtr +newCallback_AirportInterface_getPoints(const IceUtil::Handle& instance, void (T::*cb)(::Ice::Int, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_getPoints(instance, cb, excb, sentcb); +} + +template Callback_AirportInterface_getPointsPtr +newCallback_AirportInterface_getPoints(T* instance, void (T::*cb)(::Ice::Int, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0) +{ + return new Callback_AirportInterface_getPoints(instance, cb, excb, sentcb); +} + +} + +#endif + +#include +#endif diff --git a/src/simulator/AirController.cpp b/src/simulator/AirController.cpp index fdeff0f..c9ceffe 100644 --- a/src/simulator/AirController.cpp +++ b/src/simulator/AirController.cpp @@ -29,49 +29,85 @@ #include #include -namespace atcsim{ - -AirController::AirController() { - // TODO Auto-generated constructor stub - -} - -AirController::~AirController() { - // TODO Auto-generated destructor stub -} - -void -AirController::doWork() -{ - std::list flights = Airport::getInstance()->getFlights(); - std::list::iterator it; - - Position pos0(3500.0, 0.0, 100.0); - Position pos1(1500.0, 0.0, 50.0); - Position pos2(200.0, 0.0, 25.0); - Position pos3(-750.0, 0.0, 25.0); - - Route r0, r1, r2, r3; - - r0.pos = pos0; - r0.speed = 500.0; - r1.pos = pos1; - r1.speed = 100.0; - r2.pos = pos2; - r2.speed = 19.0; - r3.pos = pos3; - r3.speed = 15.0; - - for(it = flights.begin(); it!=flights.end(); ++it) - { - if((*it)->getRoute()->empty()) - { - (*it)->getRoute()->push_back(r3); - (*it)->getRoute()->push_front(r2); - (*it)->getRoute()->push_front(r1); - (*it)->getRoute()->push_front(r0); +namespace atcsim { + + AirController::AirController() { + // TODO Auto-generated constructor stub + + } + + AirController::~AirController() { + // TODO Auto-generated destructor stub + } + + void crearRuta(Flight *fl) + { + int x = fl->getPosition().get_x(); + int y = fl->getPosition().get_y(); + int z = fl->getPosition().get_z(); + + Route ruta[4]; + + int este_oeste; + if (y > 0) este_oeste = -1; + else este_oeste = 1; + + Position p0((x + 200), (y + (200 * este_oeste)), z); + Position p1(x, (y + (400 * este_oeste)), z); + Position p2((x - 200), (y + (200 * este_oeste)), z); + Position p3(x, y, z); + Position posiciones[4] = { p0,p1,p2,p3 }; + for (int i = 0; i < 4; i++) + { + ruta[i].pos = posiciones[i]; + ruta[i].speed = 20; + fl->getRoute()->push_back(ruta[i]); } } -} + + void + AirController::doWork() + { + std::list flights = Airport::getInstance()->getFlights(); + std::list::iterator it; + + Position pos_aterrizaje_0(3500.0, 0.0, 100.0); + Position pos_aterrizaje_1(1500.0, 0.0, 50.0); + Position pos_aterrizaje_2(200.0, 0.0, 25.0); + Position pos_aterrizaje_3(-750.0, 0.0, 25.0); + + Route ra0, ra1, ra2, ra3; + + ra0.pos = pos_aterrizaje_0; + ra0.speed = 500.0; + ra1.pos = pos_aterrizaje_1; + ra1.speed = 200.0; + ra2.pos = pos_aterrizaje_2; + ra2.speed = 50.0; + ra3.pos = pos_aterrizaje_3; + ra3.speed = 15.0; + + + if (!Airport::getInstance()->is_booked_landing()) { + Flight* primero = flights.front(); + primero->getRoute()->clear(); //limpia la ruta de vuelo + } + for (it = flights.begin(); it != flights.end(); ++it) + { + if ((*it)->getRoute()->empty()) + { + if (Airport::getInstance()->is_booked_landing()) { + crearRuta((*it)); + } + else { + Airport::getInstance()->book_landing(); + (*it)->getRoute()->push_back(ra0); + (*it)->getRoute()->push_back(ra1); + (*it)->getRoute()->push_back(ra2); + (*it)->getRoute()->push_back(ra3); + } + } + } + } } // namespace atcsim From d7ae2ef79b105d7f159a1ba2a2a2cfedd2659550 Mon Sep 17 00:00:00 2001 From: Raquel Date: Thu, 10 Jan 2019 20:54:47 +0100 Subject: [PATCH 3/6] Rollback --- src/simulator/AirController.cpp | 120 +++++++++++--------------------- 1 file changed, 42 insertions(+), 78 deletions(-) diff --git a/src/simulator/AirController.cpp b/src/simulator/AirController.cpp index c9ceffe..fdeff0f 100644 --- a/src/simulator/AirController.cpp +++ b/src/simulator/AirController.cpp @@ -29,85 +29,49 @@ #include #include -namespace atcsim { - - AirController::AirController() { - // TODO Auto-generated constructor stub - - } - - AirController::~AirController() { - // TODO Auto-generated destructor stub - } - - void crearRuta(Flight *fl) - { - int x = fl->getPosition().get_x(); - int y = fl->getPosition().get_y(); - int z = fl->getPosition().get_z(); - - Route ruta[4]; - - int este_oeste; - if (y > 0) este_oeste = -1; - else este_oeste = 1; - - Position p0((x + 200), (y + (200 * este_oeste)), z); - Position p1(x, (y + (400 * este_oeste)), z); - Position p2((x - 200), (y + (200 * este_oeste)), z); - Position p3(x, y, z); - Position posiciones[4] = { p0,p1,p2,p3 }; - for (int i = 0; i < 4; i++) - { - ruta[i].pos = posiciones[i]; - ruta[i].speed = 20; - fl->getRoute()->push_back(ruta[i]); +namespace atcsim{ + +AirController::AirController() { + // TODO Auto-generated constructor stub + +} + +AirController::~AirController() { + // TODO Auto-generated destructor stub +} + +void +AirController::doWork() +{ + std::list flights = Airport::getInstance()->getFlights(); + std::list::iterator it; + + Position pos0(3500.0, 0.0, 100.0); + Position pos1(1500.0, 0.0, 50.0); + Position pos2(200.0, 0.0, 25.0); + Position pos3(-750.0, 0.0, 25.0); + + Route r0, r1, r2, r3; + + r0.pos = pos0; + r0.speed = 500.0; + r1.pos = pos1; + r1.speed = 100.0; + r2.pos = pos2; + r2.speed = 19.0; + r3.pos = pos3; + r3.speed = 15.0; + + for(it = flights.begin(); it!=flights.end(); ++it) + { + if((*it)->getRoute()->empty()) + { + (*it)->getRoute()->push_back(r3); + (*it)->getRoute()->push_front(r2); + (*it)->getRoute()->push_front(r1); + (*it)->getRoute()->push_front(r0); } } +} - - void - AirController::doWork() - { - std::list flights = Airport::getInstance()->getFlights(); - std::list::iterator it; - - Position pos_aterrizaje_0(3500.0, 0.0, 100.0); - Position pos_aterrizaje_1(1500.0, 0.0, 50.0); - Position pos_aterrizaje_2(200.0, 0.0, 25.0); - Position pos_aterrizaje_3(-750.0, 0.0, 25.0); - - Route ra0, ra1, ra2, ra3; - - ra0.pos = pos_aterrizaje_0; - ra0.speed = 500.0; - ra1.pos = pos_aterrizaje_1; - ra1.speed = 200.0; - ra2.pos = pos_aterrizaje_2; - ra2.speed = 50.0; - ra3.pos = pos_aterrizaje_3; - ra3.speed = 15.0; - - - if (!Airport::getInstance()->is_booked_landing()) { - Flight* primero = flights.front(); - primero->getRoute()->clear(); //limpia la ruta de vuelo - } - for (it = flights.begin(); it != flights.end(); ++it) - { - if ((*it)->getRoute()->empty()) - { - if (Airport::getInstance()->is_booked_landing()) { - crearRuta((*it)); - } - else { - Airport::getInstance()->book_landing(); - (*it)->getRoute()->push_back(ra0); - (*it)->getRoute()->push_back(ra1); - (*it)->getRoute()->push_back(ra2); - (*it)->getRoute()->push_back(ra3); - } - } - } - } } // namespace atcsim From 0db9618e336e7df00236e25eadc75858266f9ae8 Mon Sep 17 00:00:00 2001 From: Raquel Date: Thu, 10 Jan 2019 21:13:09 +0100 Subject: [PATCH 4/6] Fichero Position_test.cpp --- test/Position_test.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/Position_test.cpp b/test/Position_test.cpp index 3ec376a..6fbd1d2 100644 --- a/test/Position_test.cpp +++ b/test/Position_test.cpp @@ -2,8 +2,10 @@ #include "gtest/gtest.h" #include "Position.h" + using namespace atcsim; + TEST(PositionTest, empty_constructor) { Position pos; @@ -93,6 +95,6 @@ TEST(PositionTest, zero_angles) int main(int argc, char* argv[]) { ::testing::InitGoogleTest(&argc, argv); - + return RUN_ALL_TESTS(); } From ef967e891afa76b9dd6acd50a7a11bbb0bb5e7f7 Mon Sep 17 00:00:00 2001 From: Raquel Date: Thu, 10 Jan 2019 21:19:55 +0100 Subject: [PATCH 5/6] Actualizacion 1 del fichero --- test/Position_test.cpp | 100 ----------------------------------------- 1 file changed, 100 deletions(-) diff --git a/test/Position_test.cpp b/test/Position_test.cpp index 6fbd1d2..e69de29 100644 --- a/test/Position_test.cpp +++ b/test/Position_test.cpp @@ -1,100 +0,0 @@ -#include -#include "gtest/gtest.h" -#include "Position.h" - - -using namespace atcsim; - - -TEST(PositionTest, empty_constructor) -{ - Position pos; - ASSERT_EQ(pos.get_x(), 0.0); - ASSERT_EQ(pos.get_y(), 0.0); - ASSERT_EQ(pos.get_z(), MAINTAIN_ALT); -} - - -TEST(PositionTest, constructor) -{ - Position pos(1,2,3); - ASSERT_EQ(pos.get_x(), 1.0); - ASSERT_EQ(pos.get_y(), 2.0); - ASSERT_EQ(pos.get_z(), 3.0); -} - - -TEST(PositionTest, setters_getters) -{ - Position pos; - pos.set_x(1.0); - pos.set_y(2.0); - pos.set_z(3.0); - ASSERT_EQ(pos.get_x(), 1.0); - ASSERT_EQ(pos.get_y(), 2.0); - ASSERT_EQ(pos.get_z(), 3.0); -} - -TEST(PositionTest, short_distance) -{ - Position pos1(1, 0, 0); - Position pos2(2, 0, 0); - ASSERT_EQ(pos1.distance(pos2), 1.0); -} - - -TEST(PositionTest, long_distance) -{ - Position pos1(1, 0, 0); - Position pos2(200, 1500, 300); - ASSERT_FLOAT_EQ(pos1.distance(pos2), 1542.5956); -} - - -TEST(PositionTest, zero_distance) -{ - Position pos1(2, 0, 0); - Position pos2(2, 0, 0); - ASSERT_EQ(pos1.distance(pos2), 0.0); -} - - -TEST(PositionTest, positive_angles) -{ - Position pos1(1, 0, 1); - Position pos2(2, 0, 5); - float bearing, inclination; - pos1.angles(pos2, bearing, inclination); - ASSERT_FLOAT_EQ(bearing, 3.1415927); - ASSERT_FLOAT_EQ(inclination, 1.325818); -} - - -TEST(PositionTest, negative_angles) -{ - Position pos1(10, -10, 10); - Position pos2(0, 0, 0); - float bearing, inclination; - pos1.angles(pos2, bearing, inclination); - ASSERT_FLOAT_EQ(bearing, -0.785398); - ASSERT_FLOAT_EQ(inclination, -0.61547971); - -} - -TEST(PositionTest, zero_angles) -{ - Position pos1(2, 0, 0); - Position pos2(2, 0, 0); - float bearing, inclination; - pos1.angles(pos2, bearing, inclination); - ASSERT_EQ(bearing, 0.0); - ASSERT_EQ(inclination, 0.0); -} - - -int main(int argc, char* argv[]) -{ - ::testing::InitGoogleTest(&argc, argv); - - return RUN_ALL_TESTS(); -} From 2a4f954495fb89d9ffd00327a24b2c94500bc204 Mon Sep 17 00:00:00 2001 From: Raquel Date: Thu, 10 Jan 2019 21:20:41 +0100 Subject: [PATCH 6/6] Actualizacion 2 del fichero --- test/Position_test.cpp | 100 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 100 insertions(+) diff --git a/test/Position_test.cpp b/test/Position_test.cpp index e69de29..6fbd1d2 100644 --- a/test/Position_test.cpp +++ b/test/Position_test.cpp @@ -0,0 +1,100 @@ +#include +#include "gtest/gtest.h" +#include "Position.h" + + +using namespace atcsim; + + +TEST(PositionTest, empty_constructor) +{ + Position pos; + ASSERT_EQ(pos.get_x(), 0.0); + ASSERT_EQ(pos.get_y(), 0.0); + ASSERT_EQ(pos.get_z(), MAINTAIN_ALT); +} + + +TEST(PositionTest, constructor) +{ + Position pos(1,2,3); + ASSERT_EQ(pos.get_x(), 1.0); + ASSERT_EQ(pos.get_y(), 2.0); + ASSERT_EQ(pos.get_z(), 3.0); +} + + +TEST(PositionTest, setters_getters) +{ + Position pos; + pos.set_x(1.0); + pos.set_y(2.0); + pos.set_z(3.0); + ASSERT_EQ(pos.get_x(), 1.0); + ASSERT_EQ(pos.get_y(), 2.0); + ASSERT_EQ(pos.get_z(), 3.0); +} + +TEST(PositionTest, short_distance) +{ + Position pos1(1, 0, 0); + Position pos2(2, 0, 0); + ASSERT_EQ(pos1.distance(pos2), 1.0); +} + + +TEST(PositionTest, long_distance) +{ + Position pos1(1, 0, 0); + Position pos2(200, 1500, 300); + ASSERT_FLOAT_EQ(pos1.distance(pos2), 1542.5956); +} + + +TEST(PositionTest, zero_distance) +{ + Position pos1(2, 0, 0); + Position pos2(2, 0, 0); + ASSERT_EQ(pos1.distance(pos2), 0.0); +} + + +TEST(PositionTest, positive_angles) +{ + Position pos1(1, 0, 1); + Position pos2(2, 0, 5); + float bearing, inclination; + pos1.angles(pos2, bearing, inclination); + ASSERT_FLOAT_EQ(bearing, 3.1415927); + ASSERT_FLOAT_EQ(inclination, 1.325818); +} + + +TEST(PositionTest, negative_angles) +{ + Position pos1(10, -10, 10); + Position pos2(0, 0, 0); + float bearing, inclination; + pos1.angles(pos2, bearing, inclination); + ASSERT_FLOAT_EQ(bearing, -0.785398); + ASSERT_FLOAT_EQ(inclination, -0.61547971); + +} + +TEST(PositionTest, zero_angles) +{ + Position pos1(2, 0, 0); + Position pos2(2, 0, 0); + float bearing, inclination; + pos1.angles(pos2, bearing, inclination); + ASSERT_EQ(bearing, 0.0); + ASSERT_EQ(inclination, 0.0); +} + + +int main(int argc, char* argv[]) +{ + ::testing::InitGoogleTest(&argc, argv); + + return RUN_ALL_TESTS(); +}