cpp/test/Ice/slicing/objects/TestI.cpp

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 #include <TestI.h>
  11 #include <Ice/Ice.h>
  12 #include <sstream>
  13
  14 using namespace Test;
  15
  16 TestI::TestI()
  17 {
  18 }
  19
  20 Ice::ObjectPtr
  21 TestI::SBaseAsObject(const ::Ice::Current&)
  22 {
  23     SBasePtr sb = new SBase;
  24     sb->sb = "SBase.sb";
  25     return sb;
  26 }
  27
  28 SBasePtr
  29 TestI::SBaseAsSBase(const ::Ice::Current&)
  30 {
  31     SBasePtr sb = new SBase;
  32     sb->sb = "SBase.sb";
  33     return sb;
  34 }
  35
  36 SBasePtr
  37 TestI::SBSKnownDerivedAsSBase(const ::Ice::Current&)
  38 {
  39     SBSKnownDerivedPtr sbskd = new SBSKnownDerived;
  40     sbskd->sb = "SBSKnownDerived.sb";
  41     sbskd->sbskd = "SBSKnownDerived.sbskd";
  42     return sbskd;
  43 }
  44
  45 SBSKnownDerivedPtr
  46 TestI::SBSKnownDerivedAsSBSKnownDerived(const ::Ice::Current&)
  47 {
  48     SBSKnownDerivedPtr sbskd = new SBSKnownDerived;
  49     sbskd->sb = "SBSKnownDerived.sb";
  50     sbskd->sbskd = "SBSKnownDerived.sbskd";
  51     return sbskd;
  52 }
  53
  54 SBasePtr
  55 TestI::SBSUnknownDerivedAsSBase(const ::Ice::Current&)
  56 {
  57     SBSUnknownDerivedPtr sbsud = new SBSUnknownDerived;
  58     sbsud->sb = "SBSUnknownDerived.sb";
  59     sbsud->sbsud = "SBSUnknownDerived.sbsud";
  60     return sbsud;
  61 }
  62
  63 Ice::ObjectPtr
  64 TestI::SUnknownAsObject(const ::Ice::Current&)
  65 {
  66     SUnknownPtr su = new SUnknown;
  67     su->su = "SUnknown.su";
  68     return su;
  69 }
  70
  71 BPtr
  72 TestI::oneElementCycle(const ::Ice::Current&)
  73 {
  74     BPtr b = new B;
  75     b->sb = "B1.sb";
  76     b->pb = b;
  77     return b;
  78 }
  79
  80 BPtr
  81 TestI::twoElementCycle(const ::Ice::Current&)
  82 {
  83     BPtr b1 = new B;
  84     b1->sb = "B1.sb";
  85     BPtr b2 = new B;
  86     b2->sb = "B2.sb";
  87     b2->pb = b1;
  88     b1->pb = b2;
  89     return b1;
  90 }
  91
  92 BPtr
  93 TestI::D1AsB(const ::Ice::Current&)
  94 {
  95     D1Ptr d1 = new D1;
  96     d1->sb = "D1.sb";
  97     d1->sd1 = "D1.sd1";
  98     D2Ptr d2 = new D2;
  99     d2->pb = d1;
 100     d2->sb = "D2.sb";
 101     d2->sd2 = "D2.sd2";
 102     d2->pd2 = d1;
 103     d1->pb = d2;
 104     d1->pd1 = d2;
 105     return d1;
 106 }
 107
 108 D1Ptr
 109 TestI::D1AsD1(const ::Ice::Current&)
 110 {
 111     D1Ptr d1 = new D1;
 112     d1->sb = "D1.sb";
 113     d1->sd1 = "D1.sd1";
 114     D2Ptr d2 = new D2;
 115     d2->pb = d1;
 116     d2->sb = "D2.sb";
 117     d2->sd2 = "D2.sd2";
 118     d2->pd2 = d1;
 119     d1->pb = d2;
 120     d1->pd1 = d2;
 121     return d1;
 122 }
 123
 124 BPtr
 125 TestI::D2AsB(const ::Ice::Current&)
 126 {
 127     D2Ptr d2 = new D2;
 128     d2->sb = "D2.sb";
 129     d2->sd2 = "D2.sd2";
 130     D1Ptr d1 = new D1;
 131     d1->pb = d2;
 132     d1->sb = "D1.sb";
 133     d1->sd1 = "D1.sd1";
 134     d1->pd1 = d2;
 135     d2->pb = d1;
 136     d2->pd2 = d1;
 137     return d2;
 138 }
 139
 140 void
 141 TestI::paramTest1(BPtr& p1, BPtr& p2, const ::Ice::Current&)
 142 {
 143     D1Ptr d1 = new D1;
 144     d1->sb = "D1.sb";
 145     d1->sd1 = "D1.sd1";
 146     D2Ptr d2 = new D2;
 147     d2->pb = d1;
 148     d2->sb = "D2.sb";
 149     d2->sd2 = "D2.sd2";
 150     d2->pd2 = d1;
 151     d1->pb = d2;
 152     d1->pd1 = d2;
 153     p1 = d1;
 154     p2 = d2;
 155 }
 156
 157 void
 158 TestI::paramTest2(BPtr& p1, BPtr& p2, const ::Ice::Current&)
 159 {
 160     ::Ice::Current c;
 161     paramTest1(p2, p1, c);
 162 }
 163
 164 BPtr
 165 TestI::paramTest3(BPtr& p1, BPtr& p2, const ::Ice::Current&)
 166 {
 167     D2Ptr d2 = new D2;
 168     d2->sb = "D2.sb (p1 1)";
 169     d2->pb = 0;
 170     d2->sd2 = "D2.sd2 (p1 1)";
 171     p1 = d2;
 172
 173     D1Ptr d1 = new D1;
 174     d1->sb = "D1.sb (p1 2)";
 175     d1->pb = 0;
 176     d1->sd1 = "D1.sd2 (p1 2)";
 177     d1->pd1 = 0;
 178     d2->pd2 = d1;
 179
 180     D2Ptr d4 = new D2;
 181     d4->sb = "D2.sb (p2 1)";
 182     d4->pb = 0;
 183     d4->sd2 = "D2.sd2 (p2 1)";
 184     p2 = d4;
 185
 186     D1Ptr d3 = new D1;
 187     d3->sb = "D1.sb (p2 2)";
 188     d3->pb = 0;
 189     d3->sd1 = "D1.sd2 (p2 2)";
 190     d3->pd1 = 0;
 191     d4->pd2 = d3;
 192
 193     return d3;
 194 }
 195
 196 BPtr
 197 TestI::paramTest4(BPtr& p1, const ::Ice::Current&)
 198 {
 199     D4Ptr d4 = new D4;
 200     d4->sb = "D4.sb (1)";
 201     d4->pb = 0;
 202     d4->p1 = new B;
 203     d4->p1->sb = "B.sb (1)";
 204     d4->p2 = new B;
 205     d4->p2->sb = "B.sb (2)";
 206     p1 = d4;
 207     return d4->p2;
 208 }
 209
 210 BPtr
 211 TestI::returnTest1(BPtr& p1, BPtr& p2, const ::Ice::Current&)
 212 {
 213     ::Ice::Current c;
 214     paramTest1(p1, p2, c);
 215     return p1;
 216 }
 217
 218 BPtr
 219 TestI::returnTest2(BPtr& p1, BPtr& p2, const ::Ice::Current&)
 220 {
 221     ::Ice::Current c;
 222     paramTest1(p2, p1, c);
 223     return p1;
 224 }
 225
 226 BPtr
 227 TestI::returnTest3(const BPtr& p1, const BPtr& p2, const ::Ice::Current&)
 228 {
 229     return p1;
 230 }
 231
 232 SS3
 233 TestI::sequenceTest(const SS1Ptr& p1, const SS2Ptr& p2, const ::Ice::Current&)
 234 {
 235     SS3 ss;
 236     ss.c1 = p1;
 237     ss.c2 = p2;
 238     return ss;
 239 }
 240
 241 Test::BDict
 242 TestI::dictionaryTest(const BDict& bin, BDict& bout, const ::Ice::Current&)
 243 {
 244     int i;
 245     for(i = 0; i < 10; ++i)
 246     {
 247         BPtr b = bin.find(i)->second;
 248         D2Ptr d2 = new D2;
 249         d2->sb = b->sb;
 250         d2->pb = b->pb;
 251         d2->sd2 = "D2";
 252         d2->pd2 = d2;
 253         bout[i * 10] = d2;
 254     }
 255     BDict r;
 256     for(i = 0; i < 10; ++i)
 257     {
 258         std::ostringstream s;
 259         s << "D1." << i * 20;
 260         D1Ptr d1 = new D1;
 261         d1->sb = s.str();
 262         d1->pb = (i == 0 ? BPtr(0) : r.find((i - 1) * 20)->second);
 263         d1->sd1 = s.str();
 264         d1->pd1 = d1;
 265         r[i * 20] = d1;
 266     }
 267     return r;
 268 }
 269
 270 void
 271 TestI::throwBaseAsBase(const ::Ice::Current&)
 272 {
 273     BaseException be;
 274     be.sbe = "sbe";
 275     be.pb = new B;
 276     be.pb->sb = "sb";
 277     be.pb->pb = be.pb;
 278     throw be;
 279 }
 280
 281 void
 282 TestI::throwDerivedAsBase(const ::Ice::Current&)
 283 {
 284     DerivedException de;
 285     de.sbe = "sbe";
 286     de.pb = new B;
 287     de.pb->sb = "sb1";
 288     de.pb->pb = de.pb;
 289     de.sde = "sde1";
 290     de.pd1 = new D1;
 291     de.pd1->sb = "sb2";
 292     de.pd1->pb = de.pd1;
 293     de.pd1->sd1 = "sd2";
 294     de.pd1->pd1 = de.pd1;
 295     throw de;
 296 }
 297
 298 void
 299 TestI::throwDerivedAsDerived(const ::Ice::Current&)
 300 {
 301     DerivedException de;
 302     de.sbe = "sbe";
 303     de.pb = new B;
 304     de.pb->sb = "sb1";
 305     de.pb->pb = de.pb;
 306     de.sde = "sde1";
 307     de.pd1 = new D1;
 308     de.pd1->sb = "sb2";
 309     de.pd1->pb = de.pd1;
 310     de.pd1->sd1 = "sd2";
 311     de.pd1->pd1 = de.pd1;
 312     throw de;
 313 }
 314
 315 void
 316 TestI::throwUnknownDerivedAsBase(const ::Ice::Current&)
 317 {
 318     D2Ptr d2 = new D2;
 319     d2->sb = "sb d2";
 320     d2->pb = d2;
 321     d2->sd2 = "sd2 d2";
 322     d2->pd2 = d2;
 323
 324     UnknownDerivedException ude;
 325     ude.sbe = "sbe";
 326     ude.pb = d2;
 327     ude.sude = "sude";
 328     ude.pd2 = d2;
 329     throw ude;
 330 }
 331
 332 void
 333 TestI::useForward(ForwardPtr& f, const ::Ice::Current&)
 334 {
 335     f = new Forward;
 336     f->h = new Hidden;
 337     f->h->f = f;
 338 }
 339
 340 void
 341 TestI::shutdown(const ::Ice::Current& current)
 342 {
 343     current.adapter->getCommunicator()->shutdown();
 344 }