HAClient.hpp

Go to the documentation of this file.

//
// Copyright (c) 2010-2021 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 <ampsplusplus.hpp>
#include <HAClientImpl.hpp>
#include <MemoryPublishStore.hpp>
#include <PublishStore.hpp>
#include <MemoryBookmarkStore.hpp>
#include <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()));
 // Doing extra dynamic_cast to throw if bad coversion
 //dynamic_cast<HAClientImpl*>(&(_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( AMPSException& )
 { // -V565
 }
}

}// namespace AMPS

#endif //_HACLIENT_H_