include/ucbhelper/interactionrequest.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_UCBHELPER_INTERACTIONREQUEST_HXX
  21 #define INCLUDED_UCBHELPER_INTERACTIONREQUEST_HXX
  22
  23 #include <com/sun/star/lang/XTypeProvider.hpp>
  24 #include <com/sun/star/task/XInteractionRequest.hpp>
  25 #include <com/sun/star/task/XInteractionAbort.hpp>
  26 #include <com/sun/star/task/XInteractionRetry.hpp>
  27 #include <com/sun/star/task/XInteractionApprove.hpp>
  28 #include <com/sun/star/task/XInteractionDisapprove.hpp>
  29 #include <com/sun/star/ucb/XInteractionAuthFallback.hpp>
  30 #include <com/sun/star/ucb/XInteractionReplaceExistingData.hpp>
  31 #include <com/sun/star/ucb/XInteractionSupplyAuthentication2.hpp>
  32 #include <rtl/ref.hxx>
  33 #include <cppuhelper/weak.hxx>
  34 #include <ucbhelper/ucbhelperdllapi.h>
  35 #include <memory>
  36
  37 namespace ucbhelper {
  38
  39 class InteractionContinuation;
  40
  41
  42 struct InteractionRequest_Impl;
  43
  44 /**
  45   * This class implements the interface XInteractionRequest. Instances can
  46   * be passed directly to XInteractionHandler::handle(...). Each interaction
  47   * request contains an exception describing the error and a number of
  48   * interaction continuations describing the possible "answers" for the request.
  49   * After the request was passed to XInteractionHandler::handle(...) the method
  50   * getSelection() returns the continuation chosen by the interaction handler.
  51   *
  52   * The typical usage of this class would be:
  53   *
  54   * 1) Create exception object that shall be handled by the interaction handler.
  55   * 2) Create InteractionRequest, supply exception as ctor parameter
  56   * 3) Create continuations needed and add them to a sequence
  57   * 4) Supply the continuations to the InteractionRequest by calling
  58   *    setContinuations(...)
  59   *
  60   * This class can also be used as base class for more specialized requests,
  61   * like authentication requests.
  62   */
  63 class UCBHELPER_DLLPUBLIC InteractionRequest : public cppu::OWeakObject,
  64                            public css::lang::XTypeProvider,
  65                            public css::task::XInteractionRequest
  66 {
  67     std::unique_ptr<InteractionRequest_Impl> m_pImpl;
  68
  69 protected:
  70     void setRequest( const css::uno::Any & rRequest );
  71
  72     InteractionRequest();
  73     virtual ~InteractionRequest() override;
  74
  75 public:
  76     /**
  77       * Constructor.
  78       *
  79       * @param rRequest is the exception describing the error.
  80       */
  81     InteractionRequest( const css::uno::Any & rRequest );
  82
  83     /**
  84       * This method sets the continuations for the request.
  85       *
  86       * @param rContinuations contains the possible continuations.
  87       */
  88     void setContinuations(
  89         const css::uno::Sequence< css::uno::Reference< css::task::XInteractionContinuation > > & rContinuations );
  90
  91     // XInterface
  92     virtual css::uno::Any SAL_CALL
  93     queryInterface( const css::uno::Type & rType )
  94         throw( css::uno::RuntimeException, std::exception ) override;
  95     virtual void SAL_CALL acquire()
  96         throw() override;
  97     virtual void SAL_CALL release()
  98         throw() override;
  99
 100     // XTypeProvider
 101     virtual css::uno::Sequence< css::uno::Type > SAL_CALL
 102     getTypes()
 103         throw( css::uno::RuntimeException, std::exception ) override;
 104     virtual css::uno::Sequence< sal_Int8 > SAL_CALL
 105     getImplementationId()
 106         throw( css::uno::RuntimeException, std::exception ) override;
 107
 108     // XInteractionRequest
 109     virtual css::uno::Any SAL_CALL
 110     getRequest()
 111         throw( css::uno::RuntimeException, std::exception ) override;
 112     virtual css::uno::Sequence< css::uno::Reference< css::task::XInteractionContinuation > > SAL_CALL
 113     getContinuations()
 114         throw( css::uno::RuntimeException, std::exception ) override;
 115
 116     // Non-interface methods.
 117
 118     /**
 119       * After passing this request to XInteractionHandler::handle, this method
 120       * returns the continuation that was chosen by the interaction handler.
 121       *
 122       * @return the continuation chosen by an interaction handler or an empty
 123       *         reference, if the request was not (yet) handled.
 124       */
 125     rtl::Reference< InteractionContinuation > const & getSelection() const;
 126
 127     /**
 128       * This method sets a continuation for the request. It also can be used
 129       * to reset the continuation set by a previous XInteractionHandler::handle
 130       * call in order to use this request object more than once.
 131       *
 132       * @param rxSelection is the interaction continuation to activate for
 133       *        the request or an empty reference in order to reset the
 134       *        current selection.
 135       */
 136     void
 137     setSelection(
 138         const rtl::Reference< InteractionContinuation > & rxSelection );
 139 };
 140
 141
 142 struct InteractionContinuation_Impl;
 143
 144 /**
 145   * This class is the base for implementations of the interface
 146   * XInteractionContinuation. Classes derived from this bas class work together
 147   * with class InteractionRequest.
 148   *
 149   * Derived classes must implement their XInteractionContinuation::select()
 150   * method the way that they simply call recordSelection() which is provided by
 151   * this class.
 152   */
 153 class UCBHELPER_DLLPUBLIC InteractionContinuation : public cppu::OWeakObject
 154 {
 155     std::unique_ptr<InteractionContinuation_Impl> m_pImpl;
 156
 157 protected:
 158     /**
 159       * This method marks this continuation as "selected" at the request it
 160       * belongs to.
 161       *
 162       * Derived classes must implement their XInteractionContinuation::select()
 163       * method the way that they call this method.
 164       */
 165     void recordSelection();
 166     virtual ~InteractionContinuation() override;
 167
 168 public:
 169     InteractionContinuation( InteractionRequest * pRequest );
 170 };
 171
 172
 173 /**
 174   * This class implements a standard interaction continuation, namely the
 175   * interface XInteractionAbort. Instances of this class can be passed
 176   * along with an interaction request to indicate the possibility to abort
 177   * the operation that caused the request.
 178   */
 179 class UCBHELPER_DLLPUBLIC InteractionAbort : public InteractionContinuation,
 180                          public css::lang::XTypeProvider,
 181                          public css::task::XInteractionAbort
 182 {
 183 public:
 184     InteractionAbort( InteractionRequest * pRequest )
 185     : InteractionContinuation( pRequest ) {}
 186
 187     // XInterface
 188     virtual css::uno::Any SAL_CALL
 189     queryInterface( const css::uno::Type & rType )
 190         throw( css::uno::RuntimeException, std::exception ) override;
 191     virtual void SAL_CALL acquire()
 192         throw() override;
 193     virtual void SAL_CALL release()
 194         throw() override;
 195
 196     // XTypeProvider
 197     virtual css::uno::Sequence< css::uno::Type > SAL_CALL
 198     getTypes()
 199         throw( css::uno::RuntimeException, std::exception ) override;
 200     virtual css::uno::Sequence< sal_Int8 > SAL_CALL
 201     getImplementationId()
 202         throw( css::uno::RuntimeException, std::exception ) override;
 203
 204     // XInteractionContinuation
 205     virtual void SAL_CALL select()
 206         throw( css::uno::RuntimeException, std::exception ) override;
 207 };
 208
 209
 210 /**
 211   * This class implements a standard interaction continuation, namely the
 212   * interface XInteractionRetry. Instances of this class can be passed
 213   * along with an interaction request to indicate the possibility to retry
 214   * the operation that caused the request.
 215   */
 216 class UCBHELPER_DLLPUBLIC InteractionRetry : public InteractionContinuation,
 217                          public css::lang::XTypeProvider,
 218                          public css::task::XInteractionRetry
 219 {
 220 public:
 221     InteractionRetry( InteractionRequest * pRequest )
 222     : InteractionContinuation( pRequest ) {}
 223
 224     // XInterface
 225     virtual css::uno::Any SAL_CALL
 226     queryInterface( const css::uno::Type & rType )
 227         throw( css::uno::RuntimeException, std::exception ) override;
 228     virtual void SAL_CALL acquire()
 229         throw() override;
 230     virtual void SAL_CALL release()
 231         throw() override;
 232
 233     // XTypeProvider
 234     virtual css::uno::Sequence< css::uno::Type > SAL_CALL
 235     getTypes()
 236         throw( css::uno::RuntimeException, std::exception ) override;
 237     virtual css::uno::Sequence< sal_Int8 > SAL_CALL
 238     getImplementationId()
 239         throw( css::uno::RuntimeException, std::exception ) override;
 240
 241     // XInteractionContinuation
 242     virtual void SAL_CALL select()
 243         throw( css::uno::RuntimeException, std::exception ) override;
 244 };
 245
 246
 247 /**
 248   * This class implements a standard interaction continuation, namely the
 249   * interface XInteractionApprove. Instances of this class can be passed
 250   * along with an interaction request to indicate the possibility to approve
 251   * the request.
 252   */
 253 class UCBHELPER_DLLPUBLIC InteractionApprove : public InteractionContinuation,
 254                            public css::lang::XTypeProvider,
 255                            public css::task::XInteractionApprove
 256 {
 257 public:
 258     InteractionApprove( InteractionRequest * pRequest )
 259     : InteractionContinuation( pRequest ) {}
 260
 261     // XInterface
 262     virtual css::uno::Any SAL_CALL
 263     queryInterface( const css::uno::Type & rType )
 264         throw( css::uno::RuntimeException, std::exception ) override;
 265     virtual void SAL_CALL acquire()
 266         throw() override;
 267     virtual void SAL_CALL release()
 268         throw() override;
 269
 270     // XTypeProvider
 271     virtual css::uno::Sequence< css::uno::Type > SAL_CALL
 272     getTypes()
 273         throw( css::uno::RuntimeException, std::exception ) override;
 274     virtual css::uno::Sequence< sal_Int8 > SAL_CALL
 275     getImplementationId()
 276         throw( css::uno::RuntimeException, std::exception ) override;
 277
 278     // XInteractionContinuation
 279     virtual void SAL_CALL select()
 280         throw( css::uno::RuntimeException, std::exception ) override;
 281 };
 282
 283
 284 /**
 285   * This class implements a standard interaction continuation, namely the
 286   * interface XInteractionDisapprove. Instances of this class can be passed
 287   * along with an interaction request to indicate the possibility to disapprove
 288   * the request.
 289   */
 290 class UCBHELPER_DLLPUBLIC InteractionDisapprove : public InteractionContinuation,
 291                               public css::lang::XTypeProvider,
 292                               public css::task::XInteractionDisapprove
 293 {
 294 public:
 295     InteractionDisapprove( InteractionRequest * pRequest )
 296     : InteractionContinuation( pRequest ) {}
 297
 298     // XInterface
 299     virtual css::uno::Any SAL_CALL
 300     queryInterface( const css::uno::Type & rType )
 301         throw( css::uno::RuntimeException, std::exception ) override;
 302     virtual void SAL_CALL acquire()
 303         throw() override;
 304     virtual void SAL_CALL release()
 305         throw() override;
 306
 307     // XTypeProvider
 308     virtual css::uno::Sequence< css::uno::Type > SAL_CALL
 309     getTypes()
 310         throw( css::uno::RuntimeException, std::exception ) override;
 311     virtual css::uno::Sequence< sal_Int8 > SAL_CALL
 312     getImplementationId()
 313         throw( css::uno::RuntimeException, std::exception ) override;
 314
 315     // XInteractionContinuation
 316     virtual void SAL_CALL select()
 317         throw( css::uno::RuntimeException, std::exception ) override;
 318 };
 319
 320
 321 /**
 322   * This class implements a standard interaction continuation, namely the
 323   * interface XInteractionSupplyAuthentication. Instances of this class can be
 324   * passed along with an authentication interaction request to enable the
 325   * interaction handler to supply the missing authentication data.
 326   */
 327 class UCBHELPER_DLLPUBLIC InteractionSupplyAuthentication :
 328                   public InteractionContinuation,
 329                   public css::lang::XTypeProvider,
 330                   public css::ucb::XInteractionSupplyAuthentication2
 331 {
 332     css::uno::Sequence< css::ucb::RememberAuthentication >
 333                   m_aRememberPasswordModes;
 334     css::uno::Sequence< css::ucb::RememberAuthentication >
 335                   m_aRememberAccountModes;
 336     OUString m_aRealm;
 337     OUString m_aUserName;
 338     OUString m_aPassword;
 339     OUString m_aAccount;
 340     css::ucb::RememberAuthentication m_eRememberPasswordMode;
 341     css::ucb::RememberAuthentication m_eDefaultRememberPasswordMode;
 342     css::ucb::RememberAuthentication m_eRememberAccountMode;
 343     css::ucb::RememberAuthentication m_eDefaultRememberAccountMode;
 344     bool m_bCanSetRealm    : 1;
 345     bool m_bCanSetUserName : 1;
 346     bool m_bCanSetPassword : 1;
 347     bool m_bCanSetAccount  : 1;
 348     bool m_bCanUseSystemCredentials     : 1;
 349     bool m_bUseSystemCredentials        : 1;
 350
 351 public:
 352     /**
 353       * Constructor.
 354       *
 355       * Note: The remember-authentication stuff is interesting only for
 356       *       clients implementing own password storage functionality.
 357       *
 358       * @param rxRequest is the interaction request that owns this continuation.
 359       * @param bCanSetRealm indicates, whether the realm given with the
 360       *        authentication request is read-only.
 361       * @param bCanSetUserName indicates, whether the username given with the
 362       *        authentication request is read-only.
 363       * @param bCanSetPassword indicates, whether the password given with the
 364       *        authentication request is read-only.
 365       * @param bCanSetAccount indicates, whether the account given with the
 366       *        authentication request is read-only.
 367       * @param rRememberPasswordModes specifies the authentication-remember-
 368       *        modes for passwords supported by the requesting client.
 369       * @param eDefaultRememberPasswordMode specifies the default
 370       *        authentication-remember-mode for passwords preferred by the
 371       *        requesting client.
 372       * @param rRememberAccountModes specifies the authentication-remember-
 373       *        modes for accounts supported by the requesting client.
 374       * @param eDefaultRememberAccountMode specifies the default
 375       *        authentication-remember-mode for accounts preferred by the
 376       *        requesting client.
 377       * @param bCanUseSystemCredentials indicates whether issuer of the
 378       *        authentication request can obtain and use system credentials
 379       *        for authentication.
 380       *
 381       * @see css::ucb::AuthenticationRequest
 382       * @see css::ucb::RememberAuthentication
 383       */
 384     inline InteractionSupplyAuthentication(
 385                     InteractionRequest * pRequest,
 386                     bool bCanSetRealm,
 387                     bool bCanSetUserName,
 388                     bool bCanSetPassword,
 389                     bool bCanSetAccount,
 390                     const css::uno::Sequence< css::ucb::RememberAuthentication > & rRememberPasswordModes,
 391                     const css::ucb::RememberAuthentication eDefaultRememberPasswordMode,
 392                     const css::uno::Sequence< css::ucb::RememberAuthentication > & rRememberAccountModes,
 393                     const css::ucb::RememberAuthentication  eDefaultRememberAccountMode,
 394                     bool bCanUseSystemCredentials );
 395
 396     // XInterface
 397     virtual css::uno::Any SAL_CALL
 398     queryInterface( const css::uno::Type & rType )
 399         throw( css::uno::RuntimeException, std::exception ) override;
 400     virtual void SAL_CALL acquire()
 401         throw() override;
 402     virtual void SAL_CALL release()
 403         throw() override;
 404
 405     // XTypeProvider
 406     virtual css::uno::Sequence< css::uno::Type > SAL_CALL
 407     getTypes()
 408         throw( css::uno::RuntimeException, std::exception ) override;
 409     virtual css::uno::Sequence< sal_Int8 > SAL_CALL
 410     getImplementationId()
 411         throw( css::uno::RuntimeException, std::exception ) override;
 412
 413     // XInteractionContinuation
 414     virtual void SAL_CALL select()
 415         throw( css::uno::RuntimeException, std::exception ) override;
 416
 417     // XInteractionSupplyAuthentication
 418     virtual sal_Bool SAL_CALL
 419     canSetRealm()
 420         throw( css::uno::RuntimeException, std::exception ) override;
 421     virtual void SAL_CALL
 422     setRealm( const OUString& Realm )
 423         throw( css::uno::RuntimeException, std::exception ) override;
 424
 425     virtual sal_Bool SAL_CALL
 426     canSetUserName()
 427         throw( css::uno::RuntimeException, std::exception ) override;
 428     virtual void SAL_CALL
 429     setUserName( const OUString& UserName )
 430         throw( css::uno::RuntimeException, std::exception ) override;
 431
 432     virtual sal_Bool SAL_CALL
 433     canSetPassword()
 434         throw( css::uno::RuntimeException, std::exception ) override;
 435     virtual void SAL_CALL
 436     setPassword( const OUString& Password )
 437         throw( css::uno::RuntimeException, std::exception ) override;
 438
 439     virtual css::uno::Sequence<
 440                 css::ucb::RememberAuthentication > SAL_CALL
 441     getRememberPasswordModes(
 442             css::ucb::RememberAuthentication& Default )
 443         throw( css::uno::RuntimeException, std::exception ) override;
 444     virtual void SAL_CALL
 445     setRememberPassword( css::ucb::RememberAuthentication Remember )
 446         throw( css::uno::RuntimeException, std::exception ) override;
 447
 448     virtual sal_Bool SAL_CALL
 449     canSetAccount()
 450         throw( css::uno::RuntimeException, std::exception ) override;
 451     virtual void SAL_CALL
 452     setAccount( const OUString& Account )
 453         throw( css::uno::RuntimeException, std::exception ) override;
 454
 455     virtual css::uno::Sequence< css::ucb::RememberAuthentication > SAL_CALL
 456     getRememberAccountModes(
 457             css::ucb::RememberAuthentication& Default )
 458         throw( css::uno::RuntimeException, std::exception ) override;
 459     virtual void SAL_CALL
 460     setRememberAccount( css::ucb::RememberAuthentication Remember )
 461         throw( css::uno::RuntimeException, std::exception ) override;
 462
 463     // XInteractionSupplyAuthentication2
 464     virtual sal_Bool SAL_CALL canUseSystemCredentials( sal_Bool& Default )
 465         throw ( css::uno::RuntimeException, std::exception ) override;
 466     virtual void SAL_CALL setUseSystemCredentials( sal_Bool UseSystemCredentials )
 467         throw ( css::uno::RuntimeException, std::exception ) override;
 468
 469     // Non-interface methods.
 470
 471     /**
 472       * This method returns the realm that was supplied by the interaction
 473       * handler.
 474       *
 475       * @return the realm.
 476       */
 477     const OUString & getRealm()    const { return m_aRealm; }
 478
 479     /**
 480       * This method returns the username that was supplied by the interaction
 481       * handler.
 482       *
 483       * @return the username.
 484       */
 485     const OUString & getUserName() const { return m_aUserName; }
 486
 487     /**
 488       * This method returns the password that was supplied by the interaction
 489       * handler.
 490       *
 491       * @return the password.
 492       */
 493     const OUString & getPassword() const { return m_aPassword; }
 494
 495     /**
 496       * This method returns the authentication remember-mode for the password
 497       * that was supplied by the interaction handler.
 498       *
 499       * @return the remember-mode for the password.
 500       */
 501     const css::ucb::RememberAuthentication &
 502     getRememberPasswordMode() const { return m_eRememberPasswordMode; }
 503
 504     bool getUseSystemCredentials() const { return m_bUseSystemCredentials; }
 505 };
 506
 507
 508
 509 inline InteractionSupplyAuthentication::InteractionSupplyAuthentication(
 510     InteractionRequest * pRequest,
 511     bool bCanSetRealm,
 512     bool bCanSetUserName,
 513     bool bCanSetPassword,
 514     bool bCanSetAccount,
 515     const css::uno::Sequence< css::ucb::RememberAuthentication > & rRememberPasswordModes,
 516     const css::ucb::RememberAuthentication eDefaultRememberPasswordMode,
 517     const css::uno::Sequence< css::ucb::RememberAuthentication > & rRememberAccountModes,
 518     const css::ucb::RememberAuthentication eDefaultRememberAccountMode,
 519     bool bCanUseSystemCredentials )
 520 : InteractionContinuation( pRequest ),
 521   m_aRememberPasswordModes( rRememberPasswordModes ),
 522   m_aRememberAccountModes( rRememberAccountModes ),
 523   m_eRememberPasswordMode( eDefaultRememberPasswordMode ),
 524   m_eDefaultRememberPasswordMode( eDefaultRememberPasswordMode ),
 525   m_eRememberAccountMode( eDefaultRememberAccountMode ),
 526   m_eDefaultRememberAccountMode( eDefaultRememberAccountMode ),
 527   m_bCanSetRealm( bCanSetRealm ),
 528   m_bCanSetUserName( bCanSetUserName ),
 529   m_bCanSetPassword( bCanSetPassword ),
 530   m_bCanSetAccount( bCanSetAccount ),
 531   m_bCanUseSystemCredentials( bCanUseSystemCredentials ),
 532   m_bUseSystemCredentials( false )
 533 {
 534 }
 535
 536
 537 /**
 538   * This class implements a standard interaction continuation, namely the
 539   * interface XInteractionReplaceExistingData. Instances of this class can be
 540   * passed along with an interaction request to indicate the possibility to
 541   * replace existing data.
 542   */
 543 class InteractionReplaceExistingData :
 544                   public InteractionContinuation,
 545                   public css::lang::XTypeProvider,
 546                   public css::ucb::XInteractionReplaceExistingData
 547 {
 548 public:
 549     InteractionReplaceExistingData( InteractionRequest * pRequest )
 550     : InteractionContinuation( pRequest ) {}
 551
 552     // XInterface
 553     virtual css::uno::Any SAL_CALL
 554     queryInterface( const css::uno::Type & rType )
 555         throw( css::uno::RuntimeException, std::exception ) override;
 556     virtual void SAL_CALL acquire()
 557         throw() override;
 558     virtual void SAL_CALL release()
 559         throw() override;
 560
 561     // XTypeProvider
 562     virtual css::uno::Sequence< css::uno::Type > SAL_CALL
 563     getTypes()
 564         throw( css::uno::RuntimeException, std::exception ) override;
 565     virtual css::uno::Sequence< sal_Int8 > SAL_CALL
 566     getImplementationId()
 567         throw( css::uno::RuntimeException, std::exception ) override;
 568
 569     // XInteractionContinuation
 570     virtual void SAL_CALL select()
 571         throw( css::uno::RuntimeException, std::exception ) override;
 572 };
 573
 574 class UCBHELPER_DLLPUBLIC InteractionAuthFallback:
 575                   public InteractionContinuation,
 576                   public css::ucb::XInteractionAuthFallback
 577 {
 578     OUString m_aCode;
 579
 580 public:
 581     InteractionAuthFallback( InteractionRequest * pRequest )
 582     : InteractionContinuation( pRequest ) {}
 583
 584     // XInterface
 585     virtual css::uno::Any SAL_CALL
 586     queryInterface( const css::uno::Type & rType )
 587         throw( css::uno::RuntimeException, std::exception ) override;
 588     virtual void SAL_CALL acquire()
 589         throw() override;
 590     virtual void SAL_CALL release()
 591         throw() override;
 592
 593     // XInteractionContinuation
 594     virtual void SAL_CALL select()
 595         throw( css::uno::RuntimeException, std::exception ) override;
 596
 597     // XAuthFallback
 598     virtual void SAL_CALL setCode( const OUString& code )
 599         throw (::css::uno::RuntimeException, ::std::exception) override;
 600     const OUString& SAL_CALL getCode()
 601         throw (::css::uno::RuntimeException, ::std::exception);
 602
 603
 604 };
 605
 606
 607 } // namespace ucbhelper
 608
 609 #endif /* ! INCLUDED_UCBHELPER_INTERACTIONREQUEST_HXX */
 610
 611 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */