HAClient.hpp

Go to the documentation of this file.

//
// Copyright (c) 2010-2024 60East Technologies Inc., All Rights Reserved.
//
// This computer software is owned by 60East Technologies Inc. and is
// protected by U.S. copyright laws and other laws and by international
// treaties.  This computer software is furnished by 60East Technologies
// Inc. pursuant to a written license agreement and may be used, copied,
// transmitted, and stored only in accordance with the terms of such
// license agreement and with the inclusion of the above copyright notice.
// This computer software or any other copies thereof may not be provided
// or otherwise made available to any other person.
//
// U.S. Government Restricted Rights.  This computer software: (a) was
// developed at private expense and is in all respects the proprietary
// information of 60East Technologies Inc.; (b) was not developed with
// government funds; (c) is a trade secret of 60East Technologies Inc.
// for all purposes of the Freedom of Information Act; and (d) is a
// commercial item and thus, pursuant to Section 12.212 of the Federal
// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
// Government's use, duplication or disclosure of the computer software
// is subject to the restrictions set forth by 60East Technologies Inc..
//

#ifndef _HACLIENT_H_
#define _HACLIENT_H_

#include <amps/ampsplusplus.hpp>
#include <amps/HAClientImpl.hpp>
#include <amps/MemoryPublishStore.hpp>
#include <amps/PublishStore.hpp>
#include <amps/MemoryBookmarkStore.hpp>
#include <amps/MMapBookmarkStore.hpp>



namespace AMPS
{

  class HAClient : public Client
  {
  public:
    HAClient()
      : Client(new HAClientImpl(std::string()))
    {
    }

    HAClient(const std::string& name_)
      : Client(new HAClientImpl(name_))
    {
    }

    HAClient(HAClientImpl* body_) : Client((ClientImpl*)body_) {}

    HAClient(const HAClient& rhs) : Client((const Client&)rhs) {}

    HAClient& operator=(const HAClient& rhs)
    {
      Client::operator=((const Client&)rhs);
      return *this;
    }

    void setTimeout(int timeout_)
    {
      getBody().setTimeout(timeout_);
    }

    int getTimeout() const
    {
      return getBody().getTimeout();
    }

    void setReconnectDelay(int reconnectDelay_)
    {
      getBody().setReconnectDelay((unsigned int)reconnectDelay_);
    }

    int getReconnectDelay() const
    {
      return (int)(getBody().getReconnectDelay());
    }

    void setReconnectDelayStrategy(const ReconnectDelayStrategy& strategy_)
    {
      getBody().setReconnectDelayStrategy(strategy_);
    }

    ReconnectDelayStrategy getReconnectDelayStrategy(void) const
    {
      return getBody().getReconnectDelayStrategy();
    }

    std::string getLogonOptions(void) const
    {
      return getBody().getLogonOptions();
    }

    void setLogonOptions(const char* logonOptions_)
    {
      getBody().setLogonOptions(logonOptions_);
    }

    void setLogonOptions(const std::string& logonOptions_)
    {
      getBody().setLogonOptions(logonOptions_);
    }

    ServerChooser getServerChooser() const
    {
      return getBody().getServerChooser();
    }

    void setServerChooser(const ServerChooser& serverChooser_)
    {
      getBody().setServerChooser(serverChooser_);
    }

    static HAClient createMemoryBacked(const std::string& name_)
    {
      HAClient client(name_);
      client.setBookmarkStore(BookmarkStore(new MemoryBookmarkStore()));
      client.setPublishStore(Store(new MemoryPublishStore(10000)));
      return client;
    }

    //  that is named subscribeLogName_.
    static HAClient createFileBacked(const std::string& name_,
                                     const std::string& publishLogName_,
                                     const std::string& subscribeLogName_)
    {
      HAClient client(name_);
      client.setBookmarkStore(BookmarkStore(
                                new MMapBookmarkStore(subscribeLogName_)));
      client.setPublishStore(Store(new PublishStore(publishLogName_)));
      return client;
    }

    void connectAndLogon()
    {
      getBody().connectAndLogon();
    }

    bool disconnected() const
    {
      return getBody().disconnected();
    }

    ConnectionInfo getConnectionInfo() const
    {
      return getBody().getConnectionInfo();
    }

    ConnectionInfo gatherConnectionInfo() const // -V524
    {
      return getBody().getConnectionInfo();
    }

  private:
    // Must make disconnect handler a friend to call the internal version
    // of connectAndLogon so that the _disconnected flag won't get reset.
    friend void HAClientImpl::HADisconnectHandler::invoke(Client&, void*);

    HAClient(const Client& rhs)
      : Client(rhs)
    {
      assert(typeid(HAClientImpl) == typeid(_body.get()));
    }

    void connectAndLogonInternal()
    {
      getBody().connectAndLogonInternal();
    }

    const HAClientImpl& getBody() const
    {
      return dynamic_cast<const HAClientImpl&>(_body.get());
    }

    HAClientImpl& getBody()
    {
      return dynamic_cast<HAClientImpl&>(_body.get());
    }

  }; // class HAClient
  inline void HAClientImpl::HADisconnectHandler::invoke(Client& client, void*)
  {
    HAClient haClient(client);
    // Intentional disconnect, bail
    if (haClient.disconnected())
    {
      return;
    }
    DisconnectedException de("Disconnected");
    haClient.getServerChooser().reportFailure((AMPSException&)de,
                                              haClient.gatherConnectionInfo());
    try
    {
      haClient.connectAndLogonInternal();
    }
    catch (RetryOperationException& )
    {
      throw;
    }
    catch (AMPSException& )
    {
      // -V565
    }
  }

}// namespace AMPS

#endif //_HACLIENT_H_