*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "IBean.h"
+#include "Integration/Core/CErrorHandler.h"
+#include "Integration/Core/CMessageHandler.h"
+#include "Integration/Core/CSimpleAsyncTaskExecutor.h"
+#include "Integration/Core/CSourcePollingChannelAdapter.h"
+#include "Integration/Dependencies/CPollerMetadata.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationAppContext.h"
+#include "Integration/IIntegrationObject.h"
+#include "amqpCore/AmqpHeaderMapper.h"
+#include "amqpCore/AmqpMessageListenerSource.h"
+#include "amqpClient/api/ConnectionFactory.h"
+#include "amqpCore/DefaultAmqpHeaderMapper.h"
+#include "amqpCore/Queue.h"
+#include "Common/CCafRegex.h"
+#include "Exception/CCafException.h"
#include "AmqpInboundChannelAdapterInstance.h"
+
using namespace Caf::AmqpIntegration;
AmqpInboundChannelAdapterInstance::AmqpInboundChannelAdapterInstance() :
#ifndef AmqpInboundChannelAdapterInstance_h
#define AmqpInboundChannelAdapterInstance_h
+
+#include "Integration/IIntegrationAppContextAware.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationAppContext.h"
+#include "Integration/ITaskExecutor.h"
+#include "amqpCore/SimpleMessageListenerContainer.h"
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IPhased.h"
+#include "Integration/ISmartLifecycle.h"
+
namespace Caf { namespace AmqpIntegration {
/**
*/
#include "stdafx.h"
+
+#include "amqpCore/AmqpOutboundEndpoint.h"
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationAppContext.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IMessageChannel.h"
+#include "amqpCore/AmqpTemplate.h"
+#include "Exception/CCafException.h"
+#include "Common/IAppConfig.h"
#include "AmqpOutboundEndpointInstance.h"
using namespace Caf::AmqpIntegration;
#ifndef AMQPOUTBOUNDENDPOINTINSTANCE_H_
#define AMQPOUTBOUNDENDPOINTINSTANCE_H_
+
+#include "Integration/IIntegrationAppContextAware.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/Core/CMessagingTemplate.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationAppContext.h"
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ILifecycle.h"
+
namespace Caf { namespace AmqpIntegration {
/**
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "amqpCore/Binding.h"
+#include "Exception/CCafException.h"
#include "BindingInstance.h"
using namespace Caf::AmqpIntegration;
#ifndef BINDINGINSTANCE_H_
#define BINDINGINSTANCE_H_
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IDocument.h"
+#include "amqpCore/Binding.h"
+#include "amqpCore/BindingInternal.h"
+
namespace Caf { namespace AmqpIntegration {
/**
*/
#include "stdafx.h"
+
+#include "Doc/PersistenceDoc/CPersistenceProtocolDoc.h"
+#include "amqpCore/CachingConnectionFactory.h"
+#include "amqpClient/api/Connection.h"
+#include "amqpCore/ConnectionListener.h"
+#include "Exception/CCafException.h"
#include "CachingConnectionFactoryObj.h"
using namespace Caf::AmqpIntegration;
#ifndef CACHINGCONNECTIONFACTORYOBJ_H_
#define CACHINGCONNECTIONFACTORYOBJ_H_
+#include "IBean.h"
+
+#include "amqpCore/CachingConnectionFactory.h"
+#include "amqpClient/api/Connection.h"
+#include "amqpCore/ConnectionListener.h"
+
namespace Caf { namespace AmqpIntegration {
/**
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "amqpCore/Binding.h"
+#include "Exception/CCafException.h"
+#include "Common/IAppConfig.h"
#include "ExchangeInstance.h"
#include "BindingInstance.h"
#ifndef EXCHANGEINSTANCE_H_
#define EXCHANGEINSTANCE_H_
+
+#include "Integration/IIntegrationObject.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationAppContext.h"
+#include "amqpCore/Binding.h"
+#include "amqpCore/Exchange.h"
+#include "amqpCore/ExchangeInternal.h"
+
namespace Caf { namespace AmqpIntegration {
/**
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Exception/CCafException.h"
#include "IntegrationObjects.h"
#include "RabbitTemplateInstance.h"
#include "RabbitAdminInstance.h"
#ifndef INTEGRATIONOBJECTS_H_
#define INTEGRATIONOBJECTS_H_
+
+#include "IBean.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf { namespace AmqpIntegration {
/**
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "amqpCore/Queue.h"
+#include "Exception/CCafException.h"
+#include "Common/IAppConfig.h"
#include "QueueInstance.h"
using namespace Caf::AmqpIntegration;
#ifndef QUEUEINSTANCE_H_
#define QUEUEINSTANCE_H_
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IDocument.h"
+#include "amqpCore/Queue.h"
+#include "amqpCore/QueueInternal.h"
+
namespace Caf { namespace AmqpIntegration {
/**
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "IBean.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationAppContext.h"
+#include "Integration/IIntegrationObject.h"
+#include "amqpCore/Binding.h"
+#include "amqpCore/BindingInternal.h"
+#include "amqpClient/api/ConnectionFactory.h"
+#include "amqpCore/Exchange.h"
+#include "amqpCore/ExchangeInternal.h"
+#include "amqpCore/Queue.h"
+#include "amqpCore/QueueInternal.h"
#include "RabbitAdminInstance.h"
using namespace Caf::AmqpIntegration;
#ifndef RABBITADMININSTANCE_H_
#define RABBITADMININSTANCE_H_
+
+#include "Integration/IIntegrationAppContextAware.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationAppContext.h"
+#include "amqpCore/Binding.h"
+#include "amqpCore/Exchange.h"
+#include "amqpCore/Queue.h"
+#include "amqpCore/RabbitAdmin.h"
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ILifecycle.h"
+
namespace Caf { namespace AmqpIntegration {
/**
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "IBean.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "amqpCore/AmqpHeaderMapper.h"
+#include "amqpCore/AmqpTemplate.h"
+#include "amqpClient/api/ConnectionFactory.h"
+#include "Common/IAppConfig.h"
#include "RabbitTemplateInstance.h"
using namespace Caf::AmqpIntegration;
#ifndef RABBITTEMPLATEINSTANCE_H_
#define RABBITTEMPLATEINSTANCE_H_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "amqpCore/AmqpHeaderMapper.h"
+#include "amqpCore/AmqpTemplate.h"
+#include "amqpCore/RabbitTemplate.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ILifecycle.h"
+
namespace Caf { namespace AmqpIntegration {
CAF_DECLARE_CLASS_AND_IMPQI_POINTER(RabbitTemplateInstance);
*/
#include "stdafx.h"
+
+#include "Doc/PersistenceDoc/CCertPathCollectionDoc.h"
+#include "Doc/PersistenceDoc/CLocalSecurityDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolDoc.h"
+#include "amqpCore/CachingConnectionFactory.h"
+#include "amqpClient/api/Connection.h"
+#include "amqpCore/ConnectionListener.h"
#include "SecureCachingConnectionFactoryObj.h"
using namespace Caf::AmqpIntegration;
#ifndef SECURECACHINGCONNECTIONFACTORYOBJ_H_
#define SECURECACHINGCONNECTIONFACTORYOBJ_H_
+#include "IBean.h"
+
+#include "amqpCore/CachingConnectionFactory.h"
+#include "amqpClient/api/Connection.h"
+#include "amqpCore/ConnectionListener.h"
+
namespace Caf { namespace AmqpIntegration {
/**
#include <CommonDefines.h>
#include <Integration.h>
-#include "../../../amqpCore/src/amqpClient/api/amqpClient.h"
#include "../../../amqpCore/src/amqpCore/amqpIntegrationCoreLink.h"
#include "amqpIntegrationDefines.h"
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CCmsMessage_h_
+#define CCmsMessage_h_
+
+#include <openssl/ssl.h>
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+
+namespace Caf {
+
+class CCmsMessage {
+public:
+ CCmsMessage();
+ virtual ~CCmsMessage();
+
+public:
+ void initialize(
+ const std::string& appId,
+ const std::string& pmeId);
+
+public:
+ void signBufferToBuffer(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ SmartPtrCDynamicByteArray& outputBuffer) const;
+
+ void verifyBufferToBuffer(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ SmartPtrCDynamicByteArray& outputBuffer) const;
+
+ void encryptBufferToBuffer(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ SmartPtrCDynamicByteArray& outputBuffer) const;
+
+ void decryptBufferToBuffer(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ SmartPtrCDynamicByteArray& outputBuffer) const;
+
+ void compressBufferToBuffer(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ SmartPtrCDynamicByteArray& outputBuffer) const;
+
+ void uncompressBufferToBuffer(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ SmartPtrCDynamicByteArray& outputBuffer) const;
+
+public:
+ void signBufferToFile(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ const std::string& outputPath) const;
+
+ void verifyBufferToFile(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ const std::string& outputPath) const;
+
+ void encryptBufferToFile(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ const std::string& outputPath) const;
+
+ void decryptBufferToFile(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ const std::string& outputPath) const;
+
+ void compressBufferToFile(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ const std::string& outputPath) const;
+
+ void uncompressBufferToFile(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ const std::string& outputPath) const;
+
+public:
+ void signFileToBuffer(
+ const std::string& inputPath,
+ SmartPtrCDynamicByteArray& outputBuffer) const;
+
+ void verifyFileToBuffer(
+ const std::string& inputPath,
+ SmartPtrCDynamicByteArray& outputBuffer) const;
+
+ void encryptFileToBuffer(
+ const std::string& inputPath,
+ SmartPtrCDynamicByteArray& outputBuffer) const;
+
+ void decryptFileToBuffer(
+ const std::string& inputPath,
+ SmartPtrCDynamicByteArray& outputBuffer) const;
+
+ void compressFileToBuffer(
+ const std::string& inputPath,
+ SmartPtrCDynamicByteArray& outputBuffer) const;
+
+ void uncompressFileToBuffer(
+ const std::string& inputPath,
+ SmartPtrCDynamicByteArray& outputBuffer) const;
+
+public:
+ void signFileToFile(
+ const std::string& inputPath,
+ const std::string& outputPath) const;
+
+ void verifyFileToFile(
+ const std::string& inputPath,
+ const std::string& outputPath) const;
+
+ void encryptFileToFile(
+ const std::string& inputPath,
+ const std::string& outputPath) const;
+
+ void decryptFileToFile(
+ const std::string& inputPath,
+ const std::string& outputPath) const;
+
+ void compressFileToFile(
+ const std::string& inputPath,
+ const std::string& outputPath) const;
+
+ void uncompressFileToFile(
+ const std::string& inputPath,
+ const std::string& outputPath) const;
+
+private:
+ void sign(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ const std::string& inputPath,
+ SmartPtrCDynamicByteArray& outputBuffer,
+ const std::string& outputPath) const;
+
+ void verify(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ const std::string& inputPath,
+ SmartPtrCDynamicByteArray& outputBuffer,
+ const std::string& outputPath) const;
+
+ void encrypt(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ const std::string& inputPath,
+ SmartPtrCDynamicByteArray& outputBuffer,
+ const std::string& outputPath) const;
+
+ void decrypt(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ const std::string& inputPath,
+ SmartPtrCDynamicByteArray& outputBuffer,
+ const std::string& outputPath) const;
+
+ void compress(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ const std::string& inputPath,
+ SmartPtrCDynamicByteArray& outputBuffer,
+ const std::string& outputPath) const;
+
+ void uncompress(
+ const SmartPtrCDynamicByteArray& inputBuffer,
+ const std::string& inputPath,
+ SmartPtrCDynamicByteArray& outputBuffer,
+ const std::string& outputPath) const;
+
+private:
+ void checkCrlf(
+ const std::string& funcName,
+ const std::string& direction,
+ const SmartPtrCDynamicByteArray& buffer,
+ const std::string& path) const;
+
+ void checkCrlf(
+ const std::string& funcName,
+ const std::string& direction,
+ const SmartPtrCDynamicByteArray& buffer) const;
+
+ void checkCrlf(
+ const std::string& funcName,
+ const std::string& direction,
+ const std::string& path) const;
+
+private:
+ std::string getReqDirPath(
+ const std::string& directory,
+ const std::string& subdir,
+ const std::string& subdir1 = std::string()) const;
+
+ std::string getReqFilePath(
+ const std::string& directory,
+ const std::string& filename) const;
+
+ Cdeqstr getReqFilePaths(
+ const std::string& directory,
+ const std::string& subdir) const;
+
+ std::string getReqRmtCertsDir(
+ const std::string& appId,
+ const std::string& pmeId) const;
+
+ void getExistingDir(
+ const std::string& parentDir,
+ const std::string& childDir,
+ std::string& result,
+ std::string& errDirs) const;
+
+private:
+ bool _isInitialized;
+
+ EVP_CIPHER* _cipher;
+ std::string _persistenceDir;
+
+ std::string _nullPath;
+ SmartPtrCDynamicByteArray _nullBuffer;
+
+ std::string _encryptPublicKeyPath;
+ std::string _decryptPublicKeyPath;
+ std::string _decryptPrivateKeyPath;
+ std::string _signPublicKeyPath;
+ std::string _signPrivateKeyPath;
+ Cdeqstr _caCertificatePaths;
+
+ bool _checkCrlf;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CCmsMessage);
+};
+
+CAF_DECLARE_SMART_POINTER(CCmsMessage);
+
+}
+
+#endif // #ifndef CCmsMessage_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: July 3, 2015
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CCmsMessageAttachments_h_
+#define CCmsMessageAttachments_h_
+
+
+
+#include "CCmsMessage.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+
+namespace Caf {
+
+class CCmsMessageAttachments {
+public:
+ CCmsMessageAttachments();
+ virtual ~CCmsMessageAttachments();
+
+public:
+ void initialize(
+ const SmartPtrCCmsMessage& cmsMessage);
+
+public:
+ void enforceSecurityOnAttachments(
+ const std::deque<SmartPtrCAttachmentDoc>& attachmentCollection,
+ const bool isSigningEnforced,
+ const bool isEncryptionEnforced) const;
+
+ std::deque<SmartPtrCAttachmentDoc> encryptAndSignAttachments(
+ const std::deque<SmartPtrCAttachmentDoc>& sourceAttachmentCollection) const;
+
+ SmartPtrCAttachmentDoc encryptAndSignAttachment(
+ const std::string& sourceAttachmentPath,
+ const SmartPtrCAttachmentDoc& sourceAttachment,
+ const std::map<std::string, std::string>& uriParameters = std::map<std::string, std::string>()) const;
+
+ std::deque<SmartPtrCAttachmentDoc> decryptAndVerifyAttachments(
+ const std::deque<SmartPtrCAttachmentDoc>& sourceAttachmentCollection) const;
+
+ SmartPtrCAttachmentDoc decryptAndVerifyAttachment(
+ const std::string& sourceAttachmentPath,
+ const SmartPtrCAttachmentDoc& sourceAttachment,
+ const std::map<std::string, std::string>& uriParameters) const;
+
+private:
+ void signAttachment(
+ const std::string& sourceAttachmentPath,
+ const SmartPtrCAttachmentDoc& sourceAttachment,
+ const std::map<std::string, std::string>& uriParameters,
+ std::string& destAttachmentPath,
+ SmartPtrCAttachmentDoc& destAttachment) const;
+
+ void verifyAttachment(
+ const std::string& sourceAttachmentPath,
+ const SmartPtrCAttachmentDoc& sourceAttachment,
+ const std::map<std::string, std::string>& uriParameters,
+ std::string& destAttachmentPath,
+ SmartPtrCAttachmentDoc& destAttachment) const;
+
+ void encryptAttachment(
+ const std::string& sourceAttachmentPath,
+ const SmartPtrCAttachmentDoc& sourceAttachment,
+ const std::map<std::string, std::string>& uriParameters,
+ std::string& destAttachmentPath,
+ SmartPtrCAttachmentDoc& destAttachment) const;
+
+ void decryptAttachment(
+ const std::string& sourceAttachmentPath,
+ const SmartPtrCAttachmentDoc& sourceAttachment,
+ const std::map<std::string, std::string>& uriParameters,
+ std::string& destAttachmentPath,
+ SmartPtrCAttachmentDoc& destAttachment) const;
+
+private:
+ void removeStr(
+ std::string& sourceStr,
+ const std::string& strToRemove) const;
+
+ void enforceSigning(
+ const bool isSigningEnforced,
+ const SmartPtrCAttachmentDoc& attachment) const;
+
+ void enforceEncryption(
+ const bool isEncryptionEnforced,
+ const SmartPtrCAttachmentDoc& attachment) const;
+
+private:
+ bool _isInitialized;
+
+ SmartPtrCCmsMessage _cmsMessage;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CCmsMessageAttachments);
+};
+
+CAF_DECLARE_SMART_POINTER(CCmsMessageAttachments);
+
+}
+
+#endif // #ifndef CCmsMessageAttachments_h_
--- /dev/null
+/*
+ * Created on: Nov 26, 2014
+ * Author: bwilliams
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CMessageDeliveryRecord_h
+#define CMessageDeliveryRecord_h
+
+
+#include "CMessagePartDescriptorSourceRecord.h"
+#include "Integration/IIntMessage.h"
+
+namespace Caf {
+
+class CMessageDeliveryRecord {
+public:
+ CMessageDeliveryRecord();
+ virtual ~CMessageDeliveryRecord();
+
+public:
+ void initialize(
+ const UUID& correlationId,
+ const uint32 numberOfParts,
+ const uint32 startingPartNumber,
+ const std::deque<SmartPtrCMessagePartDescriptorSourceRecord>& messagePartSources,
+ const IIntMessage::SmartPtrCHeaders& messageHeaders);
+
+public:
+ UUID getCorrelationId() const;
+
+ std::string getCorrelationIdStr() const;
+
+ uint32 getNumberOfParts() const;
+
+ uint32 getStartingPartNumber() const;
+
+ std::deque<SmartPtrCMessagePartDescriptorSourceRecord> getMessagePartSources() const;
+
+ IIntMessage::SmartPtrCHeaders getMessageHeaders() const;
+
+private:
+ bool _isInitialized;
+ UUID _correlationId;
+ uint32 _numberOfParts;
+ uint32 _startingPartNumber;
+ std::deque<SmartPtrCMessagePartDescriptorSourceRecord> _messagePartSources;
+ IIntMessage::SmartPtrCHeaders _messageHeaders;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CMessageDeliveryRecord);
+};
+
+CAF_DECLARE_SMART_POINTER(CMessageDeliveryRecord);
+
+}
+
+#endif /* CMessageDeliveryRecord_h */
--- /dev/null
+/*
+ * Created on: Nov 19, 2014
+ * Author: bwilliams
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CMessagePartDescriptor_h
+#define CMessagePartDescriptor_h
+
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+
+namespace Caf {
+
+class CMessagePartDescriptor;
+CAF_DECLARE_SMART_POINTER(CMessagePartDescriptor);
+
+/**
+ * Class that emits and parses message parts header blocks.<br>
+ */
+class CMessagePartDescriptor {
+public:
+ /**
+ * Converts the BLOCK_SIZE data in a ByteBuffer into a MessagePartsHeader
+ * <p>
+ * The incoming ByteBuffer position will be modified.
+ * @param buffer ByteBuffer to convert
+ * @return a MessagePartsHeader
+ */
+ static SmartPtrCMessagePartDescriptor fromByteBuffer(SmartPtrCDynamicByteArray& buffer);
+
+ /**
+ * Converts a byte array into a MessagePartsHeader
+ * @param blockData byte array to convert
+ * @return a MessagePartsHeader
+ */
+ static SmartPtrCMessagePartDescriptor fromArray(SmartPtrCDynamicByteArray& blockData);
+
+ static SmartPtrCDynamicByteArray toArray(const uint16 attachmentNumber,
+ const uint32 partNumber, const uint32 dataSize, const uint32 dataOffset);
+
+public:
+ CMessagePartDescriptor();
+ virtual ~CMessagePartDescriptor();
+
+public:
+ /**
+ * @param correlationId the correlation id
+ * @param numberOfParts the total number of parts
+ */
+ void initialize(
+ const uint16 attachmentNumber,
+ const uint32 partNumber,
+ const uint32 dataSize,
+ const uint32 dataOffset);
+
+ /**
+ * @return the attachmentNumber
+ */
+ uint16 getAttachmentNumber() const;
+ std::string getAttachmentNumberStr() const;
+
+ /**
+ * @return the partNumber
+ */
+ uint32 getPartNumber() const;
+
+ /**
+ * @return the dataSize
+ */
+ uint32 getDataSize() const;
+
+ /**
+ * @return the dataOffset
+ */
+ uint32 getDataOffset() const;
+
+public:
+ /**
+ * The <code>BLOCK_SIZE</code> field stores the size of a <code>MessagePartsHeader</code> in byte array form.<br>
+ */
+ static const uint32 BLOCK_SIZE = 20;
+ static const byte CAF_MSG_VERSION = 1;
+
+private:
+ static const byte RESERVED = (byte)0xcd;
+
+private:
+ bool _isInitialized;
+ uint16 _attachmentNumber;
+ uint32 _partNumber;
+ uint32 _dataSize;
+ uint32 _dataOffset;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CMessagePartDescriptor);
+};
+
+}
+
+#endif /* CMessagePartDescriptor_h */
--- /dev/null
+/*
+ * Created on: Nov 26, 2014
+ * Author: bwilliams
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CMessagePartDescriptorSourceRecord_h
+#define CMessagePartDescriptorSourceRecord_h
+
+namespace Caf {
+
+class CMessagePartDescriptorSourceRecord {
+public:
+ CMessagePartDescriptorSourceRecord();
+ virtual ~CMessagePartDescriptorSourceRecord();
+
+public:
+ void initialize(
+ const uint16 attachmentNumber,
+ const std::string filePath,
+ const uint32 dataOffset,
+ const uint32 dataLength);
+
+public:
+ uint16 getAttachmentNumber() const;
+
+ std::string getFilePath() const;
+
+ uint32 getDataOffset() const;
+
+ uint32 getDataLength() const;
+
+private:
+ bool _isInitialized;
+ uint16 _attachmentNumber;
+ std::string _filePath;
+ uint32 _dataOffset;
+ uint32 _dataLength;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CMessagePartDescriptorSourceRecord);
+};
+
+CAF_DECLARE_SMART_POINTER(CMessagePartDescriptorSourceRecord);
+
+}
+
+#endif /* CMessagePartDescriptorSourceRecord_h */
--- /dev/null
+/*
+ * Created on: Nov 26, 2014
+ * Author: bwilliams
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CMessagePartRecord_h
+#define CMessagePartRecord_h
+
+namespace Caf {
+
+class CMessagePartRecord {
+public:
+ CMessagePartRecord();
+ virtual ~CMessagePartRecord();
+
+public:
+ void initialize(
+ const uint16 attachmentNumber,
+ const std::string filePath,
+ const uint64 dataOffset,
+ const uint64 dataLength);
+
+public:
+ uint16 getAttachmentNumber() const;
+
+ std::string getFilePath() const;
+
+ uint64 getDataOffset() const;
+
+ uint64 getDataLength() const;
+
+ void setAttachmentNumber(const uint16 attachmentNumber);
+
+ void setFilePath(const std::string& filePath);
+
+ void setDataOffset(const uint64 dataOffset);
+
+ void setDataLength(const uint64 dataLength);
+
+private:
+ bool _isInitialized;
+ uint16 _attachmentNumber;
+ std::string _filePath;
+ uint64 _dataOffset;
+ uint64 _dataLength;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CMessagePartRecord);
+};
+
+CAF_DECLARE_SMART_POINTER(CMessagePartRecord);
+
+}
+
+#endif /* CMessagePartRecord_h */
--- /dev/null
+/*
+ * Created on: Nov 19, 2014
+ * Author: bwilliams
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CMessagePartsHeader_h
+#define CMessagePartsHeader_h
+
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+
+namespace Caf {
+
+class CMessagePartsHeader;
+CAF_DECLARE_SMART_POINTER(CMessagePartsHeader);
+
+/**
+ * Class that emits and parses message parts header blocks.<br>
+ */
+class CMessagePartsHeader {
+public:
+ /**
+ * Converts the BLOCK_SIZE data in a ByteBuffer into a MessagePartsHeader
+ * <p>
+ * The incoming ByteBuffer position will be modified.
+ * @param buffer ByteBuffer to convert
+ * @return a MessagePartsHeader
+ */
+ static SmartPtrCMessagePartsHeader fromByteBuffer(SmartPtrCDynamicByteArray& buffer);
+
+ /**
+ * Converts a byte array into a MessagePartsHeader
+ * @param blockData byte array to convert
+ * @return a MessagePartsHeader
+ */
+ static SmartPtrCMessagePartsHeader fromArray(SmartPtrCDynamicByteArray& blockData);
+
+ static SmartPtrCDynamicByteArray toArray(const UUID correlationId,
+ const uint32 numberOfParts);
+
+public:
+ CMessagePartsHeader();
+ virtual ~CMessagePartsHeader();
+
+public:
+ /**
+ * @param correlationId the correlation id
+ * @param numberOfParts the total number of parts
+ */
+ void initialize(
+ const UUID correlationId,
+ const uint32 numberOfParts);
+
+ /**
+ * @return the correlationId
+ */
+ UUID getCorrelationId() const;
+ std::string getCorrelationIdStr() const;
+
+ /**
+ * @return the numberOfParts
+ */
+ uint32 getNumberOfParts() const;
+
+public:
+ /**
+ * The <code>BLOCK_SIZE</code> field stores the size of a <code>MessagePartsHeader</code> in byte array form.<br>
+ */
+ static const uint32 BLOCK_SIZE = 24;
+ static const byte CAF_MSG_VERSION = 1;
+
+private:
+ static const byte RESERVED1 = (byte)0xcd;
+ static const byte RESERVED2 = (byte)0xcd;
+ static const byte RESERVED3 = (byte)0xcd;
+
+private:
+ bool _isInitialized;
+ UUID _correlationId;
+ uint32 _numberOfParts;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CMessagePartsHeader);
+};
+
+}
+
+#endif /* CMessagePartsHeader_h */
--- /dev/null
+/*
+ * Created on: Aug 16, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef ReplyToResolver_h
+#define ReplyToResolver_h
+
+
+#include "ICafObject.h"
+
+#include "Integration/IIntMessage.h"
+
+namespace Caf {
+struct __declspec(novtable) ReplyToResolver : public ICafObject {
+ CAF_DECL_UUID("4D306795-4475-4D2C-BEF0-0ADE28843BBC")
+
+ virtual std::string cacheReplyTo(const SmartPtrIIntMessage& message) = 0;
+
+ virtual std::string lookupReplyTo(const SmartPtrIIntMessage& message) = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(ReplyToResolver);
+}
+#endif /* ReplyToResolver_h */
*/
#include "stdafx.h"
-#include "CCmsMessageUtils.h"
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
#include "CCmsMessage.h"
+#include "Exception/CCafException.h"
+#include "CCmsMessageUtils.h"
#include <fstream>
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+
+#include "CCmsMessage.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
#include "CCmsMessageAttachments.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
#include "CCmsMessageTransformer.h"
using namespace Caf;
#ifndef CCmsMessageTransformer_h_
#define CCmsMessageTransformer_h_
+
+#include "IBean.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Integration/Caf/CBeanPropertiesHelper.h"
+#include "Integration/Caf/CCafMessageHeaders.h"
+#include "CCmsMessage.h"
+#include "CCmsMessageAttachments.h"
+#include "Common/IAppContext.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Exception/CCafException.h"
#include "CCmsMessageTransformerInstance.h"
+#include "Integration/Caf/CCafMessageCreator.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
using namespace Caf;
#include <openssl/ssl.h>
+#include "CCmsMessageAttachments.h"
+#include "Common/IAppContext.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ITransformer.h"
+
namespace Caf {
class CCmsMessageTransformerInstance :
*/
#include "stdafx.h"
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Exception/CCafException.h"
#include "CCmsMessageUtils.h"
using namespace Caf;
#define CCmsMessageUtil_h_
#include <openssl/cms.h>
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
#include <openssl/conf.h>
#include <openssl/engine.h>
#include <openssl/err.h>
*/
#include "stdafx.h"
+
+#include "Integration/Caf/CCafMessagePayload.h"
+#include "Doc/ResponseDoc/CEventKeyDoc.h"
+#include "Doc/ResponseDoc/CManifestDoc.h"
+#include "IVariant.h"
+#include "Integration/IIntMessage.h"
+#include "Common/CCafRegex.h"
+#include "Exception/CCafException.h"
#include "CEventTopicCalculatorInstance.h"
using namespace Caf;
const SmartPtrCEventKeyDoc eventKey = *key;
topicBld << '.' << replaceDots.replaceLiteral(eventKey->getValue(), "_");
}
-
+
return CVariant::createString(topicBld.str());
}
#ifndef CEventTopicCalculatorInstance_h
#define CEventTopicCalculatorInstance_h
+
+#include "IBean.h"
+
+#include "IVariant.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IExpressionInvoker.h"
+
namespace Caf {
class CEventTopicCalculatorInstance :
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
#include "CIncomingMessageHandler.h"
using namespace Caf;
#ifndef CIncomingMessageHandler_h_
#define CIncomingMessageHandler_h_
+
+#include "IBean.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Integration/Caf/CCafMessageHeadersWriter.h"
+#include "CMessagePartDescriptor.h"
+#include "Common/IAppContext.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
#include "CIncomingMessageHandlerInstance.h"
+#include "CMessagePartsHeader.h"
+#include "Integration/Core/MessageHeaders.h"
+#include "Integration/Caf/CCafMessageCreator.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
+#include "Integration/Caf/CCafMessagePayload.h"
+#include "Integration/Core/CMessageHeaderUtils.h"
using namespace Caf;
#ifndef CIncomingMessageHandlerInstance_h
#define CIncomingMessageHandlerInstance_h
-#include "ReplyToResolver.h"
+
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ITransformer.h"
namespace Caf {
*/
#include "stdafx.h"
+
+#include "CMessagePartDescriptorSourceRecord.h"
+#include "Integration/IIntMessage.h"
#include "CMessageDeliveryRecord.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
#include "CMessagePartDescriptor.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "CMessagePartDescriptorSourceRecord.h"
+#include "CMessagePartRecord.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Exception/CCafException.h"
#include "CMessagePartDescriptorCalculator.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
+#include "Integration/Caf/CCafMessagePayload.h"
+#include "Integration/Caf/CCafMessageCreator.h"
using namespace Caf;
#ifndef CMessagePartDescriptorCalculator_h
#define CMessagePartDescriptorCalculator_h
+
+#include "CMessagePartDescriptorSourceRecord.h"
+#include "CMessagePartRecord.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+
namespace Caf {
class CMessagePartDescriptorCalculator {
*/
#include "stdafx.h"
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
#include "CMessagePartsBuilder.h"
using namespace Caf;
#ifndef CMessagePartsBuilder_h
#define CMessagePartsBuilder_h
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+
namespace Caf {
/**
*/
#include "stdafx.h"
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
#include "CMessagePartsHeader.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
#include "CMessagePartsParser.h"
using namespace Caf;
#ifndef CMessagePartsParser_h
#define CMessagePartsParser_h
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+
namespace Caf {
/**
*/
#include "stdafx.h"
+
+#include "CMessageDeliveryRecord.h"
+#include "CMessagePartDescriptorSourceRecord.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Integration/Core/CIntMessageHeaders.h"
+#include "Exception/CCafException.h"
#include "COutgoingMessageHandler.h"
+#include "CMessagePartsHeader.h"
+#include "CMessagePartDescriptor.h"
+#include "amqpCore/DefaultAmqpHeaderMapper.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
+#include "Integration/Core/CMessageHeaderUtils.h"
+#include "Integration/Core/MessageHeaders.h"
+#include "Integration/Core/CMessageHeaderUtils.h"
#include <fstream>
#ifndef COutgoingMessageHandler_h
#define COutgoingMessageHandler_h
+
+#include "IBean.h"
+
+#include "CMessageDeliveryRecord.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageProcessor.h"
+
using namespace Caf;
class COutgoingMessageHandler :
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
#include "CProtocolHeaderEnricher.h"
using namespace Caf;
#ifndef CProtocolHeaderEnricher_h_
#define CProtocolHeaderEnricher_h_
+
+#include "IBean.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Integration/Caf/CCafMessageHeadersWriter.h"
+#include "Common/IAppContext.h"
+#include "Doc/CafCoreTypesDoc/CProtocolCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CProtocolDoc.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Exception/CCafException.h"
#include "CProtocolHeaderEnricherInstance.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
using namespace Caf;
#ifndef CProtocolHeaderEnricherInstance_h
#define CProtocolHeaderEnricherInstance_h
-#include "ReplyToResolver.h"
+
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "Doc/CafCoreTypesDoc/CProtocolDoc.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ITransformer.h"
namespace Caf {
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
#include "CReplyToCacher.h"
using namespace Caf;
#ifndef CReplyToCacher_h_
#define CReplyToCacher_h_
+
+#include "IBean.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "IBean.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Exception/CCafException.h"
#include "CReplyToCacherInstance.h"
using namespace Caf;
#ifndef CReplyToCacherInstance_h
#define CReplyToCacherInstance_h
+
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
#include "ReplyToResolver.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ITransformer.h"
namespace Caf {
*/
#include "stdafx.h"
+
+#include "Integration/Caf/CCafMessageHeaders.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "IVariant.h"
+#include "Integration/IIntMessage.h"
+#include "Exception/CCafException.h"
#include "CReplyToResolverInstance.h"
+#include "amqpCore/DefaultAmqpHeaderMapper.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
using namespace Caf;
#ifndef CReplyToResolverInstance_h
#define CReplyToResolverInstance_h
+#include "IBean.h"
+#include "IVariant.h"
#include "ReplyToResolver.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IExpressionInvoker.h"
namespace Caf {
#include "../../../amqpCore/src/amqpCore/amqpIntegrationCoreLink.h"
#include "commIntegrationDefines.h"
-#include <DocXml.h>
#include <DocUtils.h>
-#include "CMessagePartRecord.h"
-#include "CMessagePartDescriptorSourceRecord.h"
-#include "CMessageDeliveryRecord.h"
#include "CMessagePartsParser.h"
#include "CMessagePartsBuilder.h"
-#include "CMessagePartDescriptor.h"
-#include "CMessagePartsHeader.h"
#include "CMessagePartDescriptorCalculator.h"
#include "CCmsMessageUtils.h"
-#include "CCmsMessage.h"
-#include "CCmsMessageAttachments.h"
#endif /* stdafx_h */
--- /dev/null
+/*
+ * Created on: May 2, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQCHANNEL_H_
+#define AMQCHANNEL_H_
+
+#include "amqpClient/TCopyOnWriteContainer.h"
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Common/CAutoMutex.h"
+#include "Exception/CCafException.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/AMQCommand.h"
+#include "amqpClient/ConsumerDispatcher.h"
+#include "amqpClient/ConsumerWorkService.h"
+#include "amqpClient/IConnectionInt.h"
+#include "amqpClient/IRpcContinuation.h"
+#include "amqpClient/amqpImpl/IServerMethod.h"
+#include "amqpClient/api/AmqpMethods.h"
+#include "amqpClient/api/Consumer.h"
+#include "amqpClient/api/GetResponse.h"
+#include "amqpClient/api/ReturnListener.h"
+#include "amqpClient/api/amqpClient.h"
+#include "Common/CThreadSignal.h"
+#include "amqpClient/api/Channel.h"
+
+namespace Caf { namespace AmqpClient {
+
+class AMQChannel;
+CAF_DECLARE_SMART_POINTER(AMQChannel);
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Concrete implementation of a Channel object representing an AMQP channel.
+ */
+class AMQChannel : public Channel {
+public:
+ AMQChannel();
+ virtual ~AMQChannel();
+
+ /**
+ * @brief Initializer
+ * @param connection the owning connection
+ * @param workService the work service to add channel tasks to
+ */
+ void init(
+ const SmartPtrIConnectionInt& connection,
+ const SmartPtrConsumerWorkService& workService);
+
+ /**
+ * @brief Notification of connection closure
+ * <p>
+ * Called by the AMQChannelManager to notify the channel that the parent connect
+ * has closed for the supplied reason.
+ * @param exception the reason for the closure
+ */
+ void notifyConnectionClosed(SmartPtrCCafException& exception);
+
+ /**
+ * @brief Close the channel with the given reason
+ * @param exception reason for closure
+ */
+ void close(SmartPtrCCafException& exception);
+
+public: // Channel
+ uint16 getChannelNumber();
+
+ void close();
+
+ bool isOpen();
+
+public: // Basic
+ void basicAck(
+ const uint64 deliveryTag,
+ const bool ackMultiple);
+
+ SmartPtrGetResponse basicGet(
+ const std::string& queue,
+ const bool noAck);
+
+ void basicPublish(
+ const std::string& exchange,
+ const std::string& routingKey,
+ const AmqpContentHeaders::SmartPtrBasicProperties& properties,
+ const SmartPtrCDynamicByteArray& body);
+
+ void basicPublish(
+ const std::string& exchange,
+ const std::string& routingKey,
+ const bool mandatory,
+ const bool immediate,
+ const AmqpContentHeaders::SmartPtrBasicProperties& properties,
+ const SmartPtrCDynamicByteArray& body);
+
+ AmqpMethods::Basic::SmartPtrConsumeOk basicConsume(
+ const std::string& queue,
+ const SmartPtrConsumer& consumer);
+
+ AmqpMethods::Basic::SmartPtrConsumeOk basicConsume(
+ const std::string& queue,
+ const bool noAck,
+ const SmartPtrConsumer& consumer);
+
+ AmqpMethods::Basic::SmartPtrConsumeOk basicConsume(
+ const std::string& queue,
+ const std::string& consumerTag,
+ const bool noAck,
+ const bool noLocal,
+ const bool exclusive,
+ const SmartPtrConsumer& consumer,
+ const SmartPtrTable& arguments = SmartPtrTable());
+
+ AmqpMethods::Basic::SmartPtrCancelOk basicCancel(
+ const std::string& consumerTag);
+
+ AmqpMethods::Basic::SmartPtrRecoverOk basicRecover(
+ const bool requeue);
+
+ AmqpMethods::Basic::SmartPtrQosOk basicQos(
+ const uint32 prefetchSize,
+ const uint32 prefetchCount,
+ const bool global);
+
+ void basicReject(
+ const uint64 deliveryTag,
+ const bool requeue);
+
+public: // Exchange
+ AmqpMethods::Exchange::SmartPtrDeclareOk exchangeDeclare(
+ const std::string& exchange,
+ const std::string& type,
+ const bool durable = false,
+ const SmartPtrTable& arguments = SmartPtrTable());
+
+ AmqpMethods::Exchange::SmartPtrDeleteOk exchangeDelete(
+ const std::string& exchange,
+ const bool ifUnused);
+
+public: // Queue
+ AmqpMethods::Queue::SmartPtrDeclareOk queueDeclare();
+
+ AmqpMethods::Queue::SmartPtrDeclareOk queueDeclare(
+ const std::string& queue,
+ const bool durable,
+ const bool exclusive,
+ const bool autoDelete,
+ const SmartPtrTable& arguments = SmartPtrTable());
+
+ AmqpMethods::Queue::SmartPtrDeclareOk queueDeclarePassive(
+ const std::string& queue);
+
+ AmqpMethods::Queue::SmartPtrDeleteOk queueDelete(
+ const std::string& queue,
+ const bool ifUnused,
+ const bool ifEmpty);
+
+ AmqpMethods::Queue::SmartPtrPurgeOk queuePurge(
+ const std::string& queue);
+
+ AmqpMethods::Queue::SmartPtrBindOk queueBind(
+ const std::string& queue,
+ const std::string& exchange,
+ const std::string& routingKey,
+ const SmartPtrTable& arguments = SmartPtrTable());
+
+ AmqpMethods::Queue::SmartPtrUnbindOk queueUnbind(
+ const std::string& queue,
+ const std::string& exchange,
+ const std::string& routingKey,
+ const SmartPtrTable& arguments = SmartPtrTable());
+
+ void addReturnListener(
+ const SmartPtrReturnListener& listener);
+
+ bool removeReturnListener(
+ const SmartPtrReturnListener& listener);
+
+private:
+ bool taskHandler();
+
+ void handleCompleteInboundCommand(const SmartPtrAMQCommand& command);
+
+ bool processAsync(const SmartPtrAMQCommand& command);
+
+ void ensureIsOpen();
+
+ SmartPtrAMQCommand execRpc(const SmartPtrIServerMethod& method);
+
+ SmartPtrIRpcContinuation nextOutstandingRpc();
+
+ void transmit(const SmartPtrIServerMethod& method);
+
+ void channelCloseByServerShutdown(const AmqpMethods::Channel::SmartPtrClose& closeMethod);
+
+ void callReturnListeners(const SmartPtrAMQCommand& command);
+
+private:
+ /*
+ * This class hooks the channel into the worker service
+ * thread pool for channel inbound AMQP frame processing
+ */
+ class ChannelTask : public CManagedThreadPool::IThreadTask {
+ public:
+ ChannelTask();
+
+ virtual ~ChannelTask();
+
+ /*
+ * Initialize the thread task
+ * channel is the pointer to the parent channel
+ */
+ void init(SmartPtrAMQChannel channel);
+
+ /*
+ * Thread pool task execution callback
+ *
+ * Calls through to the channel to do the actual work
+ * returns 'true' if the thread pool should remove this task
+ * returns 'false' if the thread pool should requeue this task
+ */
+ bool run();
+
+ private:
+ SmartPtrAMQChannel _channel;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(ChannelTask);
+ };
+ CAF_DECLARE_SMART_POINTER(ChannelTask);
+
+private:
+ static const uint8 DEBUGLOG_FLAG_ENTRYEXIT;
+ static const uint8 DEBUGLOG_FLAG_AMQP;
+
+ bool _isInitialized;
+ volatile bool _isOpen;
+ uint8 _debugLogFlags;
+ SmartPtrIConnectionInt _connection;
+ SmartPtrConsumerWorkService _workService;
+ SmartPtrConsumerDispatcher _dispatcher;
+ uint16 _channelNumber;
+ SmartPtrCAmqpChannel _channelHandle;
+ SmartPtrAMQCommand _command;
+ SmartPtrIRpcContinuation _activeRpc;
+ SmartPtrCAutoMutex _channelMutex;
+ CThreadSignal _channelSignal;
+
+ typedef std::deque<SmartPtrReturnListener> ReturnListenerCollection;
+ typedef TCopyOnWriteContainer<ReturnListenerCollection> CowReturnListenerCollection;
+ CowReturnListenerCollection _returnListeners;
+
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_CM_DECLARE_NOCOPY(AMQChannel);
+};
+
+}}
+
+#endif /* AMQCHANNEL_H_ */
--- /dev/null
+/*
+ * Created on: May 7, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQCHANNELMANAGER_H_
+#define AMQCHANNELMANAGER_H_
+
+
+
+#include "Exception/CCafException.h"
+#include "amqpClient/AMQChannel.h"
+#include "amqpClient/ConsumerWorkService.h"
+#include "amqpClient/api/Channel.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Manages a set of channels for a connection.
+ * Channels are indexed by channel number (<code><b>1.._channelMax</b></code>).
+ */
+class AMQChannelManager {
+public:
+ AMQChannelManager();
+ virtual ~AMQChannelManager();
+
+public:
+ /**
+ * @brief Initialize the manager to control <code><b>channelMax</b></code> channels.
+ * @param workService the service (thread pool) to run the channels in
+ */
+ void init(const SmartPtrConsumerWorkService& workService);
+
+ /**
+ * @brief Create a new channel
+ * @param connection The controlling #Caf::AmqpClient::IConnectionInt connection
+ * @return the new Channel
+ */
+ SmartPtrChannel createChannel(const SmartPtrIConnectionInt& connection);
+
+ /**
+ * @brief Return an existing channel on this connection.
+ * @param channelNumber the number of the required channel
+ * @return the #Caf::AmqpClient::Channel interface to the channel if it exists else
+ * throws an exception
+ */
+ SmartPtrChannel getChannel(const uint16 channelNumber);
+
+ /**
+ * @brief Return the number of open channels
+ * @return the number of open channels
+ */
+ size_t getOpenChannelCount();
+
+ /**
+ * @brief Notify all channels that the connection is closed and the reason for it
+ * @param shutdownException the exception (reason) for the closure
+ */
+ void notifyConnectionClose(SmartPtrCCafException& shutdownException);
+
+ /**
+ * @brief Close achannel with the supplied reason
+ * @param channelNumber the channel to close
+ * @param reason the reason for closure
+ */
+ void closeChannel(const uint16 channelNumber, SmartPtrCCafException& reason);
+
+ /**
+ * @brief Remove a channel from management
+ * @param channelNumber channel number
+ */
+ void removeChannel(const uint16 channelNumber);
+
+private:
+ typedef std::map<uint16, SmartPtrAMQChannel> ChannelMap;
+
+ bool _isInitialized;
+ ChannelMap _channelMap;
+ SmartPtrConsumerWorkService _workService;
+
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(AMQChannelManager);
+};
+CAF_DECLARE_SMART_POINTER(AMQChannelManager);
+
+}}
+
+#endif /* AMQCHANNELMANAGER_H_ */
--- /dev/null
+/*
+ * Created on: May 9, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQCOMMAND_H_
+#define AMQCOMMAND_H_
+
+
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/CAmqpFrame.h"
+#include "amqpClient/CommandAssembler.h"
+#include "amqpClient/amqpImpl/IContentHeader.h"
+#include "amqpClient/amqpImpl/IMethod.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief This class represents an AMQP command
+ * <p>
+ * This class wraps up the method, content header and body information for an
+ * incoming AMQP command.
+ */
+class AMQCommand {
+public:
+ AMQCommand();
+ virtual ~AMQCommand();
+
+ /**
+ * @brief Prepare the object for frame processing
+ */
+ void init();
+
+ /**
+ * @brief Process an AMQP frame
+ * @param frame amqp frame data
+ */
+ bool handleFrame(const SmartPtrCAmqpFrame& frame);
+
+ /**
+ * @brief Return the body if available
+ * @return the body's raw bytes if available or a <code><i>null</i></code> object
+ */
+ SmartPtrCDynamicByteArray getContentBody();
+
+ /**
+ * @brief Return the content header if available
+ * @return the IContentHeader if available or a
+ * <code><i>null</i></code> object
+ */
+ SmartPtrIContentHeader getContentHeader();
+
+ /**
+ * @brief Return the method
+ * @return the IMethod object interface representing the method.
+ * QueryInterface must be used to get to the actual method object
+ */
+ SmartPtrIMethod getMethod();
+
+private:
+ SmartPtrCommandAssembler _assembler;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(AMQCommand);
+};
+CAF_DECLARE_SMART_POINTER(AMQCommand);
+
+}}
+
+#endif /* AMQCOMMAND_H_ */
--- /dev/null
+/*
+ * Created on: May 2, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQCONNECTION_H_
+#define AMQCONNECTION_H_
+
+
+#include "Common/CThreadSignal.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "Common/CManagedThreadPool.h"
+#include "amqpClient/AMQChannelManager.h"
+#include "amqpClient/CAmqpAuthMechanism.h"
+#include "amqpClient/CAmqpConnection.h"
+#include "amqpClient/ConnectionWeakReference.h"
+#include "amqpClient/ConsumerWorkService.h"
+#include "amqpClient/api/Address.h"
+#include "amqpClient/api/CertInfo.h"
+#include "amqpClient/api/Channel.h"
+#include "amqpClient/IConnectionInt.h"
+#include "amqpClient/api/Connection.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Concrete class representing and managing an AMQP connection to a broker.
+ * <p>
+ * To create a broker connection, use a ConnectionFactory created
+ * by calling #createConnectionFactory
+ */
+class AMQConnection : public Connection, public IConnectionInt {
+public:
+ AMQConnection();
+ virtual ~AMQConnection();
+
+public:
+ /**
+ * @brief Initialize the connection.
+ * @param username name used to establish connection
+ * @param password for <code><b>username</b></code>
+ * @param address info needed to establish connection
+ * @param certInfo info needed to establish a secure connection
+ * @param requestedFrameMax max size of frame
+ * @param requestedChannelMax max number of channels
+ * @param requestedHeartbeat hearbeat in seconds
+ * @param connectionTimeout connection timeout in milliseconds
+ * @param consumerThreadCount number of consumer threads
+ */
+ void init(
+ const std::string username,
+ const std::string password,
+ const SmartPtrAddress& address,
+ const SmartPtrCertInfo& certInfo,
+ const uint32 requestedFrameMax,
+ const uint32 requestedChannelMax,
+ const uint32 requestedHeartbeat,
+ const uint32 connectionTimeout,
+ const uint32 consumerThreadCount,
+ const uint16 retries,
+ const uint16 secondsToWait);
+
+ /**
+ * @brief Start up the connection.
+ */
+ void start();
+
+
+public: // Connection
+ SmartPtrChannel createChannel();
+
+ void closeChannel(const SmartPtrChannel& channel);
+
+ void close();
+
+ bool isOpen();
+
+public: // IConnectionInt
+ AMQPStatus amqpConnectionOpenChannel(SmartPtrCAmqpChannel& channel);
+
+ void notifyChannelClosedByServer(const uint16 channelNumber);
+
+ void channelCloseChannel(Channel *channel);
+
+private:
+ void initConnection();
+
+ static void closeChannel(
+ const bool isRunning,
+ const SmartPtrAMQChannelManager channelManager,
+ const SmartPtrChannel& channel);
+
+ static SmartPtrChannel createChannel(
+ const bool isRunning,
+ const SmartPtrAMQChannelManager& channelManager,
+ const SmartPtrConnectionWeakReference& weakReferenceSelf);
+
+ static void* threadFunc(void* context);
+
+ void threadWorker();
+
+private:
+ bool _isInitialized;
+ volatile bool _isRunning;
+ volatile bool _shouldShutdown;
+ bool _wasCloseCalled;
+ GThread* _thread;
+ CThreadSignal _connectionSignal;
+ SmartPtrAddress _address;
+ SmartPtrCertInfo _certInfo;
+ uint32 _connectionTimeout;
+ SmartPtrCAmqpConnection _connectionHandle;
+ uint32 _requestedFrameMax;
+ uint32 _requestedChannelMax;
+ uint32 _requestedHeartbeat;
+ uint16 _retries;
+ uint16 _secondsToWait;
+ SmartPtrCAmqpAuthMechanism _authMechanism;
+ SmartPtrAMQChannelManager _channelManager;
+ SmartPtrConnectionWeakReference _weakReferenceSelf;
+ SmartPtrCManagedThreadPool _threadPool;
+ SmartPtrConsumerWorkService _workService;
+
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_CM_CREATE_LOG;
+ CAF_THREADSIGNAL_CREATE;
+ CAF_CM_DECLARE_NOCOPY(AMQConnection);
+};
+
+CAF_DECLARE_SMART_POINTER(AMQConnection);
+
+}}
+
+#endif /* AMQCONNECTION_H_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: 10/19/2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQP_CLIENTLINK_H_
+#define AMQP_CLIENTLINK_H_
+
+#ifndef AMQPCLIENT_LINKAGE
+ #ifdef WIN32
+ #ifdef AMQP_CLIENT
+ #define AMQPCLIENT_LINKAGE __declspec(dllexport)
+ #else
+ #define AMQPCLIENT_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define AMQPCLIENT_LINKAGE
+ #endif
+#endif
+
+#endif /* AMQP_CLIENTLINK_H_ */
--- /dev/null
+/*
+ * Created on: May 15, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef BLOCKINGRPCCONTINUATION_H_
+#define BLOCKINGRPCCONTINUATION_H_
+
+
+
+#include "amqpClient/IRpcContinuation.h"
+
+#include "Exception/CCafException.h"
+#include "amqpClient/AMQCommand.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @brief A IRpcContinuation that blocks until the response is received.
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ */
+class BlockingRpcContinuation : public IRpcContinuation {
+public:
+ BlockingRpcContinuation();
+ virtual ~BlockingRpcContinuation();
+
+ /**
+ * @brief Initialize the object
+ */
+ void init();
+
+ /**
+ * @brief Waits indefinately for a response to an AMQP method call
+ * @retval null if an error occured. In this case call getException to get the exception
+ * @retval non-null AMQCommand response
+ */
+ SmartPtrAMQCommand getReply();
+
+ /**
+ * @brief Waits for a time for a response to an AMQP method call
+ * @param timeout time in milliseconds to wait for a response
+ * @retval null if an error occured. In this case call getException to get the exception
+ * @retval non-null AMQCommand response
+ */
+ SmartPtrAMQCommand getReply(uint32 timeout);
+
+ /**
+ * @brief Returns the exception that occured if getReply returns <code><i>null</i></code>.
+ * @return the exception. The returned exception will have its reference count increased.
+ */
+ SmartPtrCCafException getException();
+
+public: // IRpcContinuation
+ void handleCommand(const SmartPtrAMQCommand& command);
+
+ void handleAbort(SmartPtrCCafException exception);
+
+private:
+ bool _isInitialized;
+ TBlockingCell<SmartPtrAMQCommand> _blocker;
+ SmartPtrCCafException _exception;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(BlockingRpcContinuation);
+};
+CAF_DECLARE_SMART_POINTER(BlockingRpcContinuation);
+
+}}
+
+#endif /* BLOCKINGRPCCONTINUATION_H_ */
--- /dev/null
+/*
+ * Created on: May 7, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENT_CAMQPAUTHMECHANISM_H_
+#define AMQPCLIENT_CAMQPAUTHMECHANISM_H_
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Manages a set of channels for a connection.
+ * Channels are indexed by channel number (<code><b>1.._channelMax</b></code>).
+ */
+class CAmqpAuthMechanism {
+public:
+ CAmqpAuthMechanism();
+ virtual ~CAmqpAuthMechanism();
+
+public:
+ AMQPStatus createClient(
+ const std::string& username,
+ const std::string& password);
+
+ std::string getUsername() const;
+ std::string getPassword() const;
+
+private:
+ std::string _username;
+ std::string _password;
+
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_CM_DECLARE_NOCOPY(CAmqpAuthMechanism);
+};
+CAF_DECLARE_SMART_POINTER(CAmqpAuthMechanism);
+
+}}
+
+#endif /* AMQPCLIENT_CAMQPAUTHMECHANISM_H_ */
--- /dev/null
+/*
+ * Created on: May 7, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENT_CAMQPCHANNEL_H_
+#define AMQPCLIENT_CAMQPCHANNEL_H_
+
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/CAmqpConnection.h"
+#include "amqpClient/CAmqpFrame.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Manages a set of channels for a connection.
+ * Channels are indexed by channel number (<code><b>1.._channelMax</b></code>).
+ */
+class CAmqpChannel {
+public:
+ CAmqpChannel();
+ virtual ~CAmqpChannel();
+
+ void initialize(
+ const SmartPtrCAmqpConnection& connection,
+ const amqp_channel_t& channel);
+
+public:
+ AMQPStatus close();
+
+ AMQPStatus closeOk();
+
+ AMQPStatus receive(
+ SmartPtrCAmqpFrame& frame,
+ int32 timeout);
+
+ AMQPStatus getId(
+ uint16 *id);
+
+ AMQPStatus basicAck(
+ const uint64 deliveryTag,
+ const bool multiple);
+
+ AMQPStatus basicCancel(
+ const std::string& consumerTag,
+ const bool noWait);
+
+ AMQPStatus basicConsume(
+ const std::string& queue,
+ const std::string& consumerTag,
+ const bool noLocal,
+ const bool noAck,
+ const bool exclusive,
+ const bool noWait,
+ const amqp_table_t *arguments);
+
+ AMQPStatus basicGet(
+ const std::string& queue,
+ const bool noAck);
+
+ AMQPStatus basicPublish(
+ const std::string& exchange,
+ const std::string& routingKey,
+ const bool mandatory,
+ const bool immediate,
+ const amqp_basic_properties_t *basicProps,
+ const SmartPtrCDynamicByteArray& body);
+
+ AMQPStatus basicRecover(
+ const bool requeue);
+
+ AMQPStatus basicQos(
+ const uint32 prefetchSize,
+ const uint16 prefetchCount,
+ bool global);
+
+ AMQPStatus exchangeDeclare(
+ const std::string& exchange,
+ const std::string& type,
+ const bool passive,
+ const bool durable,
+ const bool noWait,
+ const amqp_table_t *arguments);
+
+ AMQPStatus exchangeDelete(
+ const std::string& exchange,
+ const bool ifUnused,
+ const bool noWait);
+
+ AMQPStatus queueBind(
+ const std::string& queue,
+ const std::string& exchange,
+ const std::string& routingKey,
+ const bool noWait,
+ const amqp_table_t *arguments);
+
+ AMQPStatus queueDeclare(
+ const std::string& queue,
+ const bool passive,
+ const bool durable,
+ const bool exclusive,
+ const bool autoDelete,
+ const bool noWait,
+ const amqp_table_t *arguments);
+
+ AMQPStatus queueDelete(
+ const std::string& queue,
+ const bool ifUnused,
+ const bool ifEmpty,
+ const bool noWait);
+
+ AMQPStatus queuePurge(
+ const std::string& queue,
+ const bool noWait);
+
+ AMQPStatus queueUnbind(
+ const std::string& queue,
+ const std::string& exchange,
+ const std::string& bindingKey,
+ const amqp_table_t *arguments);
+
+private:
+ bool _isInitialized;
+ SmartPtrCAmqpConnection _connection;
+ amqp_channel_t _channel;
+
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_CM_DECLARE_NOCOPY(CAmqpChannel);
+};
+
+}}
+
+#endif /* AMQPCLIENT_CAMQPCHANNEL_H_ */
--- /dev/null
+/*
+ * Created on: May 7, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENT_CAMQPCONNECTION_H_
+#define AMQPCLIENT_CAMQPCONNECTION_H_
+
+
+#include "amqpClient/CAmqpChannel.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/CAmqpAuthMechanism.h"
+#include "amqpClient/CAmqpFrame.h"
+#include "amqpClient/api/Address.h"
+#include "amqpClient/api/CertInfo.h"
+
+namespace Caf { namespace AmqpClient {
+
+/** Connection states. */
+typedef enum {
+ AMQP_STATE_INITIALIZED = 0, /*!< New connection. */
+ AMQP_STATE_CONNECTING, /*!< Connection in progress. */
+ AMQP_STATE_CONNECTED, /*!< Connected. */
+ AMQP_STATE_DISCONNECTING, /*!< Disconnection in process. */
+ AMQP_STATE_DISCONNECTED, /*!< Disconnected. */
+} AMQPConnectionState;
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Manages a set of channels for a connection.
+ * Channels are indexed by channel number (<code><b>1.._channelMax</b></code>).
+ */
+class CAmqpConnection {
+private:
+ typedef std::deque<SmartPtrCAmqpFrame> CAmqpFrames;
+ typedef std::map<amqp_channel_t, CAmqpFrames> CChannelFrames;
+ CAF_DECLARE_SMART_POINTER(CChannelFrames);
+
+ typedef std::set<amqp_channel_t> COpenChannels;
+ CAF_DECLARE_SMART_POINTER(COpenChannels);
+
+public:
+ CAmqpConnection();
+ virtual ~CAmqpConnection();
+
+public:
+ AMQPStatus connectionCreate(
+ const SmartPtrAddress& address,
+ const SmartPtrCAmqpAuthMechanism& auth,
+ const SmartPtrCertInfo& certInfo,
+ const uint16 channelMax,
+ const uint32 frameMax,
+ const uint16 heartbeat,
+ const uint16 retries,
+ const uint16 secondsToWait);
+
+ AMQPStatus connectionConnect(
+ const int32 flags);
+
+ AMQPStatus connectionClose();
+
+ AMQPStatus connectionProcessIO();
+
+ AMQPStatus connectionWaitForIO(
+ const int32 timeout);
+
+ AMQPStatus connectionGetState(
+ AMQPConnectionState *state);
+
+ AMQPStatus connectionGetMaxChannels(
+ uint16 *channels);
+
+ AMQPStatus connectionGetMaxFrameSize(
+ uint32 *frameSize);
+
+ AMQPStatus connectionGetHeartbeatInterval(
+ uint16 *interval);
+
+ AMQPStatus connectionGetLastError(
+ const char **error);
+
+ AMQPStatus channelOpen(
+ SmartPtrCAmqpChannel& chan);
+
+ AMQPStatus channelClose(
+ const amqp_channel_t& channel);
+
+ AMQPStatus channelCloseOk(
+ const amqp_channel_t& channel);
+
+ AMQPStatus receive(
+ const amqp_channel_t& channel,
+ SmartPtrCAmqpFrame& frame,
+ const int32 timeout);
+
+ AMQPStatus basicAck(
+ const amqp_channel_t& channel,
+ const uint64 deliveryTag,
+ const bool multiple);
+
+ AMQPStatus basicCancel(
+ const amqp_channel_t& channel,
+ const std::string& consumerTag,
+ const bool noWait);
+
+ AMQPStatus basicConsume(
+ const amqp_channel_t& channel,
+ const std::string& queue,
+ const std::string& consumerTag,
+ const bool noLocal,
+ const bool noAck,
+ const bool exclusive,
+ const bool noWait,
+ const amqp_table_t *arguments);
+
+ AMQPStatus basicGet(
+ const amqp_channel_t& channel,
+ const std::string& queue,
+ const bool noAck);
+
+ AMQPStatus basicPublish(
+ const amqp_channel_t& channel,
+ const std::string& exchange,
+ const std::string& routingKey,
+ const bool mandatory,
+ const bool immediate,
+ const amqp_basic_properties_t *basicProps,
+ const SmartPtrCDynamicByteArray& body);
+
+ AMQPStatus basicRecover(
+ const amqp_channel_t& channel,
+ const bool requeue);
+
+ AMQPStatus basicQos(
+ const amqp_channel_t& channel,
+ const uint32 prefetchSize,
+ const uint16 prefetchCount,
+ const bool global);
+
+ AMQPStatus exchangeDeclare(
+ const amqp_channel_t& channel,
+ const std::string& exchange,
+ const std::string& type,
+ const bool passive,
+ const bool durable,
+ const bool noWait,
+ const amqp_table_t *arguments);
+
+ AMQPStatus exchangeDelete(
+ const amqp_channel_t& channel,
+ const std::string& exchange,
+ const bool ifUnused,
+ const bool noWait);
+
+ AMQPStatus queueBind(
+ const amqp_channel_t& channel,
+ const std::string& queue,
+ const std::string& exchange,
+ const std::string& routingKey,
+ const bool noWait,
+ const amqp_table_t *arguments);
+
+ AMQPStatus queueDeclare(
+ const amqp_channel_t& channel,
+ const std::string& queue,
+ const bool passive,
+ const bool durable,
+ const bool exclusive,
+ const bool autoDelete,
+ const bool noWait,
+ const amqp_table_t *arguments);
+
+ AMQPStatus queueDelete(
+ const amqp_channel_t& channel,
+ const std::string& queue,
+ const bool ifUnused,
+ const bool ifEmpty,
+ const bool noWait);
+
+ AMQPStatus queuePurge(
+ const amqp_channel_t& channel,
+ const std::string& queue,
+ const bool noWait);
+
+ AMQPStatus queueUnbind(
+ const amqp_channel_t& channel,
+ const std::string& queue,
+ const std::string& exchange,
+ const std::string& routingKey,
+ const amqp_table_t *arguments);
+
+private:
+ AMQPStatus createConnection();
+ AMQPStatus createSslConnection();
+
+ AMQPStatus connectConnection();
+
+ AMQPStatus closeConnection();
+
+ AMQPStatus closeChannel(
+ const amqp_channel_t& channel);
+
+ int32 receiveFrame(
+ const amqp_connection_state_t& connectionState,
+ SmartPtrCAmqpFrame& frame) const;
+
+ void addFrames(
+ const CAmqpFrames& frames,
+ const SmartPtrCChannelFrames& channelFrames) const;
+
+ bool isDataAvail(
+ const amqp_connection_state_t& connectionState) const;
+
+ void validateOpenChannel(
+ const amqp_channel_t& channel) const;
+
+ void restartListener(
+ const std::string& reason) const;
+
+private:
+ amqp_connection_state_t _connectionState;
+ amqp_socket_t* _socket;
+ amqp_channel_t _curChannel;
+ AMQPConnectionState _connectionStateEnum;
+ bool _isConnectionLost;
+ int32 _lastStatus;
+
+ SmartPtrCAmqpAuthMechanism _auth;
+ uint16 _channelMax;
+ uint32 _frameMax;
+ uint16 _heartbeat;
+ uint16 _retries;
+ uint16 _secondsToWait;
+ SmartPtrAddress _address;
+ SmartPtrCertInfo _certInfo;
+ SmartPtrCChannelFrames _channelFrames;
+
+ Csetstr _cachedStrings;
+ COpenChannels _openChannels;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CAmqpConnection);
+};
+
+}}
+
+#endif /* AMQPCLIENT_CAMQPCONNECTION_H_ */
--- /dev/null
+/*
+ * Created on: May 7, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENT_CAMQPFRAME_H_
+#define AMQPCLIENT_CAMQPFRAME_H_
+
+#include "amqp.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Manages a set of channels for a connection.
+ * Channels are indexed by channel number (<code><b>1.._channelMax</b></code>).
+ */
+class CAmqpFrame {
+public:
+ CAmqpFrame();
+ virtual ~CAmqpFrame();
+
+public:
+ void initialize(
+ const amqp_frame_t& frame);
+
+ uint8_t getFrameType() const;
+ amqp_channel_t getChannel() const;
+
+ const amqp_method_t* const getPayloadAsMethod() const;
+
+ uint16_t getHeaderClassId() const;
+ uint64_t getHeaderBodySize() const;
+ const amqp_basic_properties_t* const getHeaderProperties() const;
+
+ const amqp_bytes_t* const getBodyFragment() const;
+
+ void log(const std::string& prefix) const;
+
+private:
+ bool _isInitialized;
+
+ uint8_t _frameType;
+ amqp_channel_t _channel;
+
+ amqp_method_t _method;
+
+ uint16_t _propertiesClassId;
+ uint64_t _propertiesBodySize;
+ amqp_basic_properties_t* _propertiesDecoded;
+
+ amqp_bytes_t _bodyFragment;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CAmqpFrame);
+};
+CAF_DECLARE_SMART_POINTER(CAmqpFrame);
+
+}}
+
+#endif /* AMQPCLIENT_CAMQPFRAME_H_ */
--- /dev/null
+/*
+ * Created on: May 9, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef COMMANDASSEMBLER_H_
+#define COMMANDASSEMBLER_H_
+
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/CAmqpFrame.h"
+#include "amqpClient/amqpImpl/IContentHeader.h"
+#include "amqpClient/amqpImpl/IMethod.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief A class that manages the assembly of AMQP frames into a complete AMQP method
+ */
+class CommandAssembler {
+public:
+ CommandAssembler();
+ virtual ~CommandAssembler();
+
+ /**
+ * @brief Initialize the object
+ */
+ void init();
+
+ /**
+ * @brief Process the AMQP frame
+ * @param frame AMQP frame
+ * @retval true all of the frames have been received and the AMQP method is complete
+ * @retval false more frames are required to complete the AMQP method
+ */
+ bool handleFrame(const SmartPtrCAmqpFrame& frame);
+
+ /**
+ * @brief Return the completion status of the method
+ * @retval true all frames have been received and the AMQP method is complete
+ * @retval false more frames are required to complete the AMQP method
+ */
+ bool isComplete();
+
+ /**
+ * @brief Return the Method
+ * @return the interface to the Method. QueryInterface to the appropriate
+ * derived type based on the class ID and method ID.
+ */
+ SmartPtrIMethod getMethod();
+
+ /**
+ * @brief Return the ContentHeader
+ * @return the interface to the ContentHeader. QueryInterface to the appropriate
+ * derived type based on the class ID.
+ */
+ SmartPtrIContentHeader getContentHeader();
+
+ /**
+ * @brief Return the method body
+ * @return the method body data as raw bytes
+ */
+ SmartPtrCDynamicByteArray getContentBody();
+
+private:
+ typedef enum {
+ EXPECTING_METHOD,
+ EXPECTING_CONTENT_HEADER,
+ EXPECTING_CONTENT_BODY,
+ COMPLETE
+ } CAState;
+
+ typedef std::deque<SmartPtrCDynamicByteArray> CBodyCollection;
+
+private:
+ void consumeBodyFrame(const SmartPtrCAmqpFrame& frame);
+ void consumeHeaderFrame(const SmartPtrCAmqpFrame& frame);
+ void consumeMethodFrame(const SmartPtrCAmqpFrame& frame);
+ void updateContentBodyState();
+ void appendBodyFragment(const amqp_bytes_t * const fragment);
+ SmartPtrCDynamicByteArray coalesceContentBody();
+
+private:
+ bool _isInitialized;
+ CAState _state;
+ SmartPtrIMethod _method;
+ SmartPtrIContentHeader _contentHeader;
+ uint32 _remainingBodyBytes;
+ CBodyCollection _bodyCollection;
+ uint32 _bodyLength;
+
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CommandAssembler);
+};
+CAF_DECLARE_SMART_POINTER(CommandAssembler);
+
+}}
+#endif /* COMMANDASSEMBLER_H_ */
--- /dev/null
+/*
+ * Created on: May 2, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CONNECTIONFACTORYIMPL_H_
+#define CONNECTIONFACTORYIMPL_H_
+
+#include "amqpClient/api/ConnectionFactory.h"
+#include "amqpClient/api/Address.h"
+#include "amqpClient/api/CertInfo.h"
+#include "amqpClient/api/Connection.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of ConnectionFactory
+ */
+class ConnectionFactoryImpl : public ConnectionFactory {
+public:
+ ConnectionFactoryImpl();
+ virtual ~ConnectionFactoryImpl();
+
+public: // ConectionFactory
+ std::string getProtocol() const;
+ void setProtocol(const std::string& host);
+ std::string getHost() const;
+ void setHost(const std::string& host);
+ uint32 getPort() const;
+ void setPort(const uint32 port);
+ std::string getVirtualHost() const;
+ void setVirtualHost(const std::string& virtualHost);
+ std::string getUsername() const;
+ void setUsername(const std::string& username);
+ std::string getPassword() const;
+ void setPassword(const std::string& password);
+ std::string getCaCertPath() const;
+ void setCaCertPath(const std::string& caCertPath);
+ std::string getClientCertPath() const;
+ void setClientCertPath(const std::string& clientCertPath);
+ std::string getClientKeyPath() const;
+ void setClientKeyPath(const std::string& clientKeyPath);
+ uint32 getRequestedChannelMax() const;
+ void setRequestedChannelMax(const uint32 requestedChannelMax);
+ uint32 getRequestedFrameMax() const;
+ void setRequestedFrameMax(const uint32 requestedFrameMax);
+ uint32 getRequestedHeartbeat() const;
+ void setRequestedHeartbeat(const uint32 requestedHeartbeat);
+ uint32 getConnectionTimeout() const;
+ void setConnectionTimeout(const uint32 connectionTimeout);
+ uint32 getConsumerThreadCount() const;
+ void setConsumerThreadCount(const uint32 threadCount);
+ uint16 getRetries() const;
+ void setRetries(const uint16 retries);
+ uint16 getSecondsToWait() const;
+ void setSecondsToWait(const uint16 seconds);
+
+ SmartPtrConnection newConnection();
+ SmartPtrConnection newConnection(
+ const SmartPtrAddress& address,
+ const SmartPtrCertInfo& certInfo);
+
+private:
+ uint32 portOrDefault(const uint32 port) const;
+
+private:
+ std::string _protocol;
+ std::string _host;
+ uint32 _port;
+ std::string _virtualHost;
+ std::string _username;
+ std::string _password;
+ std::string _caCertPath;
+ std::string _clientCertPath;
+ std::string _clientKeyPath;
+ uint32 _requestedChannelMax;
+ uint32 _requestedFrameMax;
+ uint32 _requestedHeartbeat;
+ uint32 _connectionTimeout;
+ uint32 _consumerThreadCount;
+ uint16 _retries;
+ uint16 _secondsToWait;
+
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(ConnectionFactoryImpl);
+};
+CAF_DECLARE_SMART_POINTER(ConnectionFactoryImpl);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: May 7, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CONNECTIONWEAKREFERENCE_H_
+#define CONNECTIONWEAKREFERENCE_H_
+
+
+#include "amqpClient/IConnectionInt.h"
+#include "amqpClient/CAmqpChannel.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief This class manages a weak reference to a IConnectionInt object.
+ * <p>
+ * The channel manager needs a reference to its connection. The connection object
+ * has a reference to the channel manager. To break this reference cycle the channel
+ * manager will be handed weak references to the connection.
+ */
+class ConnectionWeakReference : public IConnectionInt {
+public:
+ ConnectionWeakReference();
+ virtual ~ConnectionWeakReference();
+
+public:
+ /**
+ * @brief Sets the weakly referenced object
+ * @param connection the weakly referenced object
+ */
+ void setReference(IConnectionInt* connection);
+
+ /**
+ * @brief Clears the weakly referenced object.
+ *
+ * Calls to any Connection method on this object will result in a thrown
+ * exception after this method has been called.
+ */
+ void clearReference();
+
+public: // IConnectionInt
+ AMQPStatus amqpConnectionOpenChannel(SmartPtrCAmqpChannel& channel);
+
+ void notifyChannelClosedByServer(const uint16 channelNumber);
+
+ void channelCloseChannel(Channel *channel);
+
+private:
+ IConnectionInt* _connection;
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_CM_DECLARE_NOCOPY(ConnectionWeakReference);
+};
+CAF_DECLARE_SMART_POINTER(ConnectionWeakReference);
+
+}}
+
+#endif /* CONNECTIONWEAKREFERENCE_H_ */
--- /dev/null
+/*
+ * Created on: May 21, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CONSUMERDISPATCHER_H_
+#define CONSUMERDISPATCHER_H_
+
+
+
+#include "ICafObject.h"
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Exception/CCafException.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/ConsumerWorkService.h"
+#include "amqpClient/api/Consumer.h"
+#include "amqpClient/api/Envelope.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Dispatches notifications to a {@link Consumer} on an internally-managed work pool.
+ * <p>
+ * Each {@link Channel} has a single {@link ConsumerDispatcher}, but the work pool may be
+ * shared with other channels, typically those on the name {@link AMQConnection}.
+ */
+class ConsumerDispatcher {
+public:
+ ConsumerDispatcher();
+ virtual ~ConsumerDispatcher();
+
+ /**
+ * @brief Initialize the object
+ * @param workService work service providing a work pool for dispatching notifications
+ */
+ void init(
+ const SmartPtrConsumerWorkService& workService);
+
+ /**
+ * @brief Prepare for shutdown of all consumers on this channel
+ */
+ void quiesce();
+
+ /**
+ * @brief Lock the dispatcher
+ * <p>
+ * Place a lock on the dispatcher. All threads attemping to call the dispatcher will
+ * be blocked until unlock is called.
+ */
+ void lock();
+
+ /**
+ * @brief unlock the dispatcher
+ * <p>
+ * Remove the lock on the dispatcher.
+ */
+ void unlock();
+
+ /**
+ * @brief Adds a consumer to the dispatcher
+ * @param consumerTag consumer tag
+ * @param consumer consumer object
+ */
+ void addConsumer(
+ const std::string& consumerTag,
+ const SmartPtrConsumer& consumer);
+
+ /**
+ * @brief Removes a consumer from the dispatcher
+ * @param consumerTag consumer tag
+ */
+ void removeConsumer(
+ const std::string& consumerTag);
+
+ /**
+ * @brief Retrieves a consumer from the dispatcher
+ * @param consumerTag consumer tag
+ * @return the consumer or <i>null</i> if not found
+ */
+ SmartPtrConsumer getConsumer(
+ const std::string& consumerTag);
+
+ /**
+ * @brief Handle basic.consume-ok
+ * @param consumerTag consumer tag
+ */
+ void handleConsumeOk(
+ const std::string& consumerTag);
+
+ /**
+ * @brief Handle basic.cancel-ok
+ * @param consumerTag consumer tag
+ */
+ void handleCancelOk(
+ const std::string& consumerTag);
+
+ /**
+ * @brief Handle basic.recover-ok
+ */
+ void handleRecoverOk();
+
+ /**
+ * @brief Handle basic.delivery
+ * @param consumerTag consumer tag
+ * @param envelope message envelope
+ * @param properties message properties and headers
+ * @param body message body
+ */
+ void handleDelivery(
+ const std::string& consumerTag,
+ const SmartPtrEnvelope& envelope,
+ const AmqpContentHeaders::SmartPtrBasicProperties& properties,
+ const SmartPtrCDynamicByteArray& body);
+
+ /**
+ * @brief Handle a channel shutdown event
+ * @param exception reason for the shutdown
+ */
+ void handleShutdown(SmartPtrCCafException exception);
+
+private: // Task support
+ typedef enum {
+ DISPATCH_ITEM_METHOD_HANDLE_CONSUME_OK,
+ DISPATCH_ITEM_METHOD_HANDLE_CANCEL_OK,
+ DISPATCH_ITEM_METHOD_HANDLE_RECOVER_OK,
+ DISPATCH_ITEM_METHOD_HANDLE_DELIVERY,
+ DISPATCH_ITEM_METHOD_TERMINATE
+ } DispatchItemMethod;
+
+ class DispatcherWorkItem : public ICafObject {
+ public:
+ DispatcherWorkItem();
+
+ void init(
+ const DispatchItemMethod method);
+
+ void init(
+ const DispatchItemMethod method,
+ const SmartPtrEnvelope& envelope,
+ const AmqpContentHeaders::SmartPtrBasicProperties& properties,
+ const SmartPtrCDynamicByteArray& body);
+
+ DispatchItemMethod getMethod() const;
+ SmartPtrEnvelope getEnvelope() const;
+ AmqpContentHeaders::SmartPtrBasicProperties getProperties() const;
+ SmartPtrCDynamicByteArray getBody() const;
+
+ private:
+ DispatchItemMethod _method;
+ SmartPtrEnvelope _envelope;
+ AmqpContentHeaders::SmartPtrBasicProperties _properties;
+ SmartPtrCDynamicByteArray _body;
+ };
+ CAF_DECLARE_SMART_POINTER(DispatcherWorkItem);
+
+ class DispatcherTask : public CManagedThreadPool::IThreadTask {
+ public:
+ DispatcherTask();
+ ~DispatcherTask();
+
+ void init(
+ const std::string& consumerTag,
+ const SmartPtrConsumer& consumer);
+
+ void term();
+
+ void addWorkItem(const SmartPtrDispatcherWorkItem& workItem);
+
+ bool run();
+
+ private:
+ static void FreeWorkItem(gpointer data);
+
+ private:
+ std::string _consumerTag;
+ SmartPtrConsumer _consumer;
+ GAsyncQueue *_workItemQueue;
+ };
+ CAF_DECLARE_SMART_POINTER(DispatcherTask);
+
+private:
+ typedef std::pair<SmartPtrConsumer, SmartPtrDispatcherTask> ConsumerItem;
+ typedef std::map<std::string, ConsumerItem> ConsumerMap;
+
+ ConsumerItem getConsumerItem(const std::string& consumerTag);
+
+private:
+ bool _isInitialized;
+ volatile bool _isShuttingDown;
+ SmartPtrConsumerWorkService _workService;
+ ConsumerMap _consumers;
+
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_CM_DECLARE_NOCOPY(ConsumerDispatcher);
+};
+CAF_DECLARE_SMART_POINTER(ConsumerDispatcher);
+
+}}
+
+#endif /* CONSUMERDISPATCHER_H_ */
--- /dev/null
+/*
+ * Created on: May 9, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CONSUMERWORKSERVICE_H_
+#define CONSUMERWORKSERVICE_H_
+
+
+#include "Common/CManagedThreadPool.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief This class wraps a thread pool for executing channel worker threads
+ */
+class ConsumerWorkService {
+public:
+ ConsumerWorkService();
+ virtual ~ConsumerWorkService();
+
+ /**
+ * @brief Initializer
+ * @param threadPool the thread pool used to execute channel threads
+ */
+ void init(const SmartPtrCManagedThreadPool& threadPool);
+
+ /**
+ * @brief Add a worker thread to the pool
+ * @param task the task to add
+ */
+ void addWork(const CManagedThreadPool::SmartPtrIThreadTask& task);
+
+ /**
+ * @brief Respond to a connection-closed notification by terminating the thread pool
+ */
+ void notifyConnectionClosed();
+
+private:
+ bool _isInitialized;
+ SmartPtrCManagedThreadPool _threadPool;
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(ConsumerWorkService);
+};
+CAF_DECLARE_SMART_POINTER(ConsumerWorkService);
+
+}}
+
+#endif /* CONSUMERWORKSERVICE_H_ */
--- /dev/null
+/*
+ * Created on: May 8, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef ICONNECTIONINT_H_
+#define ICONNECTIONINT_H_
+
+#include "ICafObject.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/api/Channel.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief This interface abstracts the calls to AMQP_ConnectionXXX c-api calls
+ * <p>
+ * AMQConnection objects pass weak references to themselves to AMQChannel objects
+ * allowing them to make calls against the channel that require the connection handle.
+ */
+struct __declspec(novtable) IConnectionInt : public ICafObject {
+
+ /**
+ * @brief Pass-through for the AMQP_ConnectionOpenChannel call
+ * @param channel the channel handle to be returned
+ * @return the AMQPStatus of the call. If AMQP_ERROR_OK then
+ * <code><b>channel</b></code> will be set to a valid channel handle.
+ */
+ virtual AMQPStatus amqpConnectionOpenChannel(SmartPtrCAmqpChannel& channel) = 0;
+
+ /**
+ * @brief Callback to notify the connection that a channel has been closed. This
+ * is in reponse to the server sending a channel.close method.
+ * @param channelNumber the channel number
+ */
+ virtual void notifyChannelClosedByServer(const uint16 channelNumber) = 0;
+
+ /**
+ * @brief Callback to notify the connection that a channel is being
+ * requested to close.
+ * @param channel Channel to close
+ */
+ virtual void channelCloseChannel(Channel *channel) = 0;
+
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(IConnectionInt);
+
+}}
+
+#endif /* ICONNECTIONINT_H_ */
--- /dev/null
+/*
+ * Created on: May 15, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef IRPCCONTINUATION_H_
+#define IRPCCONTINUATION_H_
+
+
+#include "ICafObject.h"
+
+#include "Exception/CCafException.h"
+#include "amqpClient/AMQCommand.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Interface for RPC worker objects
+ * <p>
+ * The channel worker thread will assemble incoming AMQP frames an then process
+ * the compiled frames as an AMQCommand object. If the command object belongs
+ * to an outstanding RPC call, that call will receive the command for processing.
+ */
+struct __declspec(novtable) IRpcContinuation : public ICafObject {
+ /**
+ * @brief Process the received AMQP command
+ * @param command the AMQCommand command object
+ */
+ virtual void handleCommand(const SmartPtrAMQCommand& command) = 0;
+
+ /**
+ * @brief Abort the command for the reason supplied
+ * @param exception the reason as an exception
+ */
+ virtual void handleAbort(SmartPtrCCafException exception) = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(IRpcContinuation);
+
+}}
+
+
+#endif /* IRPCCONTINUATION_H_ */
--- /dev/null
+/*
+ * Created on: May 21, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef TCOPYONWRITECONTAINER_H_
+#define TCOPYONWRITECONTAINER_H_
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief An STL container wrapper that implements copy-on-write semantics
+ */
+template <typename Container, typename ValueType = typename Container::value_type>
+class TCopyOnWriteContainer {
+public:
+ typedef TCafSmartPtr<Container, TCafObject<Container> > SmartPtrContainer;
+
+ TCopyOnWriteContainer() {
+ _container.CreateInstance();
+ }
+
+ SmartPtrContainer getAll() {
+ return _container;
+ }
+
+ void add(const ValueType& value) {
+ SmartPtrContainer newContainer;
+ newContainer.CreateInstance();
+ newContainer->insert(
+ newContainer->begin(),
+ _container->begin(),
+ _container->end());
+ newContainer->push_back(value);
+ _container = newContainer;
+ }
+
+ bool remove(const ValueType& value) {
+ bool found = false;
+ SmartPtrContainer newContainer;
+ newContainer.CreateInstance();
+ SmartPtrContainer currContainer = _container;
+ for (typename Container::const_iterator iter = currContainer->begin();
+ iter != currContainer->end();
+ ++iter) {
+ if (*iter == value) {
+ found = true;
+ } else {
+ newContainer->push_back(*iter);
+ }
+ }
+
+ if (found) {
+ _container = newContainer;
+ }
+ return found;
+ }
+
+ void clear() {
+ _container.CreateInstance();
+ }
+
+private:
+ SmartPtrContainer _container;
+};
+
+}}
+
+#endif /* TCOPYONWRITECONTAINER_H_ */
--- /dev/null
+/*
+ * Created on: May 16, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef BASICACKMETHOD_H_
+#define BASICACKMETHOD_H_
+
+#include "amqpClient/amqpImpl/IServerMethod.h"
+#include "amqpClient/CAmqpChannel.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of AMQP basic.ack
+ */
+class BasicAckMethod :public IServerMethod {
+public:
+ BasicAckMethod();
+ virtual ~BasicAckMethod();
+
+ /**
+ * @brief Initialize the method
+ * @param deliveryTag delivery tag
+ * @param ackMultiple acknowledge multiple flag
+ */
+ void init(
+ const uint64 deliveryTag,
+ const bool ackMultiple);
+
+public: // IServerMethod
+ std::string getMethodName() const;
+
+ AMQPStatus send(const SmartPtrCAmqpChannel& channel);
+
+private:
+ bool _isInitialized;
+ uint64 _deliveryTag;
+ bool _ackMultiple;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(BasicAckMethod);
+};
+CAF_DECLARE_SMART_POINTER(BasicAckMethod);
+
+}}
+
+#endif /* BASICACKMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 21, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef BASICCANCELMETHOD_H_
+#define BASICCANCELMETHOD_H_
+
+#include "amqpClient/amqpImpl/IServerMethod.h"
+#include "amqpClient/CAmqpChannel.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of AMQP basic.cancel
+ */
+class BasicCancelMethod : public IServerMethod {
+public:
+ BasicCancelMethod();
+ virtual ~BasicCancelMethod();
+
+ /**
+ * @brief Initialize the method
+ * @param consumerTag the <i>consumer tag</i> associated with the consumer
+ */
+ void init(
+ const std::string& consumerTag);
+
+public: // IServerMethod
+ std::string getMethodName() const;
+
+ AMQPStatus send(const SmartPtrCAmqpChannel& channel);
+
+private:
+ bool _isInitialized;
+ std::string _consumerTag;
+
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(BasicCancelMethod);
+};
+CAF_DECLARE_SMART_POINTER(BasicCancelMethod);
+
+}}
+
+#endif /* BASICCANCELMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 21, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef BASICCONSUMEMETHOD_H_
+#define BASICCONSUMEMETHOD_H_
+
+#include "amqpClient/amqpImpl/IServerMethod.h"
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/api/amqpClient.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of AMQP basic.consume
+ */
+class BasicConsumeMethod : public IServerMethod {
+public:
+ BasicConsumeMethod();
+ virtual ~BasicConsumeMethod();
+
+ /**
+ * @brief Initialize the method
+ * @param queue queue name
+ * @param consumerTag consumer tag (or blank for server-generated tag)
+ * @param noLocal do not send messages to the connection that published them
+ * @param noAck no acknowledgement needed
+ * @param exclusive request exclusive consumer access to the queue
+ * @param arguments additional call arguments
+ */
+ void init(
+ const std::string& queue,
+ const std::string& consumerTag,
+ const bool noLocal,
+ const bool noAck,
+ const bool exclusive,
+ const SmartPtrTable& arguments);
+
+public: // IServerMethod
+ std::string getMethodName() const;
+
+ AMQPStatus send(const SmartPtrCAmqpChannel& channel);
+
+private:
+ bool _isInitialized;
+ std::string _queue;
+ std::string _consumerTag;
+ bool _noLocal;
+ bool _noAck;
+ bool _exclusive;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(BasicConsumeMethod);
+};
+CAF_DECLARE_SMART_POINTER(BasicConsumeMethod);
+
+}}
+
+#endif /* BASICCONSUMEMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 16, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef BASICGETMETHOD_H_
+#define BASICGETMETHOD_H_
+
+#include "amqpClient/amqpImpl/IServerMethod.h"
+#include "amqpClient/CAmqpChannel.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of AMQP basic.get
+ */
+class BasicGetMethod : public IServerMethod {
+public:
+ BasicGetMethod();
+ virtual ~BasicGetMethod();
+
+ /**
+ * @brief Initialize the method
+ * @param queue queue name
+ * @param noAck no acknowledgement (manual acknowledgement) fag
+ */
+ void init(
+ const std::string& queue,
+ const bool noAck);
+
+public: // IServerMethod
+ std::string getMethodName() const;
+
+ AMQPStatus send(const SmartPtrCAmqpChannel& channel);
+
+private:
+ bool _isInitialized;
+ std::string _queue;
+ bool _noAck;
+
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(BasicGetMethod);
+};
+CAF_DECLARE_SMART_POINTER(BasicGetMethod);
+
+}}
+
+#endif /* BASICGETMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 11, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef BASICPROPERTIES_H_
+#define BASICPROPERTIES_H_
+
+#include "amqpClient/api/amqpClient.h"
+#include "amqpClient/amqpImpl/IContentHeader.h"
+#include "amqpClient/CAmqpFrame.h"
+#include "amqpClient/api/AmqpContentHeaders.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of AMQP basic properties
+ */
+class BasicProperties :
+ public AmqpContentHeaders::BasicProperties,
+ public IContentHeader {
+ CAF_DECL_UUID("db3dbcd6-f241-47ff-b17c-d5cf6addabf8")
+
+ CAF_BEGIN_QI()
+ CAF_QI_ENTRY(AmqpContentHeaders::BasicProperties)
+ CAF_QI_ENTRY(IContentHeader)
+ CAF_QI_ENTRY(BasicProperties)
+ CAF_END_QI()
+public:
+ BasicProperties();
+ virtual ~BasicProperties();
+
+ /**
+ * @brief Initialize the properties
+ * <p>
+ * This version creates an object with no properties. Call the setXXX methods
+ * to add properties.
+ */
+ void init();
+
+ /**
+ * @brief Initialize the properties
+ * <p>
+ * Set the <code><i>flags</i></code> property to the binary 'or' (<code><b>|</b></code>) of
+ * BASIC_PROPERTY_XXXX_FLAG constants representing the fields present.
+ * <p>
+ * Use <code><b>0</b></code>, <code><b>std::string()</b></code> or
+ * <code><b>SmartPtrTable()</b></code> to skip initialization of fields not included
+ * in the object.
+ */
+ void init(
+ const uint32 flags,
+ const std::string& contentType,
+ const std::string& contentEncoding,
+ const SmartPtrTable& headers,
+ const uint8 deliveryMode,
+ const uint8 priority,
+ const std::string& correlationId,
+ const std::string& replyTo,
+ const std::string& expiration,
+ const std::string& messageId,
+ const uint64 timestamp,
+ const std::string& type,
+ const std::string& userId,
+ const std::string& appId,
+ const std::string& clusterId);
+
+ /**
+ * @brief Converts this class instance into a c-api amqp_basic_properties_t struct.
+ * <p>
+ * The pointers in the c-api struct point at member of this class. This class instance
+ * must be realized as int32 as the return <code><i>properties</i></code> is in use.
+ * @param properties the c-api properties structure to be filled out
+ */
+ void getAsApiProperties(amqp_basic_properties_t& properties);
+
+public: // IContentHeader
+ void init(const SmartPtrCAmqpFrame& frame);
+
+ uint64 getBodySize();
+
+public: // AmqpProperties::BasicProperties,
+ bool areHeadersAvailable();
+ uint32 getFlags();
+ std::string getContentType();
+ void setContentType(const std::string& contentType);
+ std::string getContentEncoding();
+ void setContentEncoding(const std::string& contentEncoding);
+ SmartPtrTable getHeaders();
+ void setHeaders(const SmartPtrTable& headers);
+ uint8 getDeliveryMode();
+ void setDeliveryMode(const uint8 deliveryMode);
+ uint8 getPriority();
+ void setPriority(const uint8 priority);
+ std::string getCorrelationId();
+ void setCorrelationId(const std::string& correlationId);
+ std::string getReplyTo();
+ void setReplyTo(const std::string& replyTo);
+ std::string getExpiration();
+ void setExpiration(const std::string& expiration);
+ std::string getMessageId();
+ void setMessageId(const std::string& messageId);
+ uint64 getTimestamp();
+ void setTimestamp(const uint64 timestamp);
+ std::string getType();
+ void setType(const std::string& type);
+ std::string getUserId();
+ void setUserId(const std::string& userId);
+ std::string getAppId();
+ void setAppId(const std::string& appId);
+ std::string getClusterId();
+ void setClusterId(const std::string& clusterId);
+
+public: // IAmqpContentHeader
+ uint16 getClassId();
+
+ std::string getClassName();
+
+private:
+ void ValidatePropertyIsSet(
+ const uint32 flag,
+ const char* propertyName);
+
+private:
+ bool _isInitialized;
+ uint32 _flags;
+ uint64 _bodySize;
+ std::string _contentType;
+ std::string _contentEncoding;
+ SmartPtrTable _headers;
+ uint8 _deliveryMode;
+ uint8 _priority;
+ std::string _correlationId;
+ std::string _replyTo;
+ std::string _expiration;
+ std::string _messageId;
+ uint64 _timestamp;
+ std::string _type;
+ std::string _userId;
+ std::string _appId;
+ std::string _clusterId;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(BasicProperties);
+};
+CAF_DECLARE_SMART_QI_POINTER(BasicProperties);
+
+}}
+
+#endif /* BASICPROPERTIES_H_ */
--- /dev/null
+/*
+ * Created on: May 15, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef BASICPUBLISHMETHOD_H_
+#define BASICPUBLISHMETHOD_H_
+
+#include "amqpClient/amqpImpl/IServerMethod.h"
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of AMQP basic.publish
+ */
+class BasicPublishMethod : public IServerMethod {
+public:
+ BasicPublishMethod();
+ virtual ~BasicPublishMethod();
+
+ /**
+ * @brief Initialize the method
+ * @param exchange exchange name
+ * @param routingKey routing key
+ * @param mandatory mandatory delivery flag
+ * @param immediate immediate delivery flag
+ * @param properties message properties
+ * @param body message body raw bytes
+ */
+ void init(
+ const std::string& exchange,
+ const std::string& routingKey,
+ bool mandatory,
+ bool immediate,
+ const AmqpContentHeaders::SmartPtrBasicProperties& properties,
+ const SmartPtrCDynamicByteArray& body);
+
+public: // IServerMethod
+ std::string getMethodName() const;
+
+ AMQPStatus send(const SmartPtrCAmqpChannel& channel);
+
+private:
+ bool _isInitialized;
+ std::string _exchange;
+ std::string _routingKey;
+ bool _mandatory;
+ bool _immediate;
+ AmqpContentHeaders::SmartPtrBasicProperties _properties;
+ SmartPtrCDynamicByteArray _body;
+
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(BasicPublishMethod);
+};
+CAF_DECLARE_SMART_POINTER(BasicPublishMethod);
+
+}}
+
+#endif /* BASICPUBLISHMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 22, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef BASICQOSMETHOD_H_
+#define BASICQOSMETHOD_H_
+
+
+#include "amqpClient/amqpImpl/IServerMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+
+namespace Caf { namespace AmqpClient {
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of AMQP basic.qos
+ */
+class BasicQosMethod : public IServerMethod {
+public:
+ BasicQosMethod();
+ virtual ~BasicQosMethod();
+
+ /**
+ * @brief Initialize the method
+ * @param prefetchSize prefetch window in octets
+ * @param prefetchCount prefetch windows in messages
+ * @param global apply to entire connection
+ */
+ void init(
+ const uint32 prefetchSize,
+ const uint16 prefetchCount,
+ const bool global);
+
+public: // IServerMethod
+ std::string getMethodName() const;
+
+ AMQPStatus send(const SmartPtrCAmqpChannel& channel);
+
+private:
+ bool _isInitialized;
+ uint32 _prefetchSize;
+ uint16 _prefetchCount;
+ bool _global;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(BasicQosMethod);
+
+};
+CAF_DECLARE_SMART_POINTER(BasicQosMethod);
+
+}}
+
+#endif /* BASICQOSMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 21, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef BASICRECOVERMETHOD_H_
+#define BASICRECOVERMETHOD_H_
+
+#include "amqpClient/amqpImpl/IServerMethod.h"
+#include "amqpClient/CAmqpChannel.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of AMQP basic.recover
+ */
+class BasicRecoverMethod : public IServerMethod {
+public:
+ BasicRecoverMethod();
+ virtual ~BasicRecoverMethod();
+
+ /**
+ * @brief Initialize the method
+ * @param requeue if <code><b>false</b></code>, the message will be redelivered to the
+ * original receipient. If <code><b>true</b></code>, the server will attempt to requeue
+ * the message, potentially delivering it to an alternative subscriber.
+ */
+ void init(
+ const bool requeue);
+
+public: // IServerMethod
+ std::string getMethodName() const;
+
+ AMQPStatus send(const SmartPtrCAmqpChannel& channel);
+
+private:
+ bool _isInitialized;
+ bool _requeue;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(BasicRecoverMethod);
+
+};
+CAF_DECLARE_SMART_POINTER(BasicRecoverMethod);
+
+}}
+
+#endif /* BASICRECOVERMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: Aug 1, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef BASICREJECTMETHOD_H_
+#define BASICREJECTMETHOD_H_
+
+
+#include "amqpClient/amqpImpl/IServerMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of AMQP basic.Reject
+ */
+class BasicRejectMethod : public IServerMethod {
+public:
+ BasicRejectMethod();
+ virtual ~BasicRejectMethod();
+
+ /**
+ * @brief Initialize the method
+ * @param deliveryTag delivery tag
+ * @param requeue requeue flag
+ */
+ void init(
+ const uint64 deliveryTag,
+ const bool requeue);
+
+public: // IServerMethod
+ std::string getMethodName() const;
+
+ AMQPStatus send(const SmartPtrCAmqpChannel& channel);
+
+private:
+ bool _isInitialized;
+ uint64 _deliveryTag;
+ bool _requeue;
+
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(BasicRejectMethod);
+};
+CAF_DECLARE_SMART_POINTER(BasicRejectMethod);
+
+}}
+
+#endif /* BASICREJECTMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 17, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CHANNELCLOSEOKMETHOD_H_
+#define CHANNELCLOSEOKMETHOD_H_
+
+#include "amqpClient/amqpImpl/IServerMethod.h"
+#include "amqpClient/CAmqpChannel.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementatin of AMQP channel.close-ok
+ */
+class ChannelCloseOkMethod :public IServerMethod {
+public:
+ ChannelCloseOkMethod();
+ virtual ~ChannelCloseOkMethod();
+
+ /**
+ * Initialize the method
+ */
+ void init();
+
+public: // IServerMethod
+ std::string getMethodName() const;
+
+ AMQPStatus send(const SmartPtrCAmqpChannel& channel);
+
+private:
+ bool _isInitialized;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(ChannelCloseOkMethod);
+};
+CAF_DECLARE_SMART_POINTER(ChannelCloseOkMethod);
+
+}}
+
+#endif /* CHANNELCLOSEOKMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 16, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef ENVELOPEIMPL_H_
+#define ENVELOPEIMPL_H_
+
+#include "amqpClient/api/Envelope.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of Envelope
+ */
+class EnvelopeImpl : public Envelope {
+public:
+ EnvelopeImpl();
+ virtual ~EnvelopeImpl();
+
+ /**
+ * @brief Initialize the object
+ * @param deliveryTag delivery tag
+ * @param redelivered redelivered flag
+ * @param exchange exchange name
+ * @param routingKey routing key
+ */
+ void init(
+ const uint64 deliveryTag,
+ const bool redelivered,
+ const std::string& exchange,
+ const std::string& routingKey);
+
+public: // Envelope
+ uint64 getDeliveryTag();
+ bool getRedelivered();
+ std::string getExchange();
+ std::string getRoutingKey();
+
+private:
+ bool _isInitialized;
+ uint64 _deliveryTag;
+ bool _redelivered;
+ std::string _exchange;
+ std::string _routingKey;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(EnvelopeImpl);
+};
+CAF_DECLARE_SMART_POINTER(EnvelopeImpl);
+
+}}
+
+#endif /* ENVELOPEIMPL_H_ */
--- /dev/null
+/*
+ * Created on: May 16, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef EXCHANGEDECLAREMETHOD_H_
+#define EXCHANGEDECLAREMETHOD_H_
+
+#include "amqpClient/amqpImpl/IServerMethod.h"
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/api/amqpClient.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of AMQP exchange.declare
+ */
+class ExchangeDeclareMethod : public IServerMethod {
+public:
+ ExchangeDeclareMethod();
+ virtual ~ExchangeDeclareMethod();
+
+ /**
+ * @brief Initializes the method
+ * @param exchange exchange name
+ * @param type exchange type
+ * @param passive passive mode call
+ * @param durable request a durable exchange
+ * @param arguments declaration arguments
+ */
+ void init(
+ const std::string& exchange,
+ const std::string& type,
+ const bool passive,
+ const bool durable,
+ const SmartPtrTable& arguments);
+
+public: // IServerMethod
+ std::string getMethodName() const;
+
+ AMQPStatus send(const SmartPtrCAmqpChannel& channel);
+
+private:
+ bool _isInitialized;
+ std::string _exchange;
+ std::string _type;
+ bool _passive;
+ bool _durable;
+
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(ExchangeDeclareMethod);
+};
+CAF_DECLARE_SMART_POINTER(ExchangeDeclareMethod);
+
+}}
+#endif /* EXCHANGEDECLAREMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 16, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef EXCHANGEDELETEMETHOD_H_
+#define EXCHANGEDELETEMETHOD_H_
+
+#include "amqpClient/amqpImpl/IServerMethod.h"
+#include "amqpClient/CAmqpChannel.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of AMQP exchange.delete
+ */
+class ExchangeDeleteMethod : public IServerMethod {
+public:
+ ExchangeDeleteMethod();
+ virtual ~ExchangeDeleteMethod();
+
+ /**
+ * @brief Initializes the method
+ * @param exchange exchange name
+ * @param ifUnused delete only if unused flag
+ */
+ void init(
+ const std::string& exchange,
+ const bool ifUnused);
+
+public: // IServerMethod
+ std::string getMethodName() const;
+
+ AMQPStatus send(const SmartPtrCAmqpChannel& channel);
+
+private:
+ bool _isInitialized;
+ std::string _exchange;
+ bool _ifUnused;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(ExchangeDeleteMethod);
+
+};
+CAF_DECLARE_SMART_POINTER(ExchangeDeleteMethod);
+
+}}
+
+#endif /* EXCHANGEDELETEMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 11, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef FIELDIMPL_H_
+#define FIELDIMPL_H_
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of a Field object
+ */
+class FieldImpl : public Field {
+public:
+ FieldImpl();
+ virtual ~FieldImpl();
+
+public: // Field
+ AmqpFieldType getAmqpType() const;
+
+ GVariant* getValue() const;
+
+ void setTypeAndValue(AmqpFieldType type, GVariant *value);
+
+private:
+ AmqpFieldType _type;
+ GVariant *_value;
+ CAF_CM_DECLARE_NOCOPY(FieldImpl);
+};
+CAF_DECLARE_SMART_POINTER(FieldImpl);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: May 16, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef GETRESPONSEIMPL_H_
+#define GETRESPONSEIMPL_H_
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/api/Envelope.h"
+#include "amqpClient/api/GetResponse.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Impelementation of the GetResponse interface
+ * <p>
+ * A class to bundle together the information from a received message. The content is
+ * packaged into an Envelope, BasicProperties and the body for easier consumption as
+ * a single unit.
+ */
+class GetResponseImpl : public GetResponse {
+public:
+ GetResponseImpl();
+ virtual ~GetResponseImpl();
+
+ /**
+ * @brief Object initializer
+ * @param envelope the message envelope
+ * @param properties the messsage properties
+ * @param body the message body in raw bytes
+ * @param messageCount the number of messages remaining in the queue
+ */
+ void init(
+ const SmartPtrEnvelope& envelope,
+ const AmqpContentHeaders::SmartPtrBasicProperties& properties,
+ const SmartPtrCDynamicByteArray& body,
+ const uint32 messageCount);
+
+public: // GetResponse
+ SmartPtrEnvelope getEnvelope();
+ AmqpContentHeaders::SmartPtrBasicProperties getProperties();
+ SmartPtrCDynamicByteArray getBody();
+ uint32 getMessageCount();
+
+private:
+ bool _isInitialized;
+ SmartPtrEnvelope _envelope;
+ AmqpContentHeaders::SmartPtrBasicProperties _properties;
+ SmartPtrCDynamicByteArray _body;
+ uint32 _messageCount;
+
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(GetResponseImpl);
+};
+CAF_DECLARE_SMART_POINTER(GetResponseImpl);
+
+}}
+
+#endif /* GETRESPONSEIMPL_H_ */
--- /dev/null
+/*
+ * Created on: May 11, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef ICONTENTHEADER_H_
+#define ICONTENTHEADER_H_
+
+#include "amqpClient/CAmqpFrame.h"
+#include "amqpClient/api/ContentHeader.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Base interface for AMQP content header implementation objects
+ */
+struct __declspec(novtable) IContentHeader : public ContentHeader {
+ CAF_DECL_UUID("04068590-3083-446E-83AE-DACD90C0F470")
+
+ /**
+ * @brief Initialize the header object from c-api properties data
+ * @param properties the properties data
+ */
+ virtual void init(const SmartPtrCAmqpFrame& frame) = 0;
+
+ /**
+ * @brief Return the expected method body data size
+ * @return the expected body size
+ */
+ virtual uint64 getBodySize() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(IContentHeader);
+
+}}
+
+#endif /* ICONTENTHEADER_H_ */
--- /dev/null
+/*
+ * Created on: May 10, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef IMETHOD_H_
+#define IMETHOD_H_
+
+#include "amqpClient/api/Method.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Base interface for AMQP method implementation objects
+ */
+struct __declspec(novtable) IMethod : public Method {
+ CAF_DECL_UUID("08ba9874-b34c-4afe-bfdc-a12fffaefddb")
+
+ /**
+ * @brief Initialize the object from c-api method data
+ * @param method the method data
+ */
+ virtual void init(const amqp_method_t * const method) = 0;
+
+ /**
+ * @retval true if the method expects a content header
+ * @retval false if the method does not expect a content header
+ */
+ virtual bool hasContent() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(IMethod);
+
+}}
+
+#endif /* IMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 15, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef ISERVERMETHOD_H_
+#define ISERVERMETHOD_H_
+
+
+#include "ICafObject.h"
+
+#include "amqpClient/CAmqpChannel.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Base interface for server methods
+ */
+struct __declspec(novtable) IServerMethod : public ICafObject {
+ CAF_DECL_UUID("ce585a8d-8b49-4312-b356-6f612142b154")
+
+ /**
+ * Return the method name
+ * @return the method name
+ */
+ virtual std::string getMethodName() const = 0;
+
+ /**
+ * Sends the command to the server
+ * @param channel AMQP channel
+ * @return the c-api AMQPStatus of the call
+ */
+ virtual AMQPStatus send(const SmartPtrCAmqpChannel& channel) = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(IServerMethod);
+
+}}
+
+#endif /* ISERVERMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 16, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef QUEUEBINDMETHOD_H_
+#define QUEUEBINDMETHOD_H_
+
+#include "amqpClient/amqpImpl/IServerMethod.h"
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/api/amqpClient.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of AMQP queue.bind
+ */
+class QueueBindMethod : public IServerMethod {
+public:
+ QueueBindMethod();
+ virtual ~QueueBindMethod();
+
+ /**
+ * @brief Initialize the method
+ * @param queue queue name
+ * @param exchange exchange name
+ * @param routingKey routing key
+ * @param arguments binding arguments
+ */
+ void init(
+ const std::string& queue,
+ const std::string& exchange,
+ const std::string& routingKey,
+ const SmartPtrTable& arguments);
+
+public: // IServerMethod
+ std::string getMethodName() const;
+
+ AMQPStatus send(const SmartPtrCAmqpChannel& channel);
+
+private:
+ bool _isInitialized;
+ std::string _queue;
+ std::string _exchange;
+ std::string _routingKey;
+
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(QueueBindMethod);
+};
+CAF_DECLARE_SMART_POINTER(QueueBindMethod);
+
+}}
+
+#endif /* QUEUEBINDMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 10, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef QUEUEDECLAREMETHOD_H_
+#define QUEUEDECLAREMETHOD_H_
+
+#include "amqpClient/amqpImpl/IServerMethod.h"
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/api/amqpClient.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of AMQP queue.declare
+ */
+class QueueDeclareMethod :
+ public IServerMethod {
+public:
+ QueueDeclareMethod();
+ virtual ~QueueDeclareMethod();
+
+ /**
+ * @brief Initialize the method using defaults
+ * <p>
+ * The defaults are:
+ * <table border="1">
+ * <tr>
+ * <th>Parameter</th><th>Value</th>
+ * </tr>
+ * <tr><td>queue</td><td>blank - the server will generate a queue name</td></tr>
+ * <tr><td>durable</td><td>false - the queue will not be durable</td></tr>
+ * <tr><td>exclusive</td><td>true - the queue will be exclusive to this conenction</td></tr>
+ * <tr><td>autoDelete</td><td>true - the queue will be deleted when no longer used</td></tr>
+ * </table>
+ */
+ void init();
+
+ /**
+ * @brief Initialize the method
+ * @param queue queue name
+ * @param durable durable queue flag
+ * @param exclusive exclusive queue flag
+ * @param autoDelete delete when no longer in use flag
+ * @param arguments method arguments
+ */
+ void init(
+ const std::string& queue,
+ bool durable,
+ bool exclusive,
+ bool autoDelete,
+ const SmartPtrTable& arguments);
+
+ /**
+ * @brief Initialize the method in passive mode
+ * @param queue queue name
+ */
+ void initPassive(
+ const std::string& queue);
+
+public: // IServerMethod
+ std::string getMethodName() const;
+
+ AMQPStatus send(const SmartPtrCAmqpChannel& channel);
+
+private:
+ bool _isInitialized;
+ std::string _queue;
+ bool _passive;
+ bool _durable;
+ bool _exclusive;
+ bool _autoDelete;
+ bool _noWait;
+
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(QueueDeclareMethod);
+};
+CAF_DECLARE_SMART_POINTER(QueueDeclareMethod);
+
+}}
+
+#endif /* QUEUEDECLAREMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 16, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef QUEUEDELETEMETHOD_H_
+#define QUEUEDELETEMETHOD_H_
+
+#include "amqpClient/amqpImpl/IServerMethod.h"
+#include "amqpClient/CAmqpChannel.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of AMQP queue.delete
+ */
+class QueueDeleteMethod : public IServerMethod {
+public:
+ QueueDeleteMethod();
+ virtual ~QueueDeleteMethod();
+
+ /**
+ * @brief Initialize the method
+ * @param queue queue name
+ * @param ifUnused delete if queue is not in use flag
+ * @param ifEmpty delete is queue is empty flag
+ */
+ void init(
+ const std::string& queue,
+ const bool ifUnused,
+ const bool ifEmpty);
+
+public: // IServerMethod
+ std::string getMethodName() const;
+
+ AMQPStatus send(const SmartPtrCAmqpChannel& channel);
+
+private:
+ bool _isInitialized;
+ std::string _queue;
+ bool _ifUnused;
+ bool _ifEmpty;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(QueueDeleteMethod);
+
+};
+CAF_DECLARE_SMART_POINTER(QueueDeleteMethod);
+
+}}
+
+#endif /* QUEUEDELETEMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 16, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef QUEUEPURGEMETHOD_H_
+#define QUEUEPURGEMETHOD_H_
+
+
+#include "amqpClient/amqpImpl/IServerMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of AMQP queue.purge
+ */
+class QueuePurgeMethod : public IServerMethod {
+public:
+ QueuePurgeMethod();
+ virtual ~QueuePurgeMethod();
+
+ /**
+ * @brief Initialize the method
+ * @param queue queue name
+ */
+ void init(
+ const std::string& queue);
+
+public: // IServerMethod
+ std::string getMethodName() const;
+
+ AMQPStatus send(const SmartPtrCAmqpChannel& channel);
+
+private:
+ bool _isInitialized;
+ std::string _queue;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(QueuePurgeMethod);
+
+};
+CAF_DECLARE_SMART_POINTER(QueuePurgeMethod);
+
+}}
+
+#endif /* QUEUEPURGEMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 16, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef QUEUEUNBINDMETHOD_H_
+#define QUEUEUNBINDMETHOD_H_
+
+
+#include "amqpClient/amqpImpl/IServerMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/api/amqpClient.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApiImpl
+ * @remark LIBRARY IMPLEMENTATION - NOT PART OF THE PUBLIC API
+ * @brief Implementation of AMQP queue.unbind
+ */
+class QueueUnbindMethod : public IServerMethod {
+public:
+ QueueUnbindMethod();
+ virtual ~QueueUnbindMethod();
+
+ /**
+ * @brief Initialize the method
+ * @param queue queue name
+ * @param exchange exchange name
+ * @param routingKey routing key
+ * @param arguments method arguments
+ */
+ void init(
+ const std::string& queue,
+ const std::string& exchange,
+ const std::string& routingKey,
+ const SmartPtrTable& arguments);
+
+public: // IServerMethod
+ std::string getMethodName() const;
+
+ AMQPStatus send(const SmartPtrCAmqpChannel& channel);
+
+private:
+ bool _isInitialized;
+ std::string _queue;
+ std::string _exchange;
+ std::string _routingKey;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(QueueUnbindMethod);
+
+};
+CAF_DECLARE_SMART_POINTER(QueueUnbindMethod);
+
+}}
+
+#endif /* QUEUEUNBINDMETHOD_H_ */
--- /dev/null
+/*
+ * Created on: May 3, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENTAPI_AMQEXCEPTIONS_H_
+#define AMQPCLIENTAPI_AMQEXCEPTIONS_H_
+
+#include "Exception/CCafException.h"
+#include "amqpClient/AmqpClientLink.h"
+
+#define AMQP_CM_DECLARE_EXCEPTION_CLASS(_exclass_) \
+class AMQPCLIENT_LINKAGE _exclass_ : public Caf::CCafException { \
+public: \
+ _exclass_(); \
+ virtual ~_exclass_(); \
+ void throwSelf(); \
+ void throwAddRefedSelf(); \
+private: \
+ _exclass_(const _exclass_ &); \
+ _exclass_ & operator=(const _exclass_ &); \
+}; \
+typedef TCafSmartPtr<_exclass_, TCafObject<_exclass_> > SmartPtr##_exclass_
+
+#define AMQP_CM_DEFINE_EXCEPTION_CLASS(_exclass_) \
+ _exclass_::_exclass_() : CCafException( #_exclass_ ) {} \
+ _exclass_::~_exclass_() {} \
+ void _exclass_::throwSelf() { throw this; } \
+ void _exclass_::throwAddRefedSelf() { this->AddRef(); throw this; }
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @brief Exceptions defined by this library
+ */
+namespace AmqpExceptions {
+
+/** @brief Unmapped AMQP exception */
+//AMQP_CM_DECLARE_EXCEPTION_CLASS(AmqpException);
+class AMQPCLIENT_LINKAGE AmqpException : public Caf::CCafException {
+public:
+ AmqpException();
+ virtual ~AmqpException();
+ void throwSelf();
+ void throwAddRefedSelf();
+private:
+ AmqpException(const AmqpException &);
+ AmqpException & operator=(const AmqpException &);
+};
+typedef TCafSmartPtr<AmqpException, TCafObject<AmqpException> > SmartPtrAmqpException;
+
+/** @brief AMQP_ERROR_TIMEOUT exception */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(AmqpTimeoutException);
+
+/** @brief AMQP_ERROR_NO_MEMORY exception */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(AmqpNoMemoryException);
+
+/** @brief AMQP_ERROR_INVALID_HANDLE exception */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(AmqpInvalidHandleException);
+
+/** @brief AMQP_ERROR_INVALID_ARGUMENT exception */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(AmqpInvalidArgumentException);
+
+/** @brief AMQP_ERROR_WRONG_STATE exception */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(AmqpWrongStateException);
+
+/** @brief AMQP_ERROR_TOO_MANY_CHANNELS exception */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(AmqpTooManyChannelsException);
+
+/** @brief AMQP_ERROR_QUEUE_FULL exception */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(AmqpQueueFullException);
+
+/** @brief AMQP_ERROR_FRAME_TOO_LARGE exception */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(AmqpFrameTooLargeException);
+
+/** @brief AMQP_ERROR_IO_ERROR exception */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(AmqpIoErrorException);
+
+/** @brief AMQP_ERROR_PROTOCOL_ERROR exception */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(AmqpProtocolErrorException);
+
+/** @brief AMQP_ERROR_UNIMPLEMENTED exception */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(AmqpUnimplementedException);
+
+/** @brief AMQP_ERROR_IO_INTERRUPTED exception */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(AmqpIoInterruptedException);
+
+// Processing exceptions
+
+/** @brief Unexpected frame */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(UnexpectedFrameException);
+
+/** @brief Unknown class or method */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(UnknownClassOrMethodException);
+
+/** @brief Connection is closed */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(ConnectionClosedException);
+
+/** @brief Channel is closed */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(ChannelClosedException);
+
+/** @brief Connection closed because of an error */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(ConnectionUnexpectedCloseException);
+
+/** @brief Connection closed because of an I/O error */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(ConnectionClosedByIOException);
+
+/** @brief Channel closed by server because of an error */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(ChannelClosedByServerException);
+
+/** @brief Channel closed by the application because it is shutting down */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(ChannelClosedByShutdownException);
+
+/** @brief Channel closed by the application user under normal circumstances */
+AMQP_CM_DECLARE_EXCEPTION_CLASS(ChannelClosedByUserException);
+
+}}}
+
+#endif
--- /dev/null
+/*
+ * Created on: May 4, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENTAPI_ADDRESS_H_
+#define AMQPCLIENTAPI_ADDRESS_H_
+
+namespace Caf { namespace AmqpClient {
+
+/** Supported Protocols */
+typedef enum {
+ PROTOCOL_AMQP = 0,
+ PROTOCOL_AMQPS,
+ PROTOCOL_TUNNEL
+} Protocol;
+
+/**
+ * @author mdonahue
+ * @brief A representation of a broker network address
+ */
+class Address {
+public:
+ Address();
+ virtual ~Address();
+
+public:
+ /**
+ * @brief Construct an address from a protocol, host name, and port number
+ * @param protocol the communication protocol (tcp, ssl, etc.)
+ * @param host the host name or dotted ip address
+ * @param port the port number
+ */
+ void initialize(
+ const std::string& protocol,
+ const std::string& host,
+ const uint32& port,
+ const std::string& virtualHost = std::string());
+
+ /**
+ * @return the protocol
+ */
+ Protocol getProtocol() const;
+
+ /**
+ * @return the protocol
+ */
+ std::string getProtocolStr() const;
+
+ /**
+ * @return the host name
+ */
+ std::string getHost() const;
+
+ /**
+ * @return the port number
+ */
+ uint32 getPort() const;
+
+ std::string getVirtualHost() const;
+
+ std::string toString() const;
+
+private:
+ Protocol translateProtocol(
+ const std::string& protocol,
+ const std::string& host) const;
+
+private:
+ bool _isInitialized;
+ std::string _protocolStr;
+ Protocol _protocol;
+ std::string _host;
+ uint32 _port;
+ std::string _virtualHost;
+ std::string _toString;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(Address);
+};
+CAF_DECLARE_SMART_POINTER(Address);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: May 14, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENTAPI_AMQPCONTENTHEADERS_H_
+#define AMQPCLIENTAPI_AMQPCONTENTHEADERS_H_
+
+#include "amqpClient/api/amqpClient.h"
+#include "amqpClient/amqpImpl/BasicProperties.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @ingroup AmqpApi
+ * @brief AMQP content header objects */
+namespace AmqpContentHeaders {
+
+/** @brief content type property is present */
+extern AMQPCLIENT_LINKAGE const uint32 BASIC_PROPERTY_CONTENT_TYPE_FLAG;
+/** @brief content encoding property is present */
+extern AMQPCLIENT_LINKAGE const uint32 BASIC_PROPERTY_CONTENT_ENCODING_FLAG;
+/** @brief headers are present */
+extern AMQPCLIENT_LINKAGE const uint32 BASIC_PROPERTY_HEADERS_FLAG;
+/** @brief delivery mode property is present */
+extern AMQPCLIENT_LINKAGE const uint32 BASIC_PROPERTY_DEVLIVERY_MODE_FLAG;
+/** @brief priority property is present */
+extern AMQPCLIENT_LINKAGE const uint32 BASIC_PROPERTY_PRIORITY_FLAG;
+/** @brief correlation id property is present */
+extern AMQPCLIENT_LINKAGE const uint32 BASIC_PROPERTY_CORRELATION_ID_FLAG;
+/** @brief reply to property is present */
+extern AMQPCLIENT_LINKAGE const uint32 BASIC_PROPERTY_REPLY_TO_FLAG;
+/** @brief expiration property is present */
+extern AMQPCLIENT_LINKAGE const uint32 BASIC_PROPERTY_EXPIRATION_FLAG;
+/** @brief message id property is present */
+extern AMQPCLIENT_LINKAGE const uint32 BASIC_PROPERTY_MESSAGE_ID_FLAG;
+/** @brief timestamp property is present */
+extern AMQPCLIENT_LINKAGE const uint32 BASIC_PROPERTY_TIMESTAMP_FLAG;
+/** @brief type property is present */
+extern AMQPCLIENT_LINKAGE const uint32 BASIC_PROPERTY_TYPE_FLAG;
+/** @brief user id property is present */
+extern AMQPCLIENT_LINKAGE const uint32 BASIC_PROPERTY_USER_ID_FLAG;
+/** @brief app id property is present */
+extern AMQPCLIENT_LINKAGE const uint32 BASIC_PROPERTY_APP_ID_FLAG;
+/** @brief cluster id property is present */
+extern AMQPCLIENT_LINKAGE const uint32 BASIC_PROPERTY_CLUSTER_ID_FLAG;
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApi
+ * @brief Basic properties class
+ * <p>
+ * Review the AMQP protocol documentation for more information.
+ */
+struct __declspec(novtable) BasicProperties : public ContentHeader {
+ CAF_DECL_UUID("A6DEE271-36C7-4B46-8EA8-F1F0E3493FC4")
+
+ /** @return are the headers available? */
+ virtual bool areHeadersAvailable() = 0;
+
+ /**
+ * @remark
+ * Use the binary 'and' (<code><b>&</b></code>) to test the flags against the
+ * BASIC_PROPERTY_XXXXX_FLAGS
+ * @return the bits representing the properties present in the object
+ */
+ virtual uint32 getFlags() = 0;
+
+ /** @return the content type */
+ virtual std::string getContentType() = 0;
+
+ /** @brief Set the content type */
+ virtual void setContentType(const std::string& contentType) = 0;
+
+ /** @return the content encoding */
+ virtual std::string getContentEncoding() = 0;
+
+ /** @brief Set the content encoding */
+ virtual void setContentEncoding(const std::string& contentEncoding) = 0;
+
+ /** @return the message headers */
+ virtual SmartPtrTable getHeaders() = 0;
+
+ /** @brief Set the headers */
+ virtual void setHeaders(const SmartPtrTable& headers) = 0;
+
+ /** @return the delivery mode */
+ virtual uint8 getDeliveryMode() = 0;
+
+ /** @brief Set the delivery mode */
+ virtual void setDeliveryMode(const uint8 deliveryMode) = 0;
+
+ /** @return the priority */
+ virtual uint8 getPriority() = 0;
+
+ /** @brief Set the priority */
+ virtual void setPriority(const uint8 priority) = 0;
+
+ /** @return the correlation id */
+ virtual std::string getCorrelationId() = 0;
+
+ /** @brief Set the correlation id */
+ virtual void setCorrelationId(const std::string& correlationId) = 0;
+
+ /** @return the reply to */
+ virtual std::string getReplyTo() = 0;
+
+ /** @brief Set the reply to */
+ virtual void setReplyTo(const std::string& replyTo) = 0;
+
+ /** @return the expiration */
+ virtual std::string getExpiration() = 0;
+
+ /** @brief Set the expiration */
+ virtual void setExpiration(const std::string& expiration) = 0;
+
+ /** @return the message id */
+ virtual std::string getMessageId() = 0;
+
+ /** @brief Set the message id */
+ virtual void setMessageId(const std::string& messageId) = 0;
+
+ /** @return the timestamp */
+ virtual uint64 getTimestamp() = 0;
+
+ /** @brief Set the timestamp */
+ virtual void setTimestamp(const uint64 timestamp) = 0;
+
+ /** @return the type */
+ virtual std::string getType() = 0;
+
+ /** @brief set the type */
+ virtual void setType(const std::string& type) = 0;
+
+ /** @return the user id */
+ virtual std::string getUserId() = 0;
+
+ /** @brief Set the user id */
+ virtual void setUserId(const std::string& userId) = 0;
+
+ /** @return the app id */
+ virtual std::string getAppId() = 0;
+
+ /** @brief Set the app id */
+ virtual void setAppId(const std::string& appId) = 0;
+
+ /** @return the cluster id */
+ virtual std::string getClusterId() = 0;
+
+ /** @brief Set the cluster id */
+ virtual void setClusterId(const std::string& clusterId) = 0;
+};
+CAF_DECLARE_SMART_POINTER(BasicProperties);
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApi
+ * @brief Create a #Caf::AmqpClient::AmqpContentHeaders::BasicProperties object to be
+ * sent with a message.
+ * <p>
+ * The object is created with no fields set. You must call the <code>setXXX</code>
+ * methods before publishing the message.
+ * @return an unpopulated basic properties object
+ */
+SmartPtrBasicProperties AMQPCLIENT_LINKAGE createBasicProperties();
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApi
+ * @brief Create an object containing #Caf::AmqpClient::AmqpContentHeaders::BasicProperties
+ * to be sent with a message
+ * <p>
+ * Set the <code><i>flags</i></code> property to the binary 'or' (<code><b>|</b></code>) of
+ * BASIC_PROPERTY_XXXX_FLAG constants representing the fields present.
+ * <p>
+ * Use <code><b>0</b></code>, <code><b>std::string()</b></code> or
+ * <code><b>SmartPtrTable()</b></code> to skip initialization of fields not included
+ * in the object.
+ * @return a basic properties object
+ */
+SmartPtrBasicProperties AMQPCLIENT_LINKAGE createBasicProperties(
+ const uint32 flags,
+ const std::string& contentType,
+ const std::string& contentEncoding,
+ const SmartPtrTable& headers,
+ const uint8 deliveryMode,
+ const uint8 priority,
+ const std::string& correlationId,
+ const std::string& replyTo,
+ const std::string& expiration,
+ const std::string& messageId,
+ const uint64 timestamp,
+ const std::string& type,
+ const std::string& userId,
+ const std::string& appId,
+ const std::string& clusterId);
+}}}
+
+#endif
--- /dev/null
+/*
+ * Created on: May 10, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENTAPI_AMQPMETHODS_H_
+#define AMQPCLIENTAPI_AMQPMETHODS_H_
+
+#include "amqpClient/api/Method.h"
+
+namespace Caf { namespace AmqpClient { namespace AmqpMethods {
+
+#if (1) // basic
+/**
+ * @brief AMQP Basic methods
+ * @ingroup AmqpApi
+ */
+namespace Basic {
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the basic.get-ok method parameters
+ */
+struct __declspec(novtable) GetOk : public Method {
+ CAF_DECL_UUID("A3CD4488-B600-4AC6-9513-03021AC06345")
+
+ /** @return the delivery tag used for basic.ack calls */
+ virtual uint64 getDeliveryTag() = 0;
+
+ /**
+ * @retval true if the message was redelivered
+ * @retval false if the message has not been redlivered
+ */
+ virtual bool getRedelivered() = 0;
+
+ /** @return the name of the exchange supplying the message */
+ virtual std::string getExchange() = 0;
+
+ /** @return the message's routing key */
+ virtual std::string getRoutingKey() = 0;
+
+ /** @return the number of messages remaining in the queue */
+ virtual uint32 getMessageCount() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(GetOk);
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the basic.get-empty method parameters
+ */
+struct __declspec(novtable) GetEmpty : public Method {
+ CAF_DECL_UUID("6bcd3e9e-e2b1-4824-b455-acad073737c5")
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(GetEmpty);
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the basic.consume-ok method parameters
+ */
+struct __declspec(novtable) ConsumeOk : public Method {
+ CAF_DECL_UUID("29E385DA-37FB-48E4-9F6D-463555C9DDDC")
+
+ virtual std::string getConsumerTag() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(ConsumeOk);
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the basic.deliver method parameters
+ */
+struct __declspec(novtable) Deliver : public Method {
+ CAF_DECL_UUID("2AD74C5E-CC9D-4A6C-9738-DA836BC25FCA")
+
+ /** @return the <i>consumer tag</i> associated with the consumer */
+ virtual std::string getConsumerTag() = 0;
+
+ /** @return the delivery tag used for basic.ack calls */
+ virtual uint64 getDeliveryTag() = 0;
+
+ /**
+ * @retval true if the message was redelivered
+ * @retval false if the message has not been redlivered
+ */
+ virtual bool getRedelivered() = 0;
+
+ /** @return the name of the exchange supplying the message */
+ virtual std::string getExchange() = 0;
+
+ /** @return the message's routing key */
+ virtual std::string getRoutingKey() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(Deliver);
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the basic.consume-ok method parameters
+ */
+struct __declspec(novtable) CancelOk : public Method {
+ CAF_DECL_UUID("759CEE2C-FDA5-4A2A-BFE0-617A879D05BF")
+
+ /** @return the <i>consumer tag</i> associated with the consumer */
+ virtual std::string getConsumerTag() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(CancelOk);
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the basic.return method parameters
+ */
+struct __declspec(novtable) Return : public Method {
+ CAF_DECL_UUID("000A440E-AEE4-418E-B9A0-9857F5C20283")
+
+ /** @return the reply code */
+ virtual uint16 getReplyCode() = 0;
+
+ /** @return the reply text */
+ virtual std::string getReplyText() = 0;
+
+ /** @return the exchnage name */
+ virtual std::string getExchange() = 0;
+
+ /** @return the routing key */
+ virtual std::string getRoutingKey() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(Return);
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the basic.recover-ok method parameters
+ */
+struct __declspec(novtable) RecoverOk : public Method {
+ CAF_DECL_UUID("DF71DC22-B65C-44FC-A0F4-EFAC181E2F69")
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(RecoverOk);
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the basic.qos-ok method
+ */
+struct __declspec(novtable) QosOk : public Method {
+ CAF_DECL_UUID("D5710B1C-DE05-42F5-9695-95364C1D9468")
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(QosOk);
+
+} // namespace Basic
+#endif
+
+#if (1) // channel
+/**
+ * @ingroup AmqpApi
+ * @brief AMQP Channel methods
+ */
+namespace Channel {
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the channel.open-ok method parameters
+ */
+struct __declspec(novtable) OpenOk : public Method {
+ CAF_DECL_UUID("4c027f40-db11-4a72-ac2e-cc8da89035cb")
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(OpenOk);
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the channel.close method parameters
+ */
+struct __declspec(novtable) Close : public Method {
+ CAF_DECL_UUID("45d0c75f-ff48-4552-9a83-498efa5f6ad2")
+
+ /** @return the reply code */
+ virtual uint16 getReplyCode() = 0;
+
+ /** @return the reply text */
+ virtual std::string getReplyText() = 0;
+
+ /** @return the class id of the method that caused the close */
+ virtual uint16 getClassId() = 0;
+
+ /** @return the method id of the method that caused the close */
+ virtual uint16 getMethodId() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(Close);
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the channel.close-ok method parameters
+ */
+struct __declspec(novtable) CloseOk : public Method {
+ CAF_DECL_UUID("DAF11BD3-06B6-4FA4-AC80-2B0959D2297D")
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(CloseOk);
+
+} // namespace Channel
+#endif
+
+#if (1) // exchange
+/**
+ * @ingroup AmqpApi
+ * @brief AMQP Exchange methods
+ */
+namespace Exchange {
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the exchange.declare-ok method parameters
+ */
+struct __declspec(novtable) DeclareOk : public Method {
+ CAF_DECL_UUID("e54d9fff-7905-4e18-b1e8-090279a5cffe")
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(DeclareOk);
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the exchange.delete-ok method parameters
+ */
+struct __declspec(novtable) DeleteOk : public Method {
+ CAF_DECL_UUID("9f13d0fb-1bdd-473a-873a-58e948bc256c")
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(DeleteOk);
+
+} // namespace Exchange
+#endif
+
+#if (1) // queue
+/**
+ * @ingroup AmqpApi
+ * @brief AMQP Queue methods
+ */
+namespace Queue {
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the queue.declare-ok method parameters
+ */
+struct __declspec(novtable) DeclareOk : public Method {
+ CAF_DECL_UUID("EB96E48E-DF40-4D5F-A41F-7F4EBEBE2BE1")
+
+ /** @return the name of the queue */
+ virtual std::string getQueueName() = 0;
+
+ /** @return the number of messages in the queue */
+ virtual uint32 getMessageCount() = 0;
+
+ /** @return the number of active consumers for the queue */
+ virtual uint32 getConsumerCount() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(DeclareOk);
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the queue.delete-ok method parameters
+ */
+struct __declspec(novtable) DeleteOk : public Method {
+ CAF_DECL_UUID("34f4b342-7ab0-44d5-b007-4eec141a4435")
+
+ /** @return the number of messages deleted */
+ virtual uint32 getMessageCount() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(DeleteOk);
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the queue.delete-ok method parameters
+ */
+struct __declspec(novtable) PurgeOk : public Method {
+ CAF_DECL_UUID("63bcf694-5ac3-4067-8134-659133986099")
+
+ /** @return the number of messages deleted */
+ virtual uint32 getMessageCount() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(PurgeOk);
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the queue.bind-ok method parameters
+ */
+struct __declspec(novtable) BindOk : public Method {
+ CAF_DECL_UUID("1a60c168-24d1-4184-a5ec-fcf9fca70994")
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(BindOk);
+
+/**
+ * @ingroup AmqpApi
+ * @brief Interface representing the queue.unbind-ok method parameters
+ */
+struct __declspec(novtable) UnbindOk : public Method {
+ CAF_DECL_UUID("edf78de1-eee4-44c0-9051-e4f6ee80c0a2")
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(UnbindOk);
+
+} // namespace Queue
+#endif
+
+}}}
+
+#endif
--- /dev/null
+/*
+ * Created on: May 4, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENTAPI_CERTINFO_H_
+#define AMQPCLIENTAPI_CERTINFO_H_
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author bwilliams
+ * @brief A representation of Cert Info
+ */
+class CertInfo {
+public:
+ CertInfo();
+ virtual ~CertInfo();
+
+public:
+ void initialize(
+ const std::string& caCertPath,
+ const std::string& clientCertPath,
+ const std::string& clientKeyPath);
+
+ std::string getCaCertPath() const;
+
+ std::string getClientCertPath() const;
+
+ std::string getClientKeyPath() const;
+
+private:
+ bool _isInitialized;
+ std::string _caCertPath;
+ std::string _clientCertPath;
+ std::string _clientKeyPath;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CertInfo);
+};
+CAF_DECLARE_SMART_POINTER(CertInfo);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: May 2, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENTAPI_CHANNEL_H_
+#define AMQPCLIENTAPI_CHANNEL_H_
+
+
+#include "ICafObject.h"
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/api/AmqpMethods.h"
+#include "amqpClient/api/Consumer.h"
+#include "amqpClient/api/GetResponse.h"
+#include "amqpClient/api/ReturnListener.h"
+#include "amqpClient/api/amqpClient.h"
+#include "amqpClient/api/AmqpContentHeaders.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApi
+ * @brief Interface to an AMQP channel
+ */
+struct __declspec(novtable) Channel : public ICafObject {
+
+ /** @return the channel number */
+ virtual uint16 getChannelNumber() = 0;
+
+ /** @brief Closes the channel */
+ virtual void close() = 0;
+
+ /**
+ * @brief Returns the state of the channel
+ * @retval true the Channel is open
+ * @retval false the Channel is closed
+ */
+ virtual bool isOpen() = 0;
+
+ /**
+ * @brief Acknowledge on or more messages
+ * <p>
+ * Acknowledges one or more messages delivered via the Deliver or
+ * Get-Ok methods. The client can ask to confirm a single message or a set of
+ * messages up to and including a specific message.
+ *
+ * @param deliveryTag the message's delivery tag
+ * @param ackMultiple acknowledge multiple messages<p>
+ * If set to <code><b>true</b></code>, the delivery tag is treated as "up to and
+ * including", so that the client can acknowledge multiple messages with a single
+ * method. If set to <code><b>false</b></code>, the delivery tag refers to a single
+ * message. If the multiple field is <code><b>true</b></code>, and the delivery tag
+ * is <code><b>0</b></code>, the server will acknowledge all outstanding messages.
+ */
+ virtual void basicAck(
+ const uint64 deliveryTag,
+ const bool ackMultiple) = 0;
+
+ /**
+ * @brief Provides a direct access to the messages in a queue
+ * <p>
+ * This method provides a direct access to the messages in a queue using a
+ * synchronous dialogue that is designed for specific types of application where
+ * synchronous functionality is more important than performance.
+ *
+ * @param queue the queue name
+ * @param noAck no acknowledgment needed. If <code><b>true</b></code>, the server does not
+ * expect acknowledgements for messages. That is, when a message is delivered to the client
+ * the server assumes the delivery will succeed and immediately dequeues it. This
+ * functionality may increase performance but at the cost of reliability. Messages can get
+ * lost if a client dies before they are delivered to the application.
+ * @return message as a GetResponse object or
+ * a <code><b>null</b></code> object if there is no message available.
+ */
+ virtual SmartPtrGetResponse basicGet(
+ const std::string& queue,
+ const bool noAck) = 0;
+
+ /**
+ * @brief Publishes a message to a specific exchange
+ * <p>
+ * This method publishes a message to a specific exchange. The message will be routed
+ * to queues as defined by the exchange configuration and distributed to any active
+ * consumers when the transaction, if any, is committed.
+ * @param exchange specifies the name of the exchange to publish to. The exchange
+ * name can be empty, meaning the default exchange.
+ * @param routingKey specifies the routing key for the message.
+ * @param properties specifies a #Caf::AmqpClient::AmqpContentHeaders::BasicProperties
+ * object containing properties and headers to publish with the message.
+ * @param body specifies the message body in raw bytes.
+ */
+ virtual void basicPublish(
+ const std::string& exchange,
+ const std::string& routingKey,
+ const AmqpContentHeaders::SmartPtrBasicProperties& properties,
+ const SmartPtrCDynamicByteArray& body) = 0;
+
+ /**
+ * @brief Publishes a message to a specific exchange
+ * <p>
+ * This method publishes a message to a specific exchange with control over the
+ * <code><i>mandatory</i></code> and <code><i>immediate</i></code> bits.
+ * The message will be routed to queues as defined by the exchange configuration and
+ * distributed to any active consumers when the transaction, if any, is committed.
+ * @param exchange specifies the name of the exchange to publish to. The exchange
+ * name can be empty, meaning the default exchange.
+ * @param routingKey specifies the routing key for the message.
+ * @param mandatory specifies how the server is to react if the message cannot be routed
+ * to a queue. If <code><b>true</b></code>, the server will return an unroutable message
+ * with a Return method. If <code><b>false</b></code>, the server silently drops the
+ * message.
+ * @param immediate specifies how the server is to react if the message cannot be routed
+ * to a queue consumer immediately. If <code><b>true</b></code>, the server will return an
+ * undeliverable message with a Return method. If <code><b>false</b></code>,
+ * the server will queue the message, but with no guarantee that it will ever be
+ * consumed.
+ * @param properties specifies a #Caf::AmqpClient::AmqpContentHeaders::BasicProperties
+ * object containing properties and headers to publish with the message.
+ * @param body specifies the message body in raw bytes.
+ */
+ virtual void basicPublish(
+ const std::string& exchange,
+ const std::string& routingKey,
+ const bool mandatory,
+ const bool immediate,
+ const AmqpContentHeaders::SmartPtrBasicProperties& properties,
+ const SmartPtrCDynamicByteArray& body) = 0;
+
+ /**
+ * @brief Starts a queue consumer
+ * <p>
+ * This method asks the server to start a 'consumer', which is a transient request for
+ * messages from a specific queue. Consumers last as int32 as the channel they were
+ * declared on, or until the client cancels them.<br>
+ * The arguments <code><i>noAck</i></code>, <code><i>noLocal</i></code> and
+ * <code><i>exclusive</i></code> are <code><b>false</b></code> and the server will
+ * genearate the consumer tag.
+ * @param queue queue name
+ * @param consumer an interface to the consumer object
+ * @return a #Caf::AmqpClient::AmqpMethods::Basic::ConsumeOk object containing
+ * the results of the call if successful
+ */
+ virtual AmqpMethods::Basic::SmartPtrConsumeOk basicConsume(
+ const std::string& queue,
+ const SmartPtrConsumer& consumer) = 0;
+
+ /**
+ * @brief Starts a queue consumer
+ * <p>
+ * This method asks the server to start a 'consumer', which is a transient request for
+ * messages from a specific queue. Consumers last as int32 as the channel they were
+ * declared on, or until the client cancels them.<br>
+ * The arguments <code><i>noLocal</i></code> and <code><i>exclusive</i></code> are
+ * <code><b>false</b></code> and the server will genearate the consumer tag.
+ * @param queue queue name
+ * @param noAck no acknowledgment needed. If <code><b>true</b></code>, the server does not
+ * expect acknowledgements for messages. That is, when a message is delivered to the client
+ * the server assumes the delivery will succeed and immediately dequeues it. This
+ * functionality may increase performance but at the cost of reliability. Messages can get
+ * lost if a client dies before they are delivered to the application.
+ * @param consumer an interface to the consumer object
+ * @return a #Caf::AmqpClient::AmqpMethods::Basic::ConsumeOk object containing
+ * the results of the call if successful
+ */
+ virtual AmqpMethods::Basic::SmartPtrConsumeOk basicConsume(
+ const std::string& queue,
+ const bool noAck,
+ const SmartPtrConsumer& consumer) = 0;
+
+ /**
+ * @brief Starts a queue consumer
+ * <p>
+ * This method asks the server to start a 'consumer', which is a transient request for
+ * messages from a specific queue. Consumers last as int32 as the channel they were
+ * declared on, or until the client cancels them.
+ * @param queue queue name
+ * @param consumerTag consumer tag (or blank to specify server-generated tag)
+ * @param noAck acknowledgement flag
+ * @param noLocal do not send messages to the connection that published them
+ * @param exclusive request exclusive consumer access to the queue
+ * @param consumer an interface to the consumer object
+ * @param arguments a set of arguments for the declaration. The syntax of these
+ * arguments depends on the server implementation.
+ * @return a #Caf::AmqpClient::AmqpMethods::Basic::ConsumeOk object containing
+ * the results of the call if successful
+ */
+ virtual AmqpMethods::Basic::SmartPtrConsumeOk basicConsume(
+ const std::string& queue,
+ const std::string& consumerTag,
+ const bool noAck,
+ const bool noLocal,
+ const bool exclusive,
+ const SmartPtrConsumer& consumer,
+ const SmartPtrTable& arguments = SmartPtrTable()) = 0;
+
+ /**
+ * @brief Cancels a consumer
+ * <p>
+ * This method cancels a consumer. This does not affect already delivered messages,
+ * but it does mean the server will not send any more messages for that consumer.
+ * The client may receive an arbitrary number of messages in between sending the cancel
+ * method and receiving the cancel.ok reply.
+ * @param consumerTag consumer tag to cancel
+ * @return a #Caf::AmqpClient::AmqpMethods::Basic::CancelOk object containing
+ * the results of the call if successful
+ */
+ virtual AmqpMethods::Basic::SmartPtrCancelOk basicCancel(
+ const std::string& consumerTag) = 0;
+
+ /**
+ * @brief Redeliver unacknowledged messages
+ * <p>
+ * This method asks the server to redeliver all unacknowledged message on the channel.
+ * Zero or more messages may be redelivered.
+ * @param requeue if <code><b>false</b></code> then the message will be redelivered to
+ * the original receipient. If <code><b>true</b></code> then the server will attempt to
+ * requeue the message, potentially delivering it to an alternate subscriber.
+ * @return a #Caf::AmqpClient::AmqpMethods::Basic::RecoverOk object containing the
+ * results of the call if successful
+ */
+ virtual AmqpMethods::Basic::SmartPtrRecoverOk basicRecover(
+ const bool requeue) = 0;
+
+ /**
+ * @brief Specifies quality of service
+ * <p>
+ * This method requests a specific quality of service. The QoS can be specified for
+ * the current channel or for all channels on the connection. The particular properties
+ * and semantics of a qos method always depend on the content class semantics.
+ * @param prefetchSize prefetch window in octets. The client can request that messages
+ * be sent in advance so that when the client finishes processing a message,
+ * the following message is already help locally, rather than needing to be sent down
+ * the channel. Prefetching gives a performance improvement. This field specifies the
+ * prefetch window size in octets. The server will send a message in advance if it is
+ * equal to or smaller in size than the available prefetch size (and also falls into
+ * other prefetch limits). May be set to zero, meaning 'no specific limit', although
+ * other prefetch limits may still apply. The prefetch-size is ignored if the no-ack
+ * option is set.
+ * @param prefetchCount prefetch window in messages. This field may be used in combination
+ * with the <i>prefetchSize</i> field; a message will only be sent in advance if both
+ * prefetch windows (and those at the channel and connection level) allow it. The
+ * prefetch-count is ignored if the no-ack option is set.
+ * @param global apply to entire connection
+ * @return
+ */
+ virtual AmqpMethods::Basic::SmartPtrQosOk basicQos(
+ const uint32 prefetchSize,
+ const uint32 prefetchCount,
+ const bool global) = 0;
+
+ /**
+ * @brief Reject an incoming message
+ * <p>
+ * This method allows a client to reject a message. It can be used to interrupt and
+ * cancel large incoming messages, or return un-treatable messages to their original
+ * queue.
+ * @param deliveryTag the delivery tag of the message
+ * @param requeue if <code><b>true</b></code>, the server will attempt to requeue
+ * the message. If <code><b>false</b></code> or the requeue attempt fails the
+ * message is discarded or dead-lettered.
+ */
+ virtual void basicReject(
+ const uint64 deliveryTag,
+ const bool requeue) = 0;
+
+ /**
+ * @brief Creates an exchange
+ * <p>
+ * This method creates an exchange if it does not already exist, and if the exchange
+ * exists, verifies that it is of the correct and expected class.
+ * @param exchange exchange name
+ * @param type exchange type
+ * @param durable request a durable exchange
+ * @param arguments a set of agrguments for the declaration. The syntax of these
+ * arguments depends on the server implementation.
+ * @return a #Caf::AmqpClient::AmqpMethods::Exchange::DeclareOk object containing
+ * the results of the call if successful
+ */
+ virtual AmqpMethods::Exchange::SmartPtrDeclareOk exchangeDeclare(
+ const std::string& exchange,
+ const std::string& type,
+ const bool durable = false,
+ const SmartPtrTable& arguments = SmartPtrTable()) = 0;
+
+ /**
+ * @brief Deletes an exchange
+ * <p>
+ * This method deletes an exchange. When an exchange is deleted all queue bindings on
+ * the exchange are cancelled.
+ * @param exchange exchange name
+ * @param ifUnused delete only if unused. If <code><b>true</b></code>, the server
+ * will only delete the exchange if it has no queue bindings. If the exchange has
+ * queue bindings the server does not delete it but raises a channel exception
+ * instead.
+ * @return a #Caf::AmqpClient::AmqpMethods::Exchange::DeleteOk object containing
+ * the results of the call if successful
+ */
+ virtual AmqpMethods::Exchange::SmartPtrDeleteOk exchangeDelete(
+ const std::string& exchange,
+ const bool ifUnused) = 0;
+
+ /**
+ * @brief Creates a queue using default parameters
+ * <p>
+ * The defaults are:
+ * <table border="1">
+ * <tr>
+ * <th>Parameter</th><th>Value</th>
+ * </tr>
+ * <tr><td>queue</td><td>blank - the server will generate a queue name</td></tr>
+ * <tr><td>durable</td><td>false - the queue will not be durable</td></tr>
+ * <tr><td>exclusive</td><td>true - the queue will be exclusive to this conenction</td></tr>
+ * <tr><td>autoDelete</td><td>true - the queue will be deleted when no longer used</td></tr>
+ * </table>
+ * @return a #Caf::AmqpClient::AmqpMethods::Queue::DeclareOk object containing
+ * the results of the call if successful. This object must be examined to retrieve
+ * the name of the queue generated by the server.
+ */
+ virtual AmqpMethods::Queue::SmartPtrDeclareOk queueDeclare() = 0;
+
+ /**
+ * @brief Creates or checks a queue
+ * <p>
+ * @param queue queue name. If blank the server will generate a name.
+ * @param durable request a durable queue
+ * @param exclusive request an exclusive queue
+ * @param autoDelete request that the queue be deleted when no longer in use
+ * @param arguments a set of agrguments for the declaration. The syntax of these
+ * arguments depends on the server implementation.
+ * @return a #Caf::AmqpClient::AmqpMethods::Queue::DeclareOk object containing
+ * the results of the call if successful. This object must be examined to retrieve
+ * the name of the queue generated by the server if the queue name was blank in
+ * the call.
+ */
+ virtual AmqpMethods::Queue::SmartPtrDeclareOk queueDeclare(
+ const std::string& queue,
+ const bool durable,
+ const bool exclusive,
+ const bool autoDelete,
+ const SmartPtrTable& arguments = SmartPtrTable()) = 0;
+
+ /**
+ * @brief Declare a queue passively; i.e. check if it exists.
+ * <p>
+ * @param queue queue name.
+ */
+ virtual AmqpMethods::Queue::SmartPtrDeclareOk queueDeclarePassive(
+ const std::string& queue) = 0;
+
+ /**
+ * @brief Deletes a queue
+ * <p>
+ * This method deletes a queue. When a queue is deleted any pending messages are
+ * sent to a dead­-letter queue if this is defined in the server configuration,
+ * and all consumers on the queue are cancelled.
+ * @param queue queue name
+ * @param ifUnused delete only if unused. If <code><b>true</b></code>, the server
+ * will only delete the queue if it has no consumers. If the queue has consumers the
+ * server does does not delete it but raises a channel exception instead.
+ * @param ifEmpty delete only if empty. If <code><b>true</b></code>, the server will
+ * only delete the queue if it has no messages. If the queue has messages the
+ * server does does not delete it but raises a channel exception instead.
+ * @return a #Caf::AmqpClient::AmqpMethods::Queue::DeleteOk object containing the
+ * result of the call if successful.
+ */
+ virtual AmqpMethods::Queue::SmartPtrDeleteOk queueDelete(
+ const std::string& queue,
+ const bool ifUnused,
+ const bool ifEmpty) = 0;
+
+ /**
+ * @brief Purges a queue
+ * <p>
+ * This method removes all messages from a queue which are not awaiting
+ * acknowledgment.
+ * @param queue queue name
+ * @return a #Caf::AmqpClient::AmqpMethods::Queue::PurgeOk containing the result
+ * of the call if successful.
+ */
+ virtual AmqpMethods::Queue::SmartPtrPurgeOk queuePurge(
+ const std::string& queue) = 0;
+
+ /**
+ * @brief Binds a queue to an exchange
+ * <p>
+ * This method binds a queue to an exchange. Until a queue is bound it will not
+ * receive any messages.
+ * @param queue queue name
+ * @param exchange exchange name
+ * @param routingKey message routing key
+ * @param arguments a set of agrguments for the binding. The syntax of these
+ * arguments depends on the server implementation.
+ * @return a #Caf::AmqpClient::AmqpMethods::Queue::BindOk containing the result
+ * of the call if successful.
+ */
+ virtual AmqpMethods::Queue::SmartPtrBindOk queueBind(
+ const std::string& queue,
+ const std::string& exchange,
+ const std::string& routingKey,
+ const SmartPtrTable& arguments = SmartPtrTable()) = 0;
+
+ /**
+ * @brief Unbinds a queue from an exchange
+ * @param queue queue name
+ * @param exchange exchange name
+ * @param routingKey message routing key
+ * @param arguments a set of agrguments for the binding. The syntax of these
+ * arguments depends on the server implementation.
+ * @return a #Caf::AmqpClient::AmqpMethods::Queue::UnbindOk containing the result
+ * of the call if successful.
+ */
+ virtual AmqpMethods::Queue::SmartPtrUnbindOk queueUnbind(
+ const std::string& queue,
+ const std::string& exchange,
+ const std::string& routingKey,
+ const SmartPtrTable& arguments = SmartPtrTable()) = 0;
+
+ /**
+ * @brief Adds a {@link ReturnListener} to the channel
+ * @param listener the {@link ReturnListener} object to add
+ */
+ virtual void addReturnListener(
+ const SmartPtrReturnListener& listener) = 0;
+
+ /**
+ * @brief Removes a {@link ReturnListener} from the channel
+ * @param listener the {@link ReturnListener} to remove
+ */
+ virtual bool removeReturnListener(
+ const SmartPtrReturnListener& listener) = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(Channel);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: May 2, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENTAPI_CONNECTION_H_
+#define AMQPCLIENTAPI_CONNECTION_H_
+
+
+#include "ICafObject.h"
+
+#include "amqpClient/api/Channel.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApi
+ * @brief Interface to an AMQP connection.
+ */
+struct __declspec(novtable) Connection : public ICafObject {
+ /**
+ * @brief Create a new channel
+ * @return a Channel
+ */
+ virtual SmartPtrChannel createChannel() = 0;
+
+ /**
+ * @brief Close a channel
+ * @param channel the Channel to close
+ */
+ virtual void closeChannel(const SmartPtrChannel& channel) = 0;
+
+ /**
+ * @brief Closes the connection and its channels
+ */
+ virtual void close() = 0;
+
+ /**
+ * @brief Return the state of the connection
+ * @retval true the connection is open
+ * @retval false the connection is closed
+ */
+ virtual bool isOpen() = 0;
+};
+
+CAF_DECLARE_SMART_INTERFACE_POINTER(Connection);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: May 4, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENTAPI_CONNECTIONFACTORY_H_
+#define AMQPCLIENTAPI_CONNECTIONFACTORY_H_
+
+#include "ICafObject.h"
+
+#include "amqpClient/api/Address.h"
+#include "amqpClient/api/CertInfo.h"
+#include "amqpClient/api/Connection.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApi
+ * @brief Interface to a convenience factory class to facilitate opening a
+ * #Caf::AmqpClient::Connection to an AMQP broker.
+ * <p>
+ * ConnectionFactories are creating using the #Caf::AmqpClient::createConnectionFactory method.
+ */
+struct __declspec(novtable) ConnectionFactory : public ICafObject {
+
+ /**
+ * @return the default protocol to use for connections
+ */
+ virtual std::string getProtocol() const = 0;
+
+ /**
+ * @brief Set the default protocol for connections
+ * @param protocol the default protocol for connections
+ */
+ virtual void setProtocol(const std::string& protocol) = 0;
+
+ /**
+ * @return the default host to use for connections
+ */
+ virtual std::string getHost() const = 0;
+
+ /**
+ * @brief Set the default host for connections
+ * @param host the default host for connections
+ */
+ virtual void setHost(const std::string& host) = 0;
+
+ /**
+ * @return the default port to use for connections
+ */
+ virtual uint32 getPort() const = 0;
+
+ /**
+ * @brief Set the default port for connections
+ * @param port the default port for connections
+ */
+ virtual void setPort(const uint32 port) = 0;
+
+ /**
+ * @return the default virtual host to use for connections
+ */
+ virtual std::string getVirtualHost() const = 0;
+
+ /**
+ * @brief Set the default virtual host for connections
+ * @param virtualHost the default virtual host for connections
+ */
+ virtual void setVirtualHost(const std::string& virtualHost) = 0;
+
+ /**
+ * @return the default user name to use for connections
+ */
+ virtual std::string getUsername() const = 0;
+
+ /**
+ * @brief Set the default user name for connections
+ * @param username the default user name for connections
+ */
+ virtual void setUsername(const std::string& username) = 0;
+
+ /**
+ * @return the default password to use for connections
+ */
+ virtual std::string getPassword() const = 0;
+
+ /**
+ * @brief Set the default password for connections
+ * @param password the default password for connections
+ */
+ virtual void setPassword(const std::string& password) = 0;
+
+ /**
+ * @return the default CaCertPath to use for connections
+ */
+ virtual std::string getCaCertPath() const = 0;
+
+ /**
+ * @brief Set the default CaCertPath for connections
+ * @param caCertPath the default CaCertPath for connections
+ */
+ virtual void setCaCertPath(const std::string& caCertPath) = 0;
+
+ /**
+ * @return the default ClientCertPath to use for connections
+ */
+ virtual std::string getClientCertPath() const = 0;
+
+ /**
+ * @brief Set the default ClientCertPath for connections
+ * @param clientCertPath the default ClientCertPath for connections
+ */
+ virtual void setClientCertPath(const std::string& clientCertPath) = 0;
+
+ /**
+ * @return the default ClientKeyPath to use for connections
+ */
+ virtual std::string getClientKeyPath() const = 0;
+
+ /**
+ * @brief Set the default ClientKeyPath for connections
+ * @param clientKeyPath the default ClientKeyPath for connections
+ */
+ virtual void setClientKeyPath(const std::string& clientKeyPath) = 0;
+
+ /**
+ * @return the initially requested maximum channel number; zero for unlimited
+ */
+ virtual uint32 getRequestedChannelMax() const = 0;
+
+ /**
+ * @brief Set the requested maximum channel number
+ * @param requestedChannelMax the initially requested maximum channel number; zero for unlimited
+ */
+ virtual void setRequestedChannelMax(const uint32 requestedChannelMax) = 0;
+
+ /**
+ * @return the initially requested maximum frame size; zero for unlimited
+ */
+ virtual uint32 getRequestedFrameMax() const = 0;
+
+ /**
+ * @brief Set the requested maximum frame size
+ * @param requestedFrameMax the initially requested maximum frame size; zero for unlimited
+ */
+ virtual void setRequestedFrameMax(const uint32 requestedFrameMax) = 0;
+
+ /**
+ * @return the initially requested heartbeat interval, in seconds; zero for none
+ */
+ virtual uint32 getRequestedHeartbeat() const = 0;
+
+ /**
+ * @brief Set the requested heartbeat interval
+ * @param requestedHeartbeat the initially requested heartbeat interval, in seconds; zero for none
+ */
+ virtual void setRequestedHeartbeat(const uint32 requestedHeartbeat) = 0;
+
+ /**
+ * @return the connection timeout, in milliseconds; zero for infinite
+ */
+ virtual uint32 getConnectionTimeout() const = 0;
+
+ /**
+ * @brief Set the connection timeout
+ * @param connectionTimeout connection establishment timeout in milliseconds; zero for infinite
+ */
+ virtual void setConnectionTimeout(const uint32 connectionTimeout) = 0;
+
+ /**
+ * @return the number of connection consumer processing threads
+ */
+ virtual uint32 getConsumerThreadCount() const = 0;
+
+ /**
+ * @brief Set the number of connection consumer processing threads
+ * @param threadCount the number of connection consumer processing threads
+ */
+ virtual void setConsumerThreadCount(const uint32 threadCount) = 0;
+
+ /**
+ * @return the number of connection retries
+ */
+ virtual uint16 getRetries() const = 0;
+
+ /**
+ * @brief Set the number of connection retries
+ * @param retries the number of connection retries
+ */
+ virtual void setRetries(const uint16 retries) = 0;
+
+ /**
+ * @return the number of connection seconds to wait
+ */
+ virtual uint16 getSecondsToWait() const = 0;
+
+ /**
+ * @brief Set the number of connection retries
+ * @param seconds the number of connection seconds to wait
+ */
+ virtual void setSecondsToWait(const uint16 seconds) = 0;
+
+ /**
+ * @brief Create a new broker connection
+ * @return a #Caf::AmqpClient::Connection interface to the connection
+ */
+ virtual SmartPtrConnection newConnection() = 0;
+
+ /**
+ * @brief Create a new broker connection
+ * @param address broker address to try
+ * @return a #Caf::AmqpClient::Connection interface to the connection
+ */
+ virtual SmartPtrConnection newConnection(
+ const SmartPtrAddress& address,
+ const SmartPtrCertInfo& certInfo) = 0;
+};
+
+CAF_DECLARE_SMART_INTERFACE_POINTER(ConnectionFactory);
+
+/**
+ * @ingroup AmqpApi
+ * @brief Create a new #Caf::AmqpClient::ConnectionFactory
+ * @return a #Caf::AmqpClient::ConnectionFactory interface to a new connection factory
+ */
+SmartPtrConnectionFactory AMQPCLIENT_LINKAGE createConnectionFactory();
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: May 21, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CONSUMER_H_
+#define CONSUMER_H_
+
+#include "ICafObject.h"
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Exception/CCafException.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/api/Envelope.h"
+#include "amqpClient/api/AmqpContentHeaders.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApi
+ * @brief Interface for application callback objects to receive notifications and messages
+ * from a queue by subscription.
+ * <p>
+ * The methods of this interface are invoked in a dispatch thread which is separate from the
+ * {@link Connection}'s thread. This allows {@link Consumer}s to call {@link Channel} or
+ * {@link Connection} methods without causing a deadlock.
+ */
+struct __declspec(novtable) Consumer : public ICafObject {
+
+ /**
+ * @brief Called when the consumer is registered by a call to any of the
+ * {@link Channel#basicConsume} methods
+ * @param consumerTag the <i>consumer tag</i> associated with the consumer
+ */
+ virtual void handleConsumeOk(
+ const std::string& consumerTag) = 0;
+
+ /**
+ * @brief Called when the consumer is cancelled by a call to {@link Channel#basicCancel}.
+ * @param consumerTag the <i>consumer tag</i> associated with the consumer
+ */
+ virtual void handleCancelOk(
+ const std::string& consumerTag) = 0;
+
+ /**
+ * @brief Called when a <code><b>basic.recover-ok</b></code> is received.
+ * @param consumerTag the <i>consumer tag</i> associated with the consumer
+ */
+ virtual void handleRecoverOk(
+ const std::string& consumerTag) = 0;
+
+ /**
+ * @brief Called when a <code><b>basic.deliver</b></code> is received for this consumer.
+ * @param consumerTag the <i>consumer tag</i> associated with the consumer
+ * @param envelope message envelope
+ * @param properties message properties and headers
+ * @param body message body
+ */
+ virtual void handleDelivery(
+ const std::string& consumerTag,
+ const SmartPtrEnvelope& envelope,
+ const AmqpContentHeaders::SmartPtrBasicProperties& properties,
+ const SmartPtrCDynamicByteArray& body) = 0;
+
+ /**
+ * @brief Called when the channel has been shut down.
+ * @param consumerTag the <i>consumer tag</i> associated with the consumer
+ * @param reason the reason for the shut down
+ */
+ virtual void handleShutdown(
+ const std::string& consumerTag,
+ SmartPtrCCafException& reason) = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(Consumer);
+
+}}
+
+#endif /* CONSUMER_H_ */
--- /dev/null
+/*
+ * Created on: May 11, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENTAPI_CONTENTHEADER_H_
+#define AMQPCLIENTAPI_CONTENTHEADER_H_
+
+
+#include "ICafObject.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApi
+ * @brief Base interface for all AMQP content headers
+ */
+struct __declspec(novtable) ContentHeader : public ICafObject {
+
+ /** @return the content header class id */
+ virtual uint16 getClassId() = 0;
+
+ /** @return the content header friendly class name */
+ virtual std::string getClassName() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(ContentHeader);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: May 16, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENTAPI_ENVELOPE_H_
+#define AMQPCLIENTAPI_ENVELOPE_H_
+
+
+#include "ICafObject.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApi
+ * @brief An interface to objects that group together basic.get-ok message properties
+ */
+struct __declspec(novtable) Envelope : public ICafObject {
+ CAF_DECL_UUID("ce68d68a-6973-49e2-a003-cb4474624f5c")
+
+ /** @return the delivery tag */
+ virtual uint64 getDeliveryTag() = 0;
+
+ /**
+ * @retval <code><b>true</b></code> if the message was redelivered
+ * @retval <code><b>false</b></code> if the message has not been redelivered
+ */
+ virtual bool getRedelivered() = 0;
+
+ /** @return the name of the exchange supplying the message */
+ virtual std::string getExchange() = 0;
+
+ /** @return the message's routing key */
+ virtual std::string getRoutingKey() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(Envelope);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: May 16, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENTAPI_GETRESPONSE_H_
+#define AMQPCLIENTAPI_GETRESPONSE_H_
+
+#include "ICafObject.h"
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/api/Envelope.h"
+#include "amqpClient/api/AmqpContentHeaders.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApi
+ * @brief Interface representing the bundling of basic.get messages into a nicer form
+ */
+struct __declspec(novtable) GetResponse : public ICafObject {
+ CAF_DECL_UUID("c8bda284-7eea-46e1-b9c3-791310d69b04")
+
+ /** @return the message envelope information (#Caf::AmqpClient::Envelope) */
+ virtual SmartPtrEnvelope getEnvelope() = 0;
+
+ /** @return the message properties (#Caf::AmqpClient::AmqpContentHeaders::BasicProperties) */
+ virtual AmqpContentHeaders::SmartPtrBasicProperties getProperties() = 0;
+
+ /** @return the message body raw bytes */
+ virtual SmartPtrCDynamicByteArray getBody() = 0;
+
+ /** @return the number of messages in the queue */
+ virtual uint32 getMessageCount() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(GetResponse);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: May 10, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENTAPI_METHOD_H_
+#define AMQPCLIENTAPI_METHOD_H_
+
+
+#include "ICafObject.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApi
+ * @brief Base interface to AMQP methods
+ */
+struct __declspec(novtable) Method : public ICafObject {
+
+ /** @return the method's class ID */
+ virtual uint16 getProtocolClassId() = 0;
+
+ /** @return the method's method ID */
+ virtual uint16 getProtocolMethodId() = 0;
+
+ /** @return the method's friendly name */
+ virtual std::string getProtocolMethodName() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(Method);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: May 21, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef RETURNLISTENER_H_
+#define RETURNLISTENER_H_
+
+#include "ICafObject.h"
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/api/AmqpContentHeaders.h"
+
+namespace Caf { namespace AmqpClient {
+
+/**
+ * @author mdonahue
+ * @ingroup AmqpApi
+ * @brief Interface for objects that will be notified of failed message deliveries
+ * <p>
+ * When {@link Channel#basicPublish} is used with the <i>mandatory</i> and/or <i>immediate</i>
+ * flags set and the message cannot be delivered, the server will response with a
+ * <code><b>basic.return</b></code> method call. {@link ReturnListener}s can monitor
+ * these failed messages.
+ */
+struct __declspec(novtable) ReturnListener : public ICafObject {
+ CAF_DECL_UUID("FEB38A27-6338-4BDB-AA0E-527322A2393B")
+
+ /**
+ * @brief Callback receiving the failed message
+ * @param replyCode server reply code
+ * @param replyText server reply text
+ * @param exchange exchange on which error occured
+ * @param routingKey routing key for the message that failed
+ * @param properties original message properties
+ * @param body original message body
+ */
+ virtual void handleReturn(
+ const uint16 replyCode,
+ const std::string& replyText,
+ const std::string& exchange,
+ const std::string& routingKey,
+ const AmqpContentHeaders::SmartPtrBasicProperties& properties,
+ const SmartPtrCDynamicByteArray& body) = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(ReturnListener);
+
+}}
+
+#endif /* RETURNLISTENER_H_ */
--- /dev/null
+/*
+ * Created on: May 3, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPCLIENTAPI_H_
+#define AMQPCLIENTAPI_H_
+
+#include "amqpClient/AmqpClientLink.h"
+#include "ICafObject.h"
+
+/**
+ * @defgroup AmqpApi AMQP API
+ * Documentaiton for the classes, methods and constants that can be
+ * used directly by applications to work with the AMQP protocol as a client.
+ */
+namespace Caf { namespace AmqpClient {
+
+/** Default user name */
+extern const char* DEFAULT_USER;
+
+/** Default password */
+extern const char* DEFAULT_PASS;
+
+/** Default virtual host */
+extern const char* DEFAULT_VHOST;
+
+/** Default protocol */
+extern const char* DEFAULT_PROTOCOL;
+
+/** Default host */
+extern const char* DEFAULT_HOST;
+
+/** Default maximum channel number; zero for maximum */
+static const uint32 DEFAULT_CHANNEL_MAX = 0;
+
+/** Default maximum frame size; zero for maximum */
+static const uint32 DEFAULT_FRAME_MAX = 131072;
+
+/** Default maximum heartbeat rate; zero for none */
+static const uint32 DEFAULT_HEARTBEAT = 0;
+
+/** 'Use the default port' port */
+static const uint32 USE_DEFAULT_PORT = UINT_MAX;
+
+/** The default non-ssl port */
+static const uint32 DEFAULT_AMQP_PORT = 5672;
+
+/** The default ssl port */
+static const uint32 DEFAULT_AMQP_SSL_PORT = 5671;
+
+/** The default connection timeout; zero means wait indefinately */
+static const uint32 DEFAULT_CONNECTION_TIMEOUT = 0;
+
+/** The default number of connection consumer threads */
+static const uint32 DEFAULT_CONSUMER_THREAD_COUNT = 10;
+
+/** The default number of basic.deliver messages to process in a single run of a channel consumer thread */
+static const uint32 DEFAULT_CONSUMER_THREAD_MAX_DELIVERY_COUNT = 100;
+
+/** The default number of times a connection open will be retried*/
+static const uint16 DEFAULT_CONNECTION_RETRIES = 5;
+
+/** The default number of seconds we will wait for each connection open attempt. 0 means wait indefinitely*/
+static const uint16 DEFAULT_CONNECTION_SECONDS_TO_WAIT = 30;
+
+/**
+ * @author mdonahue
+ * @brief Object that maps a c-api AMQP field into a lifetime-managed GVariant
+ */
+struct __declspec(novtable) Field : public ICafObject {
+ /**
+ * @brief Field value types
+ */
+ typedef enum {
+ /** @brief internal value representing Not Set */
+ AMQP_FIELD_TYPE_NOTSET,
+ /** @brief boolean */
+ AMQP_FIELD_TYPE_BOOLEAN,
+ /** @brief signed 8-bit integer */
+ AMQP_FIELD_TYPE_I8,
+ /** @brief unsigned 8-bit integer */
+ AMQP_FIELD_TYPE_U8,
+ /** @brief signed 16-bit integer */
+ AMQP_FIELD_TYPE_I16,
+ /** @brief unsigned 16-bit integer */
+ AMQP_FIELD_TYPE_U16,
+ /** @brief signed 32-bit integer */
+ AMQP_FIELD_TYPE_I32,
+ /** @brief unsigned 32-bit integer */
+ AMQP_FIELD_TYPE_U32,
+ /** @brief signed 64-bit integer */
+ AMQP_FIELD_TYPE_I64,
+ /** @brief unsigned 64-bit integer */
+ AMQP_FIELD_TYPE_U64,
+ /** @brief 32-bit float */
+ AMQP_FIELD_TYPE_F32,
+ /** @brief 64-bit double */
+ AMQP_FIELD_TYPE_F64,
+ /** @brief UTF8-encoded text */
+ AMQP_FIELD_TYPE_UTF8,
+ /** @brief NOT SUPPORTED */
+ AMQP_FIELD_TYPE_ARRAY,
+ /** @brief NOT SUPPORTED */
+ AMQP_FIELD_TYPE_BYTES,
+ /** @brief NOT SUPPORTED */
+ AMQP_FIELD_TYPE_DECIMAL,
+ /** @brief NOT SUPPORTED */
+ AMQP_FIELD_TYPE_TIMESTAMP,
+ /** @brief NOT SUPPORTED */
+ AMQP_FIELD_TYPE_TABLE,
+ /** @brief NOT SUPPORTED */
+ AMQP_FIELD_TYPE_VOID
+ } AmqpFieldType;
+
+ /**
+ * @return the field type
+ */
+ virtual AmqpFieldType getAmqpType() const = 0;
+ /**
+ * @return the field value as a GVariant
+ */
+ virtual GVariant* getValue() const = 0;
+ /**
+ * @brief Set the field type and value
+ * @param type field type
+ * @param value field value. <code><b>DO NOT increment the reference count
+ * before calling this method.</b></code> This object will take ownership of
+ * the GVariant and will call g_variant_unref upon value reassignment or destruction.
+ */
+ virtual void setTypeAndValue(AmqpFieldType type, GVariant *value) = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(Field);
+/** @brief A map of field names to field objects */
+typedef std::map<std::string, SmartPtrField> Table;
+CAF_DECLARE_SMART_POINTER(Table);
+
+/**
+ * @brief Add a boolean value to a field table
+ * @param key the field key
+ * @param val the value
+ * @param table the table to insert the field into
+ */
+void AMQPCLIENT_LINKAGE tableAddBoolean(
+ const std::string key,
+ const bool val,
+ SmartPtrTable& table);
+
+/**
+ * @brief Add a signed 8-bit value to a field table
+ * @param key the field key
+ * @param val the value
+ * @param table the table to insert the field into
+ */
+void AMQPCLIENT_LINKAGE tableAddInt8(
+ const std::string key,
+ const int8 val,
+ SmartPtrTable& table);
+
+/**
+ * @brief Add a unsigned 8-bit value to a field table
+ * @param key the field key
+ * @param val the value
+ * @param table the table to insert the field into
+ */
+void AMQPCLIENT_LINKAGE tableAddUint8(
+ const std::string key,
+ const uint8 val,
+ SmartPtrTable& table);
+
+/**
+ * @brief Add a signed 16-bit value to a field table
+ * @param key the field key
+ * @param val the value
+ * @param table the table to insert the field into
+ */
+void AMQPCLIENT_LINKAGE tableAddInt16(
+ const std::string key,
+ const int16 val,
+ SmartPtrTable& table);
+
+/**
+ * @brief Add a unsigned 16-bit value to a field table
+ * @param key the field key
+ * @param val the value
+ * @param table the table to insert the field into
+ */
+void AMQPCLIENT_LINKAGE tableAddUint16(
+ const std::string key,
+ const uint16 val,
+ SmartPtrTable& table);
+
+/**
+ * @brief Add a signed 32-bit value to a field table
+ * @param key the field key
+ * @param val the value
+ * @param table the table to insert the field into
+ */
+void AMQPCLIENT_LINKAGE tableAddInt32(
+ const std::string key,
+ const int32 val,
+ SmartPtrTable& table);
+
+/**
+ * @brief Add a unsigned 32-bit value to a field table
+ * @param key the field key
+ * @param val the value
+ * @param table the table to insert the field into
+ */
+void AMQPCLIENT_LINKAGE tableAddUint32(
+ const std::string key,
+ const uint32 val,
+ SmartPtrTable& table);
+
+/**
+ * @brief Add a signed 64-bit value to a field table
+ * @param key the field key
+ * @param val the value
+ * @param table the table to insert the field into
+ */
+void AMQPCLIENT_LINKAGE tableAddInt64(
+ const std::string key,
+ const int64 val,
+ SmartPtrTable& table);
+
+/**
+ * @brief Add a unsigned 64-bit value to a field table
+ * @param key the field key
+ * @param val the value
+ * @param table the table to insert the field into
+ */
+void AMQPCLIENT_LINKAGE tableAddUint64(
+ const std::string key,
+ const uint64 val,
+ SmartPtrTable& table);
+
+/**
+ * @brief Add a float value to a field table
+ * @param key the field key
+ * @param val the value
+ * @param table the table to insert the field into
+ */
+void AMQPCLIENT_LINKAGE tableAddFloat(
+ const std::string key,
+ const float val,
+ SmartPtrTable& table);
+
+/**
+ * @brief Add a double value to a field table
+ * @param key the field key
+ * @param val the value
+ * @param table the table to insert the field into
+ */
+void AMQPCLIENT_LINKAGE tableAddDouble(
+ const std::string key,
+ const double val,
+ SmartPtrTable& table);
+
+/**
+ * @brief Add UTF8-encoded text to a field table
+ * @param key the field key
+ * @param val the value
+ * @param table the table to insert the field into
+ */
+void AMQPCLIENT_LINKAGE tableAddUtf8(
+ const std::string key,
+ const std::string& val,
+ SmartPtrTable& table);
+
+/**
+ * @brief Add a time stamp (unsigned 64-bit integer) to a field table
+ * @param key the field key
+ * @param val the value
+ * @param table the table to insert the field into
+ */
+void AMQPCLIENT_LINKAGE tableAddTimestamp(
+ const std::string key,
+ const uint64 val,
+ SmartPtrTable& table);
+}}
+
+#include "amqpClient/api/AMQExceptions.h"
+
+#endif
--- /dev/null
+/*
+ * Created on: May 24, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_ABSTRACTCONNECTIONFACTORY_H_
+#define AMQPINTEGRATIONCORE_ABSTRACTCONNECTIONFACTORY_H_
+
+#include "amqpCore/ConnectionFactory.h"
+#include "amqpClient/api/ConnectionFactory.h"
+#include "amqpClient/api/Connection.h"
+#include "amqpCore/CompositeConnectionListener.h"
+#include "amqpCore/ConnectionListener.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+class AMQPINTEGRATIONCORE_LINKAGE AbstractConnectionFactory : public ConnectionFactory {
+public:
+ AbstractConnectionFactory();
+ virtual ~AbstractConnectionFactory();
+
+ /**
+ * @brief Initialize the connection factory
+ * @param amqpConnectionFactory the underlying Caf::AmqpClient::ConnectionFactory object
+ */
+ void init(const AmqpClient::SmartPtrConnectionFactory& amqpConnectionFactory);
+
+ virtual void setConnectionListeners(const std::deque<SmartPtrConnectionListener>& listeners);
+
+ /**
+ * @brief Set the default protocol for connections
+ * @param protocol the default protocol for connections
+ */
+ void setProtocol(const std::string& protocol);
+
+ /**
+ * @brief Set the default host for connections
+ * @param host the default host for connections
+ */
+ void setHost(const std::string& host);
+
+ /**
+ * @brief Set the default port for connections
+ * @param port the default port for connections
+ */
+ void setPort(const uint32 port);
+
+ /**
+ * @brief Set the default host for connections
+ * @param virtualHost the default host for connections
+ */
+ void setVirtualHost(const std::string& virtualHost);
+
+ /**
+ * @brief Set the default user name for connections
+ * @param username the default user name for connections
+ */
+ void setUsername(const std::string& username);
+
+ /**
+ * @brief Set the default password for connections
+ * @param password the default password for connections
+ */
+ void setPassword(const std::string& password);
+
+ /**
+ * @brief Set the default CaCertPath for connections
+ * @param caCertPath the default CaCertPath for connections
+ */
+ void setCaCertPath(const std::string& caCertPath);
+
+ /**
+ * @brief Set the default ClientCertPath for connections
+ * @param clientCertPath the default ClientCertPath for connections
+ */
+ void setClientCertPath(const std::string& clientCertPath);
+
+ /**
+ * @brief Set the default ClientKeyPath for connections
+ * @param clientKeyPath the default ClientKeyPath for connections
+ */
+ void setClientKeyPath(const std::string& clientKeyPath);
+
+ /**
+ * @brief Set the number of connection retries
+ * @param retries
+ */
+ void setRetries(const uint16 retries);
+
+ /**
+ * @brief Set the wait period in seconds
+ * @param seconds
+ */
+ void setSecondsToWait(const uint16 seconds);
+
+ /**
+ * @brief Set the connection timeout
+ * @param connectionTimeout connection establishment timeout in milliseconds; zero for infinite
+ */
+ void setConnectionTimeout(const uint32 connectionTimeout);
+
+public: // ConnectionFactory
+ virtual SmartPtrConnection createConnection() = 0;
+ std::string getProtocol();
+ std::string getHost();
+ uint32 getPort();
+ std::string getVirtualHost();
+ std::string getUsername();
+ std::string getPassword();
+ std::string getCaCertPath();
+ std::string getClientCertPath();
+ std::string getClientKeyPath();
+ uint16 getRetries();
+ uint16 getSecondsToWait();
+ virtual void addConnectionListener(const SmartPtrConnectionListener& listener);
+
+protected:
+ std::string getDefaultProtocol();
+
+ std::string getDefaultHostName();
+
+ SmartPtrConnection createBareConnection();
+
+ SmartPtrConnectionListener getConnectionListener();
+
+private:
+ bool _isInitialized;
+ AmqpClient::SmartPtrConnectionFactory _amqpConnectionFactory;
+ SmartPtrCompositeConnectionListener _connectionListener;
+
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(AbstractConnectionFactory);
+};
+CAF_DECLARE_SMART_POINTER(AbstractConnectionFactory);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: Jun 12, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_AMQPADMIN_H_
+#define AMQPINTEGRATIONCORE_AMQPADMIN_H_
+
+
+
+#include "ICafObject.h"
+
+#include "amqpCore/Binding.h"
+#include "amqpCore/Exchange.h"
+#include "amqpCore/Queue.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @brief Specifies a basic set of AMQP administrative operations for AMQP > 0.8
+ */
+struct __declspec(novtable) AmqpAdmin : public ICafObject {
+ CAF_DECL_UUID("B10A94BC-0CC7-476F-A38A-2794CF98D74C")
+
+ /**
+ * @brief Declare an exchange
+ * @param exchange the exchange (#Caf::AmqpIntegration::Exchange) to declare
+ */
+ virtual void declareExchange(SmartPtrExchange exchange) = 0;
+
+ /**
+ * @brief Delete an exchange
+ * @param exchange the name of the exchange
+ * @retval true the exchange existed and was deleted
+ * @retval false the exchange did not exists or could not be deleted
+ */
+ virtual bool deleteExchange(const std::string& exchange) = 0;
+
+ /**
+ * @brief Declare a queue whose name is automatically generated.
+ * <p>
+ * The queue is created with durable=false, exclusive=true and auto-delete=true.
+ * @return the created queue. Call #Caf::AmqpIntegration::Queue::getName to
+ * get the server-generated name of the queue.
+ */
+ virtual SmartPtrQueue declareQueue() = 0;
+
+ /**
+ * @brief Declare a queue
+ * @param queue the queue to declare
+ */
+ virtual void declareQueue(SmartPtrQueue queue) = 0;
+
+ /**
+ * @brief Delete a queue without regard for whether it is in use or has messages in it
+ * @param queue the name of the queue
+ * @retval true the queue existed and was deleted
+ * @retval false the queue did not exist or could not be deleted
+ */
+ virtual bool deleteQueue(const std::string& queue) = 0;
+
+ /**
+ * @brief Delete a queue
+ * @param queue the name of the queue
+ * @param unused <b>true</b> if the queue should be deleted only if not in use
+ * @param empty <b>true</b> if the queue shoudl be deleted only if empty
+ */
+ virtual void deleteQueue(
+ const std::string& queue,
+ const bool unused,
+ const bool empty) = 0;
+
+ /**
+ * @brief Purges the contents of a queue
+ * @param queue the name of the queue
+ */
+ virtual void purgeQueue(const std::string& queue) = 0;
+
+ /**
+ * @brief Declare a binding of a queue to an exchange
+ * @param binding the binding information
+ */
+ virtual void declareBinding(SmartPtrBinding binding) = 0;
+
+ /**
+ * @brief Remove a binding of a queue to an exchange
+ * @param binding the binding information
+ */
+ virtual void removeBinding(SmartPtrBinding binding) = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(AmqpAdmin);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: Jun 6, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_AMQPHEADERMAPPER_H_
+#define AMQPINTEGRATIONCORE_AMQPHEADERMAPPER_H_
+
+
+#include "ICafObject.h"
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Integration/IIntMessage.h"
+#include "amqpClient/api/Envelope.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @brief This interface is used by objects that map AMQP headers to integration message
+ * headers and vice versa.
+ */
+struct __declspec(novtable) AMQPINTEGRATIONCORE_LINKAGE
+AmqpHeaderMapper : public ICafObject {
+ CAF_DECL_UUID("5A292DD4-C3CC-4556-9809-90027C13EFA5")
+
+ /*
+ * @brief Return the collection of AMQP headers from an integration message.
+ * @param headers the integration message headers
+ * @return the AMQP headers
+ */
+ virtual AmqpClient::AmqpContentHeaders::SmartPtrBasicProperties
+ fromHeaders(IIntMessage::SmartPtrCHeaders headers) = 0;
+
+ /**
+ * @brief Return the collection of integration message headers from an AMQP message.
+ * @param properties the AMQP message properties (#Caf::AmqpClient::AmqpContentHeaders::BasicProperties).
+ * @param envelope the AMQP message envelope (#Caf::AmqpClient::Envelope).
+ * @return the filtered set of headers as integration message headers
+ */
+ virtual IIntMessage::SmartPtrCHeaders
+ toHeaders(
+ AmqpClient::AmqpContentHeaders::SmartPtrBasicProperties properties,
+ AmqpClient::SmartPtrEnvelope envelope) = 0;
+
+ /**
+ * @brief Return the filtered collection of integration message headers from an integration message.
+ * @param headers the input set of message headers
+ * @return the filtered set of headers as integration message headers
+ */
+ virtual IIntMessage::SmartPtrCHeaders
+ filterHeaders(
+ IIntMessage::SmartPtrCHeaders headers) = 0;
+
+ /** @brief AMQP header prefix */
+ static const std::string PREFIX;
+
+ /** @brief AMQP application id header */
+ static const std::string APP_ID;
+
+ /** @brief AMQP cluster id header */
+ static const std::string CLUSTER_ID;
+
+ /** @brief AMQP content encoding header */
+ static const std::string CONTENT_ENCODING;
+
+ /** @brief AMQP content length hedaer */
+ static const std::string CONTENT_LENGTH;
+
+ /** @brief AMQP content type header */
+ static const std::string CONTENT_TYPE;
+
+ /** @brief AMQP correlation id header */
+ static const std::string CORRELATION_ID;
+
+ /** @brief AMQP delivery mode header */
+ static const std::string DELIVERY_MODE;
+
+ /** @brief AMQP delivery tag header */
+ static const std::string DELIVERY_TAG;
+
+ /** @brief AMQP expiration header */
+ static const std::string EXPIRATION;
+
+ /** @brief AMQP message count header */
+ static const std::string MESSAGE_COUNT;
+
+ /** @brief AMQP message id header */
+ static const std::string MESSAGE_ID;
+
+ /** @brief AMQP received exchange header */
+ static const std::string RECEIVED_EXCHANGE;
+
+ /** @brief AMQP routing key header */
+ static const std::string RECEIVED_ROUTING_KEY;
+
+ /** @brief AMQP redelivered header */
+ static const std::string REDELIVERED;
+
+ /** @brief AMQP reply to header */
+ static const std::string REPLY_TO;
+
+ /** @brief AMQP timestamp header */
+ static const std::string TIMESTAMP;
+
+ /** @brief AMQP type header */
+ static const std::string TYPE;
+
+ /** @brief AMQP user id header */
+ static const std::string USER_ID;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(AmqpHeaderMapper);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: Aug 7, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AmqpMessageListenerSource_h
+#define AmqpMessageListenerSource_h
+
+#include "Integration/Dependencies/CPollerMetadata.h"
+#include "Integration/IIntMessage.h"
+#include "amqpCore/AmqpHeaderMapper.h"
+#include "amqpCore/MessageListener.h"
+#include "Integration/Core/CAbstractPollableChannel.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+class AMQPINTEGRATIONCORE_LINKAGE AmqpMessageListenerSource :
+ public CAbstractPollableChannel,
+ public MessageListener {
+public:
+ AmqpMessageListenerSource();
+ virtual ~AmqpMessageListenerSource();
+
+ void init(
+ const SmartPtrAmqpHeaderMapper& headerMapper,
+ const SmartPtrCPollerMetadata& pollerMetadata);
+
+public: // MessageListener
+ void onMessage(const SmartPtrIIntMessage& message);
+
+private: // CAbstractPollableChannel
+ bool doSend(
+ const SmartPtrIIntMessage& message,
+ int32 timeout);
+
+ SmartPtrIIntMessage doReceive(const int32 timeout);
+
+private:
+ static void QueueItemDestroyFunc(gpointer data);
+
+private:
+ bool _isInitialized;
+ std::string _id;
+ GAsyncQueue *_messageQueue;
+ SmartPtrAmqpHeaderMapper _headerMapper;
+
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(AmqpMessageListenerSource);
+};
+CAF_DECLARE_SMART_POINTER(AmqpMessageListenerSource);
+
+}}
+
+#endif /* AmqpMessageListenerSource_h */
--- /dev/null
+/*
+ * Created on: Jul 16, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_AMQPOUTBOUNDENDPOINT_H_
+#define AMQPINTEGRATIONCORE_AMQPOUTBOUNDENDPOINT_H_
+
+
+
+#include "Integration/IMessageHandler.h"
+
+#include "Common/IAppConfig.h"
+#include "Common/IAppContext.h"
+#include "Integration/Core/CExpressionHandler.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "amqpCore/AmqpHeaderMapper.h"
+#include "amqpCore/AmqpTemplate.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @ingroup IntObjImpl
+ * @brief Adapter that converts and sends Messages to an AMQP exchange
+ */
+class AMQPINTEGRATIONCORE_LINKAGE AmqpOutboundEndpoint : public IMessageHandler {
+ CAF_BEGIN_QI()
+ CAF_QI_ENTRY(IMessageHandler)
+ CAF_END_QI()
+
+public:
+ AmqpOutboundEndpoint();
+ virtual ~AmqpOutboundEndpoint();
+
+ /**
+ * @brief Initialize this object
+ * @param amqpTemplate the #Caf::AmqpIntegration::AmqpTemplate used to
+ * send and receive messages
+ * @param appConfig the application configuration object
+ * @param appContext the application context object
+ */
+ void init(
+ SmartPtrAmqpTemplate amqpTemplate,
+ SmartPtrIAppConfig appConfig,
+ SmartPtrIAppContext appContext);
+
+ /**
+ * @brief Set the name of the AMQP exchange
+ * @param exchangeName the name of the exchange
+ */
+ void setExchangeName(const std::string& exchangeName);
+
+ /**
+ * @brief Set the name of the AMQP exchange as an expression of message information
+ * @param exchangeNameExpression the exchange name expression
+ */
+ void setExchangeNameExpression(const std::string& exchangeNameExpression);
+
+ /**
+ * @brief Set the routing key
+ * @param routingKey the routing key
+ */
+ void setRoutingKey(const std::string& routingKey);
+
+ /**
+ * @brief Set the routing key as an expression of message information
+ * @param routingKeyExpression the routing key expression
+ */
+ void setRoutingKeyExpression(const std::string& routingKeyExpression);
+
+ /**
+ * @brief Set the regular expression mapping of headers to send along with the message
+ * <p>
+ * AMQP headers (amqp_XXXX) are always automatically mapped to their AMQP
+ * BasicProperties counterparts. This expression controls which additional headers
+ * are sent along with the message.
+ * @param expression header mapping expression
+ */
+ void setMappedRequestHeadersExpression(const std::string& expression);
+
+ /**
+ * @brief Set the expects reply flag.
+ * @param expectReply <b>true</b> if a reply is expected else <b>false</b>
+ */
+ void setExpectReply(const bool expectReply);
+
+ /**
+ * @brief Set the requires reply flag.
+ * @param requiresReply <b>true</b> if a reply is required else <b>false</b>
+ */
+ void setRequiresReply(const bool requiresReply);
+
+ /**
+ * @brief Set the friendly name of this instance.
+ * @param name the instance name
+ */
+ void setComponentName(const std::string& name);
+
+ /**
+ * @brief Set the channel resolver object
+ * @param channelResolver the channel resolver
+ */
+ void setChannelResolver(SmartPtrIChannelResolver channelResolver);
+
+public: // IMessageHandler
+ UUID getHandlerId() const;
+
+ void handleMessage(const SmartPtrIIntMessage& message);
+
+ SmartPtrIIntMessage getSavedMessage() const;
+
+ void clearSavedMessage();
+
+private:
+ SmartPtrIIntMessage handleRequestMessage(SmartPtrIIntMessage requestMessage);
+
+ void handleResult(
+ SmartPtrIIntMessage resultMessage,
+ IIntMessage::SmartPtrCHeaders requestHeaders);
+
+ void send(
+ const std::string& exchangeName,
+ const std::string& routingKey,
+ SmartPtrIIntMessage requestMessage);
+
+ SmartPtrIIntMessage sendAndReceive(
+ const std::string& exchangeName,
+ const std::string& routingKey,
+ SmartPtrIIntMessage requestMessage);
+
+ SmartPtrIIntMessage createReplyMessage(
+ SmartPtrIIntMessage reply,
+ IIntMessage::SmartPtrCHeaders requestHeaders);
+
+ void sendReplyMessage(
+ SmartPtrIIntMessage reply,
+ const std::string& replyChannelHeaderValue);
+
+private:
+ bool _isInitialized;
+ UUID _id;
+ std::string _componentName;
+ SmartPtrAmqpTemplate _amqpTemplate;
+ bool _expectReply;
+ bool _requiresReply;
+ std::string _exchangeName;
+ std::string _exchangeNameExpression;
+ std::string _routingKey;
+ std::string _routingKeyExpression;
+ std::string _requestHeaderMapperExpression;
+ SmartPtrIChannelResolver _channelResolver;
+ SmartPtrIMessageChannel _outputChannel;
+ SmartPtrCExpressionHandler _exchangeNameHandler;
+ SmartPtrCExpressionHandler _routingKeyHandler;
+ SmartPtrAmqpHeaderMapper _requestHeaderMapper;
+ SmartPtrAmqpHeaderMapper _responseHeaderMapper;
+
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(AmqpOutboundEndpoint);
+};
+CAF_DECLARE_SMART_QI_POINTER(AmqpOutboundEndpoint);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: May 25, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_AMQPTEMPLATE_H_
+#define AMQPINTEGRATIONCORE_AMQPTEMPLATE_H_
+
+
+
+#include "ICafObject.h"
+
+#include "Integration/IIntMessage.h"
+#include "amqpClient/api/Channel.h"
+#include "amqpCore/AmqpHeaderMapper.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @brief Specifies a basic set of AMQP operations.
+ * <p>
+ * Provides synchronous send and receive methods as well as a generic executor
+ * through a callback to a provided object.
+ */
+struct __declspec(novtable) AmqpTemplate : public ICafObject {
+ CAF_DECL_UUID("B79DDF8E-B302-4576-9D96-DC413C76392C")
+
+ /**
+ * @brief Send a message to a default exchange with a default routing key.
+ * @param message a message to send
+ * @param headerMapper optional header mapper to use in place of the standard mapper
+ */
+ virtual void send(
+ SmartPtrIIntMessage message,
+ SmartPtrAmqpHeaderMapper headerMapper = SmartPtrAmqpHeaderMapper()) = 0;
+
+ /**
+ * @brief Send a message to a default exchange with a routing key.
+ * @param routingKey the routing key
+ * @param message a message to send
+ * @param headerMapper optional header mapper to use in place of the standard mapper
+ */
+ virtual void send(
+ const std::string& routingKey,
+ SmartPtrIIntMessage message,
+ SmartPtrAmqpHeaderMapper headerMapper = SmartPtrAmqpHeaderMapper()) = 0;
+
+ /**
+ * @brief Send a message to an exchange with a routing key.
+ * @param exchange the name of the exchange
+ * @param routingKey the routing key
+ * @param message a message to send
+ * @param headerMapper optional header mapper to use in place of the standard mapper
+ */
+ virtual void send(
+ const std::string& exchange,
+ const std::string& routingKey,
+ SmartPtrIIntMessage message,
+ SmartPtrAmqpHeaderMapper headerMapper = SmartPtrAmqpHeaderMapper()) = 0;
+
+ /**
+ * @brief Receive a message if there is one from a default queue.
+ * <p>
+ * Returns immediately, possibly with a null value.
+ * @param headerMapper optional header mapper to use in place of the standard mapper
+ */
+ virtual SmartPtrIIntMessage receive(
+ SmartPtrAmqpHeaderMapper headerMapper = SmartPtrAmqpHeaderMapper()) = 0;
+
+ /**
+ * @brief Receive a message if there is one from a specific queue.
+ * <p>
+ * Returns immediately, possibly with a null value.
+ * @param queueName the name of the queue
+ * @param headerMapper optional header mapper to use in place of the standard mapper
+ */
+ virtual SmartPtrIIntMessage receive(
+ const std::string& queueName,
+ SmartPtrAmqpHeaderMapper headerMapper = SmartPtrAmqpHeaderMapper()) = 0;
+
+ /**
+ * @brief Basic RPC pattern.
+ * <p>
+ * Send a message to a default exchange with a default routing key and attempt to
+ * receive a response. The implementation will create a temporary anonymous queue
+ * to receive the response and will use the repy-to header to notify the recipient
+ * of the response routing.
+ * @param message a message to send
+ * @param requestHeaderMapper optional header mapper to use in place of the standard mapper on the outgoing message
+ * @param responseHeaderMapper optional header mapper to use in place of the standard mapper on the incoming message
+ */
+ virtual SmartPtrIIntMessage sendAndReceive(
+ SmartPtrIIntMessage message,
+ SmartPtrAmqpHeaderMapper requestHeaderMapper = SmartPtrAmqpHeaderMapper(),
+ SmartPtrAmqpHeaderMapper responseHeaderMapper = SmartPtrAmqpHeaderMapper()) = 0;
+
+ /**
+ * @brief Basic RPC pattern.
+ * <p>
+ * Send a message to a default exchange with a specific routing key and attempt to
+ * receive a response. The implementation will create a temporary anonymous queue
+ * to receive the response and will use the repy-to header to notify the recipient
+ * of the response routing.
+ * @param routingKey the routing key
+ * @param message a message to send
+ * @param requestHeaderMapper optional header mapper to use in place of the standard mapper on the outgoing message
+ * @param responseHeaderMapper optional header mapper to use in place of the standard mapper on the incoming message
+ */
+ virtual SmartPtrIIntMessage sendAndReceive(
+ const std::string& routingKey,
+ SmartPtrIIntMessage message,
+ SmartPtrAmqpHeaderMapper requestHeaderMapper = SmartPtrAmqpHeaderMapper(),
+ SmartPtrAmqpHeaderMapper responseHeaderMapper = SmartPtrAmqpHeaderMapper()) = 0;
+
+ /**
+ * @brief Basic RPC pattern.
+ * <p>
+ * Send a message to a specific exchange with a specific routing key and attempt to
+ * receive a response. The implementation will create a temporary anonymous queue
+ * to receive the response and will use the repy-to header to notify the recipient
+ * of the response routing.
+ * @param exchange the name of the exchange
+ * @param routingKey the routing key
+ * @param message a message to send
+ * @param requestHeaderMapper optional header mapper to use in place of the standard mapper on the outgoing message
+ * @param responseHeaderMapper optional header mapper to use in place of the standard mapper on the incoming message
+ */
+ virtual SmartPtrIIntMessage sendAndReceive(
+ const std::string& exchange,
+ const std::string& routingKey,
+ SmartPtrIIntMessage message,
+ SmartPtrAmqpHeaderMapper requestHeaderMapper = SmartPtrAmqpHeaderMapper(),
+ SmartPtrAmqpHeaderMapper responseHeaderMapper = SmartPtrAmqpHeaderMapper()) = 0;
+
+ /**
+ * @brief Interface to objects used to execute arbitrary AMQP commands
+ * <p>
+ * This interface provides a mechanism to execute arbitrary AMQP commands. Implement
+ * a class based on this interface with the logic required to support the desired
+ * AMQP operation. The template will call this object with a channel on which
+ * to execute the command.
+ * @param channel the AMQP channel (Caf::AmqpClient::Channel in the
+ * CAF AMQP Client Library API documentation.)
+ * @param data user-specific data required to perform the operation
+ * @return a pointer to a user-specified object representing the result of the
+ * operation.
+ */
+ struct Executor : public ICafObject {
+ virtual gpointer execute(AmqpClient::SmartPtrChannel channel, gpointer data) = 0;
+ };
+ CAF_DECLARE_SMART_POINTER(Executor);
+
+ /**
+ * @brief Execute an arbitrary AMQP operation
+ * @see #Caf::AmqpIntegration::AmqpTemplate::Executor
+ * @param executor the object used to execute the AMQP operation
+ * @param data user-specific data required to perform the operation
+ * @return a pointer to a user-specified object representing the result of the
+ * operation.
+ */
+ virtual gpointer execute(SmartPtrExecutor executor, gpointer data) = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(AmqpTemplate);
+
+}}
+
+#endif /* AMQPINTEGRATIONCORE_AMQPTEMPLATE_H_ */
--- /dev/null
+/*
+ * Created on: Jun 13, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_BINDING_H_
+#define AMQPINTEGRATIONCORE_BINDING_H_
+
+
+#include "ICafObject.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @brief Simple container collecting information to describe a queue binding. Used in conjunction with RabbitAdmin.
+ * <p>
+ * Use #Caf::AmqpIntegration::createBinding to create a binding.
+ */
+struct __declspec(novtable) Binding : public ICafObject {
+ CAF_DECL_UUID("A6067BE6-18C1-4D50-BB2F-AB9E49EA2111")
+
+ /** @return the queue name */
+ virtual std::string getQueue() const = 0;
+
+ /** @return the exchange name */
+ virtual std::string getExchange() const = 0;
+
+ /** @return the routing key */
+ virtual std::string getRoutingKey() const = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(Binding);
+
+}}
+
+#endif /* AMQPINTEGRATIONCORE_BINDING_H_ */
--- /dev/null
+/*
+ * Created on: Jun 14, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_BINDINGIMPL_H_
+#define AMQPINTEGRATIONCORE_BINDINGIMPL_H_
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @brief Implementations of the #Caf::AmqpIntegration::Binding interface.
+ */
+class AMQPINTEGRATIONCORE_LINKAGE BindingImpl : public Binding {
+public:
+ BindingImpl();
+ virtual ~BindingImpl();
+
+ /**
+ * @brief initialize the object
+ * @param queue the name of the queue
+ * @param exchange the name of the exchange
+ * @param routingKey the routing key
+ */
+ void init(
+ const std::string queue,
+ const std::string exchange,
+ const std::string routingKey);
+
+ std::string getQueue() const;
+
+ std::string getExchange() const;
+
+ std::string getRoutingKey() const;
+
+private:
+ std::string _queue;
+ std::string _exchange;
+ std::string _routingKey;
+ CAF_CM_DECLARE_NOCOPY(BindingImpl);
+};
+CAF_DECLARE_SMART_POINTER(BindingImpl);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: Jun 15, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_BINDINGINTERNAL_H_
+#define AMQPINTEGRATIONCORE_BINDINGINTERNAL_H_
+
+
+#include "ICafObject.h"
+
+#include "amqpCore/Binding.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @ingroup IntObjImpl
+ * @brief Interface allowing for internal management of binding integration objects
+ */
+struct __declspec(novtable) BindingInternal : public ICafObject {
+ CAF_DECL_UUID("23D0079E-93F8-4C06-BD33-F0E795506FB2")
+
+ /**
+ * @brief Sets the delegated Binding object
+ * @param binding the delegated binding
+ */
+ virtual void setBindingInternal(SmartPtrBinding binding) = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(BindingInternal);
+
+}}
+#endif /* AMQPINTEGRATIONCORE_BINDINGINTERNAL_H_ */
--- /dev/null
+/*
+ * Created on: Jul 30, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_BLOCKINGQUEUECONSUMER_H_
+#define AMQPINTEGRATIONCORE_BLOCKINGQUEUECONSUMER_H_
+
+#include "ICafObject.h"
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Common/CAutoRecMutex.h"
+#include "Exception/CCafException.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/api/Channel.h"
+#include "amqpClient/api/Envelope.h"
+#include "amqpCore/AmqpHeaderMapper.h"
+#include "amqpClient/api/Connection.h"
+#include "amqpCore/ConnectionFactory.h"
+#include "Integration/ILifecycle.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+// Forward-declare
+class BlockingQueueConsumer;
+CAF_DECLARE_SMART_POINTER(BlockingQueueConsumer)
+
+/**
+ * @ingroup IntObjImpl
+ * @brief Specialized consumer encapsulating knowledge of the broker connections and having its own lifecycle
+ */
+class AMQPINTEGRATIONCORE_LINKAGE BlockingQueueConsumer :
+ public ILifecycle {
+public:
+ BlockingQueueConsumer();
+ virtual ~BlockingQueueConsumer();
+
+ /**
+ * @brief object initializer
+ * @param connectionFactory connection factory object
+ * @param headerMapper header mapper object to map incoming headers
+ * @param acknowledgeMode message acknowledgement mode
+ * @param prefetchCount if <i>acknowledgeMode</i> is <i>AUTO</i> or <i>MANUAL</i> this
+ * message prefetch count value will be sent to the broker via the basic.qos method.
+ * @param queue the queue to consume
+ */
+ void init(
+ SmartPtrConnectionFactory connectionFactory,
+ SmartPtrAmqpHeaderMapper headerMapper,
+ AcknowledgeMode acknowledgeMode,
+ uint32 prefetchCount,
+ const std::string& queue);
+
+ /**
+ * @retval the underlying channel
+ */
+ AmqpClient::SmartPtrChannel getChannel();
+
+ /**
+ * @retval the AMQP consumer tag(s)
+ */
+ std::string getConsumerTag();
+
+ /**
+ * @brief Wait for the next message delivery and return it
+ * <p>
+ * This is a blocking call and will return only when a message has been delivered
+ * or the consumer is canceled. In the case of cancellation NULL will be returned.
+ * @retval the next message or NULL
+ */
+ SmartPtrIIntMessage nextMessage();
+
+ /**
+ * @brief Wait for the next message delivery and return it
+ * <p>
+ * This is a non-blocking call and will return when a message has been delivered
+ * within the timeout specified or if the consumer is canceled.
+ * @param timeout the timeout in milliseconds
+ * @retval the next message or NULL
+ */
+ SmartPtrIIntMessage nextMessage(int32 timeout);
+
+ /**
+ * @brief Acknowledges unacknowledged messages
+ * <p>
+ * Sends a basic.ack for messages that have been delivered. This method only
+ * sends a basic.ack if the acknowledge mode flag is set to ACKNOWLEDGEMODE_AUTO.
+ */
+ bool commitIfNecessary();
+
+ /**
+ * @brief Rejects unacknowledged messaages
+ * <p>
+ * Sends a basic.reject for messages that have been delivered. This method only
+ * sends a basic.reject if the acknowledge mode flag is set to ACKNOWLEDGEMODE_AUTO.
+ * @param ex the application exception necessitating a rollback
+ */
+ void rollbackOnExceptionIfNecessary(SmartPtrCCafException& ex);
+
+public:
+ void start(const uint32 timeoutMs);
+ void stop(const uint32 timeoutMs);
+ bool isRunning() const;
+
+private:
+ class InternalConsumer : public AmqpClient::Consumer {
+ public:
+ InternalConsumer();
+ virtual ~InternalConsumer();
+
+ void init(
+ BlockingQueueConsumer* parent);
+
+ public:
+ void handleConsumeOk(
+ const std::string& consumerTag);
+
+ void handleCancelOk(
+ const std::string& consumerTag);
+
+ void handleRecoverOk(
+ const std::string& consumerTag);
+
+ void handleDelivery(
+ const std::string& consumerTag,
+ const AmqpClient::SmartPtrEnvelope& envelope,
+ const AmqpClient::AmqpContentHeaders::SmartPtrBasicProperties& properties,
+ const SmartPtrCDynamicByteArray& body);
+
+ void handleShutdown(
+ const std::string& consumerTag,
+ SmartPtrCCafException& reason);
+
+ std::string getConsumerTag();
+
+ private:
+ SmartPtrBlockingQueueConsumer _parent;
+ AmqpClient::SmartPtrChannel _channel;
+ std::string _consumerTag;
+ GAsyncQueue *_deliveryQueue;
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(InternalConsumer);
+ };
+ CAF_DECLARE_SMART_POINTER(InternalConsumer);
+
+private:
+ struct Delivery : public ICafObject {
+ AmqpClient::SmartPtrEnvelope envelope;
+ AmqpClient::AmqpContentHeaders::SmartPtrBasicProperties properties;
+ SmartPtrCDynamicByteArray body;
+ };
+ CAF_DECLARE_SMART_POINTER(Delivery);
+
+private:
+ void checkShutdown();
+
+ SmartPtrIIntMessage handle(SmartPtrDelivery delivery);
+
+ static void destroyQueueItem(gpointer data);
+
+private:
+ friend class InternalConsumer;
+
+ bool _isInitialized;
+ volatile bool _isRunning;
+ volatile bool _isCanceled;
+ std::set<uint64> _deliveryTags;
+ SmartPtrInternalConsumer _consumer;
+ SmartPtrCAutoRecMutex _parentLock;
+ SmartPtrCCafException _shutdownException;
+ GAsyncQueue *_deliveryQueue;
+ SmartPtrConnectionFactory _connectionFactory;
+ SmartPtrConnection _connection;
+ AmqpClient::SmartPtrChannel _channel;
+ SmartPtrAmqpHeaderMapper _headerMapper;
+ AcknowledgeMode _acknowledgeMode;
+ uint32 _prefetchCount;
+ std::string _queue;
+
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(BlockingQueueConsumer);
+};
+
+}}
+
+#endif /* AMQPINTEGRATIONCORE_BLOCKINGQUEUECONSUMER_H_ */
--- /dev/null
+/*
+ * Created on: May 25, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CACHINGCONNECTIONFACTORY_H_
+#define CACHINGCONNECTIONFACTORY_H_
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Common/CAutoRecMutex.h"
+#include "Exception/CCafException.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/api/AmqpMethods.h"
+#include "amqpClient/api/Channel.h"
+#include "amqpClient/api/Consumer.h"
+#include "amqpClient/api/GetResponse.h"
+#include "amqpClient/api/ReturnListener.h"
+#include "amqpClient/api/amqpClient.h"
+#include "amqpCore/ChannelProxy.h"
+#include "amqpClient/api/Connection.h"
+#include "amqpClient/api/ConnectionFactory.h"
+#include "amqpCore/ConnectionListener.h"
+#include "amqpCore/AbstractConnectionFactory.h"
+#include "amqpCore/ConnectionProxy.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @ingroup IntObjImpl
+ * @brief Implementation of the CachingConnectionFactory Integration Object
+ */
+class AMQPINTEGRATIONCORE_LINKAGE CachingConnectionFactory :
+ public AbstractConnectionFactory {
+public:
+ CachingConnectionFactory();
+ virtual ~CachingConnectionFactory();
+
+ void init();
+
+ void init(const std::string& protocol, const std::string& host, const uint32 port);
+
+ void init(const std::string& protocol, const std::string& host);
+
+ void init(const uint32 port);
+
+ void init(const AmqpClient::SmartPtrConnectionFactory& amqpConnectionFactory);
+
+ void destroy();
+
+ uint32 getChannelCacheSize();
+
+ AmqpClient::SmartPtrChannel getChannel();
+
+ void setConnectionListeners(const std::deque<SmartPtrConnectionListener>& listeners);
+
+ void setChannelCacheSize(uint32 cacheSize);
+
+public: // ConnectionFactory
+ SmartPtrConnection createConnection();
+
+ void addConnectionListener(const SmartPtrConnectionListener& listener);
+
+private:
+ typedef std::deque<SmartPtrChannelProxy> ProxyDeque;
+ CAF_DECLARE_SMART_POINTER(ProxyDeque);
+
+ void reset();
+
+ SmartPtrChannelProxy newCachedChannelProxy();
+
+ AmqpClient::SmartPtrChannel createBareChannel();
+
+private:
+ class ChannelCachingConnectionProxy : public ConnectionProxy {
+ public:
+ ChannelCachingConnectionProxy();
+ virtual ~ChannelCachingConnectionProxy();
+
+ public:
+ void init(
+ SmartPtrConnection connection,
+ CachingConnectionFactory *parent);
+
+ void destroy();
+
+ public: // ConnectionProxy
+ SmartPtrConnection getTargetConnection();
+
+ public: // Connection
+ AmqpClient::SmartPtrChannel createChannel();
+ void close();
+ bool isOpen();
+
+ public:
+ AmqpClient::SmartPtrChannel createBareChannel();
+
+ private:
+ SmartPtrConnection _target;
+ CachingConnectionFactory *_parent;
+
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(ChannelCachingConnectionProxy);
+ };
+ CAF_DECLARE_SMART_POINTER(ChannelCachingConnectionProxy);
+ friend class ChannelCachingConnectionProxy;
+
+ class CachedChannelHandler : public ChannelProxy {
+ public:
+ CachedChannelHandler();
+ virtual ~CachedChannelHandler();
+
+ void init(
+ CachingConnectionFactory *parent,
+ AmqpClient::SmartPtrChannel channel);
+
+ private:
+ void logicalClose();
+
+ void physicalClose();
+
+ void checkChannel();
+
+ void postProcessCall(SmartPtrCCafException exception);
+
+ public: // ChannelProxy
+ AmqpClient::SmartPtrChannel getTargetChannel();
+
+ public: // Channel
+ uint16 getChannelNumber();
+
+ void close();
+
+ bool isOpen();
+
+ void basicAck(
+ const uint64 deliveryTag,
+ const bool ackMultiple);
+
+ AmqpClient::SmartPtrGetResponse basicGet(
+ const std::string& queue,
+ const bool noAck);
+
+ void basicPublish(
+ const std::string& exchange,
+ const std::string& routingKey,
+ const AmqpClient::AmqpContentHeaders::SmartPtrBasicProperties& properties,
+ const SmartPtrCDynamicByteArray& body);
+
+ void basicPublish(
+ const std::string& exchange,
+ const std::string& routingKey,
+ const bool mandatory,
+ const bool immediate,
+ const AmqpClient::AmqpContentHeaders::SmartPtrBasicProperties& properties,
+ const SmartPtrCDynamicByteArray& body);
+
+ AmqpClient::AmqpMethods::Basic::SmartPtrConsumeOk basicConsume(
+ const std::string& queue,
+ const AmqpClient::SmartPtrConsumer& consumer);
+
+ AmqpClient::AmqpMethods::Basic::SmartPtrConsumeOk basicConsume(
+ const std::string& queue,
+ const bool noAck,
+ const AmqpClient::SmartPtrConsumer& consumer);
+
+ AmqpClient::AmqpMethods::Basic::SmartPtrConsumeOk basicConsume(
+ const std::string& queue,
+ const std::string& consumerTag,
+ const bool noAck,
+ const bool noLocal,
+ const bool exclusive,
+ const AmqpClient::SmartPtrConsumer& consumer,
+ const AmqpClient::SmartPtrTable& arguments = AmqpClient::SmartPtrTable());
+
+ AmqpClient::AmqpMethods::Basic::SmartPtrCancelOk basicCancel(
+ const std::string& consumerTag);
+
+ AmqpClient::AmqpMethods::Basic::SmartPtrRecoverOk basicRecover(
+ const bool requeue);
+
+ AmqpClient::AmqpMethods::Basic::SmartPtrQosOk basicQos(
+ const uint32 prefetchSize,
+ const uint32 prefetchCount,
+ const bool global);
+
+ void basicReject(
+ const uint64 deliveryTag,
+ const bool requeue);
+
+ AmqpClient::AmqpMethods::Exchange::SmartPtrDeclareOk exchangeDeclare(
+ const std::string& exchange,
+ const std::string& type,
+ const bool durable = false,
+ const AmqpClient::SmartPtrTable& arguments = AmqpClient::SmartPtrTable());
+
+ AmqpClient::AmqpMethods::Exchange::SmartPtrDeleteOk exchangeDelete(
+ const std::string& exchange,
+ const bool ifUnused);
+
+ AmqpClient::AmqpMethods::Queue::SmartPtrDeclareOk queueDeclare();
+
+ AmqpClient::AmqpMethods::Queue::SmartPtrDeclareOk queueDeclare(
+ const std::string& queue,
+ const bool durable,
+ const bool exclusive,
+ const bool autoDelete,
+ const AmqpClient::SmartPtrTable& arguments = AmqpClient::SmartPtrTable());
+
+ AmqpClient::AmqpMethods::Queue::SmartPtrDeclareOk queueDeclarePassive(
+ const std::string& queue);
+
+ AmqpClient::AmqpMethods::Queue::SmartPtrDeleteOk queueDelete(
+ const std::string& queue,
+ const bool ifUnused,
+ const bool ifEmpty);
+
+ AmqpClient::AmqpMethods::Queue::SmartPtrPurgeOk queuePurge(
+ const std::string& queue);
+
+ AmqpClient::AmqpMethods::Queue::SmartPtrBindOk queueBind(
+ const std::string& queue,
+ const std::string& exchange,
+ const std::string& routingKey,
+ const AmqpClient::SmartPtrTable& arguments = AmqpClient::SmartPtrTable());
+
+ AmqpClient::AmqpMethods::Queue::SmartPtrUnbindOk queueUnbind(
+ const std::string& queue,
+ const std::string& exchange,
+ const std::string& routingKey,
+ const AmqpClient::SmartPtrTable& arguments = AmqpClient::SmartPtrTable());
+
+ void addReturnListener(
+ const AmqpClient::SmartPtrReturnListener& listener);
+
+ bool removeReturnListener(
+ const AmqpClient::SmartPtrReturnListener& listener);
+
+ private:
+ CachingConnectionFactory *_parent;
+ AmqpClient::SmartPtrChannel _channel;
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_CM_DECLARE_NOCOPY(CachedChannelHandler);
+ };
+ CAF_DECLARE_SMART_POINTER(CachedChannelHandler);
+ friend class CachedChannelHandler;
+
+private:
+ bool _isInitialized;
+ bool _isActive;
+ SmartPtrCAutoRecMutex _connectionMonitor;
+ SmartPtrChannelCachingConnectionProxy _connection;
+ uint32 _channelCacheSize;
+ SmartPtrProxyDeque _cachedChannels;
+ SmartPtrCAutoRecMutex _cachedChannelsMonitor;
+
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CachingConnectionFactory);
+};
+CAF_DECLARE_SMART_POINTER(CachingConnectionFactory);
+
+}}
+
+#endif /* CACHINGCONNECTIONFACTORY_H_ */
--- /dev/null
+/*
+ * Created on: May 29, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CHANNELPROXY_H_
+#define CHANNELPROXY_H_
+
+
+#include "amqpClient/api/Channel.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @ingroup IntObjImpl
+ * @brief Interface on objects used to proxy channel objects for the various
+ * connection objects.
+ */
+struct __declspec(novtable) ChannelProxy : public AmqpClient::Channel {
+
+ /**
+ * @brief Return the proxied Channel object
+ * @return the proxied channel
+ */
+ virtual AmqpClient::SmartPtrChannel getTargetChannel() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(ChannelProxy);
+
+}}
+
+#endif /* CHANNELPROXY_H_ */
--- /dev/null
+/*
+ * Created on: Jun 2, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef COMPOSITECONNECTIONLISTENER_H_
+#define COMPOSITECONNECTIONLISTENER_H_
+
+#include "amqpClient/api/Connection.h"
+#include "amqpCore/ConnectionListener.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @ingroup IntObjImpl
+ * @brief Implementation of ConnectionListener that notifies multiple delegates
+ */
+class AMQPINTEGRATIONCORE_LINKAGE CompositeConnectionListener : public ConnectionListener {
+public:
+ CompositeConnectionListener();
+ virtual ~CompositeConnectionListener();
+
+ typedef std::deque<SmartPtrConnectionListener> ListenerDeque;
+
+ /**
+ * @brief Set the delegate collection
+ * @param delegates the collection of ConnectionListener delegates
+ */
+ void setDelegates(const ListenerDeque& delegates);
+
+ /**
+ * @brief Add a delegate to the collection
+ * @param delegate the ConnectionListener delegate to add
+ */
+ void addDelegate(const SmartPtrConnectionListener& delegate);
+
+public: // ConnectionListener
+ void onCreate(const SmartPtrConnection& connection);
+ void onClose(const SmartPtrConnection& connection);
+
+private:
+ ListenerDeque _delegates;
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CompositeConnectionListener);
+};
+CAF_DECLARE_SMART_POINTER(CompositeConnectionListener);
+
+}}
+
+#endif /* COMPOSITECONNECTIONLISTENER_H_ */
--- /dev/null
+/*
+ * Created on: May 24, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_CONNECTION_H_
+#define AMQPINTEGRATIONCORE_CONNECTION_H_
+
+
+#include "ICafObject.h"
+
+#include "amqpClient/api/Channel.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @ingroup IntObjImpl
+ * @brief An interface for Caf::AmqpIntegration connection objects
+ */
+struct __declspec(novtable) Connection : public ICafObject {
+
+ /**
+ * @brief Create a {@link AmqpClient::Channel Channel}.
+ */
+ virtual AmqpClient::SmartPtrChannel createChannel() = 0;
+
+ /**
+ * @brief Close the connection
+ */
+ virtual void close() = 0;
+
+ /**
+ * @brief Check the connection's status
+ * @retval true the connection is open
+ * @retval false the connection is closed
+ */
+ virtual bool isOpen() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(Connection);
+
+}}
+
+#endif /* AMQPINTEGRATIONCORE_CONNECTION_H_ */
--- /dev/null
+/*
+ * Created on: May 24, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_CONNECTIONFACTORY_H_
+#define AMQPINTEGRATIONCORE_CONNECTIONFACTORY_H_
+
+#include "amqpClient/api/Connection.h"
+#include "amqpCore/ConnectionListener.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @ingroup IntObjImpl
+ * @brief Interface for connection factory implementations
+ */
+struct __declspec(novtable) ConnectionFactory : ICafObject {
+ CAF_DECL_UUID("D2420BC6-240C-4EAC-8518-E86A93A40035")
+
+ /**
+ * @return a new Connection
+ */
+ virtual SmartPtrConnection createConnection() = 0;
+
+ /**
+ * @return the default protocol to use for connections
+ */
+ virtual std::string getProtocol() = 0;
+
+ /**
+ * @return the default host to use for connections
+ */
+ virtual std::string getHost() = 0;
+
+ /**
+ * @return the default port to use for connections
+ */
+ virtual uint32 getPort() = 0;
+
+ /**
+ * @return the default virtual host to use for connections
+ */
+ virtual std::string getVirtualHost() = 0;
+
+ /**
+ * @return the default user name to use for connections
+ */
+ virtual std::string getUsername() = 0;
+
+ /**
+ * @return the default password to use for connections
+ */
+ virtual std::string getPassword() = 0;
+
+ /**
+ * @return the default path to the CA Cert
+ */
+ virtual std::string getCaCertPath() = 0;
+
+ /**
+ * @return the default path to the Client Cert
+ */
+ virtual std::string getClientCertPath() = 0;
+
+ /**
+ * @return the default path to the Client Key
+ */
+ virtual std::string getClientKeyPath() = 0;
+
+ /**
+ * @return the number of connection retries
+ */
+ virtual uint16 getRetries() = 0;
+
+ /**
+ * @return the number of connection seconds to wait
+ */
+ virtual uint16 getSecondsToWait() = 0;
+
+ /**
+ * @brief Add a connection create/close callback
+ * @param listener ConnectionListener callback
+ */
+ virtual void addConnectionListener(const SmartPtrConnectionListener& listener) = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(ConnectionFactory);
+
+}}
+
+#endif /* AMQPINTEGRATIONCORE_CONNECTIONFACTORY_H_ */
--- /dev/null
+/*
+ * Created on: Jun 2, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_CONNECTIONLISTENER_H_
+#define AMQPINTEGRATIONCORE_CONNECTIONLISTENER_H_
+
+#include "ICafObject.h"
+
+#include "amqpCore/Connection.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @ingroup IntObjImpl
+ * @brief Connection event notification callback interface
+ */
+struct __declspec(novtable) ConnectionListener : public ICafObject {
+ CAF_DECL_UUID("8F249C38-CF91-4553-9C68-3D714626A7EC")
+
+ /**
+ * @brief Connection created event
+ * @param connection the Connection that has been created
+ */
+ virtual void onCreate(const SmartPtrConnection& connection) = 0;
+
+ /**
+ * @brief Connection closed event
+ * @param connection the Connection that has been closed
+ */
+ virtual void onClose(const SmartPtrConnection& connection) = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(ConnectionListener);
+
+}}
+
+#endif /* AMQPINTEGRATIONCORE_CONNECTIONLISTENER_H_ */
--- /dev/null
+/*
+ * Created on: May 25, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_CONNECTIONPROXY_H_
+#define AMQPINTEGRATIONCORE_CONNECTIONPROXY_H_
+
+#include "amqpClient/api/Connection.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @ingroup IntObjImpl
+ * @brief Interface on objects used to proxy connection objects for the various
+ * connection factories.
+ */
+struct __declspec(novtable) ConnectionProxy : public Connection {
+
+ /**
+ * @brief Return the proxied Connection object
+ * @return the proxied connection
+ */
+ virtual SmartPtrConnection getTargetConnection() = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(ConnectionProxy);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: Jun 6, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_DEFAULTAMQPHEADERMAPPER_H_
+#define AMQPINTEGRATIONCORE_DEFAULTAMQPHEADERMAPPER_H_
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Common/CCafRegex.h"
+#include "Integration/IIntMessage.h"
+#include "amqpClient/api/Envelope.h"
+#include "amqpCore/AmqpHeaderMapper.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @brief This class is used to map AMQP headers to integration message
+ * headers and vice versa.
+ * <p>
+ * This class maps headers between the AMQP message protocol and the internal
+ * integration object message protocol. By default, standard AMQP headers are mapped and
+ * internal and user-defined headers are not. An optional regular expression can be
+ * supplied to allow user-defined headers to be mapped from integration messages
+ * to AMQP.
+ */
+class AMQPINTEGRATIONCORE_LINKAGE DefaultAmqpHeaderMapper : public AmqpHeaderMapper {
+public:
+ DefaultAmqpHeaderMapper();
+ virtual ~DefaultAmqpHeaderMapper();
+
+ /**
+ * @brief Object initializer
+ * @param userHeaderRegex the regular expression to apply to the integration
+ * message header keys. Those that match are mapped to the AMQP message headers.
+ */
+ void init(const std::string& userHeaderRegex = std::string());
+
+ virtual AmqpClient::AmqpContentHeaders::SmartPtrBasicProperties
+ fromHeaders(IIntMessage::SmartPtrCHeaders headers);
+
+ virtual IIntMessage::SmartPtrCHeaders
+ toHeaders(
+ AmqpClient::AmqpContentHeaders::SmartPtrBasicProperties properties,
+ AmqpClient::SmartPtrEnvelope envelope);
+
+ virtual IIntMessage::SmartPtrCHeaders
+ filterHeaders(
+ IIntMessage::SmartPtrCHeaders headers);
+
+private:
+ bool _isInitialized;
+ SmartPtrCCafRegex _userHeaderRegex;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(DefaultAmqpHeaderMapper);
+};
+CAF_DECLARE_SMART_POINTER(DefaultAmqpHeaderMapper);
+
+}}
+
+#endif /* AMQPINTEGRATIONCORE_DEFAULTAMQPHEADERMAPPER_H_ */
--- /dev/null
+/*
+ * Created on: Jun 12, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_EXCHANGE_H_
+#define AMQPINTEGRATIONCORE_EXCHANGE_H_
+
+
+#include "ICafObject.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @brief Constants representing the exchange types returned by #Caf::AmqpIntegration::Exchange::getType
+ */
+struct AMQPINTEGRATIONCORE_LINKAGE ExchangeTypes {
+ /** @brief direct exchange */
+ static const char *DIRECT;
+ /** @brief topic exchange */
+ static const char *TOPIC;
+ /** @brief headers exchange */
+ static const char *HEADERS;
+ /** @brief fanoout exchange */
+ static const char *FANOUT;
+};
+
+/**
+ * @brief Simple container collecting information to describe an exchange. Used in conjunction with RabbitAdmin.
+ * <p>
+ * Use #Caf::AmqpIntegration::createDirectExchange, #Caf::AmqpIntegration::createTopicExchange,
+ * #Caf::AmqpIntegration::createHeadersExchange or #Caf::AmqpIntegration::createFanoutExchange
+ * to create an exchange.
+ */
+struct __declspec(novtable) Exchange : public ICafObject {
+ CAF_DECL_UUID("0F93E16B-E12D-4D00-8DB8-163D57BE2078")
+
+ /** @return the name of the exchange */
+ virtual std::string getName() const = 0;
+
+ /** @return the exchange type @see #Caf::AmqpIntegration::ExchangeTypes */
+ virtual std::string getType() const = 0;
+
+ /**
+ * @retval true the exchange is durable
+ * @retval false the exchange is not durable
+ */
+ virtual bool isDurable() const = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(Exchange);
+
+}}
+
+#endif /* AMQPINTEGRATIONCORE_EXCHANGE_H_ */
--- /dev/null
+/*
+ * Created on: Jun 14, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_EXCHANGEIMPL_H_
+#define AMQPINTEGRATIONCORE_EXCHANGEIMPL_H_
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @brief Base class for implementations of the #Caf::AmqpIntegration::Exchange interface
+ */
+class AMQPINTEGRATIONCORE_LINKAGE AbstractExchange : public Exchange {
+public:
+ AbstractExchange();
+ virtual ~AbstractExchange();
+
+ /**
+ * @brief initalize the object
+ * @param name exchange name
+ * @param isDurable <b>true</b> if the exchange is durable else <b>false</b>
+ */
+ void init(
+ const std::string& name,
+ const bool isDurable);
+
+ virtual std::string getName() const;
+ virtual std::string getType() const = 0;
+ virtual bool isDurable() const;
+
+private:
+ std::string _name;
+ bool _isDurable;
+ CAF_CM_DECLARE_NOCOPY(AbstractExchange);
+};
+
+/**
+ * @brief Implementation of the #Caf::AmqpIntegration::Exchange interface for direct exchanges
+ */
+class DirectExchange : public AbstractExchange {
+public:
+ DirectExchange();
+
+ /**
+ * @brief initalize the object
+ * @param name exchange name
+ * @param durable <b>true</b> if the exchange is durable else <b>false</b>
+ */
+ void init(
+ const std::string name,
+ const bool durable);
+
+ virtual std::string getType() const;
+ CAF_CM_DECLARE_NOCOPY(DirectExchange);
+};
+CAF_DECLARE_SMART_POINTER(DirectExchange);
+
+/**
+ * @brief Implementation of the #Caf::AmqpIntegration::Exchange interface for topic exchanges
+ */
+class TopicExchange : public AbstractExchange {
+public:
+ TopicExchange();
+
+ /**
+ * @brief initalize the object
+ * @param name exchange name
+ * @param durable <b>true</b> if the exchange is durable else <b>false</b>
+ */
+ void init(
+ const std::string name,
+ const bool durable);
+
+ virtual std::string getType() const;
+ CAF_CM_DECLARE_NOCOPY(TopicExchange);
+};
+CAF_DECLARE_SMART_POINTER(TopicExchange);
+
+/**
+ * @brief Implementation of the #Caf::AmqpIntegration::Exchange interface for headers exchanges
+ */
+class HeadersExchange : public AbstractExchange {
+public:
+ HeadersExchange();
+
+ /**
+ * @brief initalize the object
+ * @param name exchange name
+ * @param durable <b>true</b> if the exchange is durable else <b>false</b>
+ */
+ void init(
+ const std::string name,
+ const bool durable);
+
+ virtual std::string getType() const;
+ CAF_CM_DECLARE_NOCOPY(HeadersExchange);
+};
+CAF_DECLARE_SMART_POINTER(HeadersExchange);
+
+/**
+ * @brief Implementation of the #Caf::AmqpIntegration::Exchange interface for fanout exchanges
+ */
+class FanoutExchange : public AbstractExchange {
+public:
+ FanoutExchange();
+
+ /**
+ * @brief initalize the object
+ * @param name exchange name
+ * @param durable <b>true</b> if the exchange is durable else <b>false</b>
+ */
+ void init(
+ const std::string name,
+ const bool durable);
+
+ virtual std::string getType() const;
+ CAF_CM_DECLARE_NOCOPY(FanoutExchange);
+};
+CAF_DECLARE_SMART_POINTER(FanoutExchange);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: Jun 14, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_EXCHANGEINTERNAL_H_
+#define AMQPINTEGRATIONCORE_EXCHANGEINTERNAL_H_
+
+
+#include "ICafObject.h"
+
+#include "amqpCore/Binding.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @ingroup IntObjImpl
+ * @brief Interface allowing for internal management of exchange integration objects
+ */
+struct __declspec(novtable) ExchangeInternal : public ICafObject {
+ CAF_DECL_UUID("5373AD13-2103-4FC4-A581-9D6D454F02A3")
+
+ /**
+ * @brief Return the bindings defined as part of the exchange definition
+ * @return the collection of bindings
+ */
+ virtual std::deque<SmartPtrBinding> getEmbeddedBindings() const = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(ExchangeInternal);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: Aug 2, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_MESSAGELISTENER_H_
+#define AMQPINTEGRATIONCORE_MESSAGELISTENER_H_
+
+
+#include "ICafObject.h"
+
+#include "Integration/IIntMessage.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+struct __declspec(novtable) MessageListener : public ICafObject {
+ CAF_DECL_UUID("5B2B7C47-ACEF-4FB1-97A0-1594D05AB4D9")
+
+ virtual void onMessage(const SmartPtrIIntMessage& message) = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(MessageListener);
+
+}}
+
+#endif /* AMQPINTEGRATIONCORE_MESSAGELISTENER_H_ */
--- /dev/null
+/*
+ * Created on: Jun 13, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_QUEUE_H_
+#define AMQPINTEGRATIONCORE_QUEUE_H_
+
+
+#include "ICafObject.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @brief Simple container collecting information to describe a queue. Used in conjunction with RabbitAdmin.
+ * <p>
+ * Use #Caf::AmqpIntegration::createQueue to create a queue.
+ */
+struct __declspec(novtable) Queue : public ICafObject {
+ CAF_DECL_UUID("082088AD-ECA3-4591-986F-8D9AFEDDEE7D")
+
+ /** @return the name of the queue */
+ virtual std::string getName() const = 0;
+
+ /**
+ * @retval true the queue is durable
+ * @retval false the queue is not durable
+ */
+ virtual bool isDurable() const = 0;
+
+ /**
+ * @retval true the queue is exclusive to the connection
+ * @retval false the queue is not exclusive to the connection
+ */
+ virtual bool isExclusive() const = 0;
+
+ /**
+ * @retval true the server should delete the queue when it is no longer in use
+ * @retval false the server should not delete the queue when it is no longer in use
+ */
+ virtual bool isAutoDelete() const = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(Queue);
+
+}}
+
+#endif /* AMQPINTEGRATIONCORE_QUEUE_H_ */
--- /dev/null
+/*
+ * Created on: Jun 14, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_QUEUEIMPL_H_
+#define AMQPINTEGRATIONCORE_QUEUEIMPL_H_
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @brief Implementation of the #Caf::AmqpIntegration::Queue interface.
+ */
+class AMQPINTEGRATIONCORE_LINKAGE QueueImpl : public Queue {
+public:
+ QueueImpl();
+ virtual ~QueueImpl();
+
+ /**
+ * @brief initialize the object
+ * <p>
+ * <i>durable</i> will be set to <b>true</b>;
+ * <i>exclusive</i> and <i>autoDelete</i> will be set to <b>false</b>.
+ * @param name queue name
+ */
+ void init(const std::string& name);
+
+ /**
+ * @brief initialize the object
+ * <p>
+ * <i>exclusive</i> and <i>autoDelete</i> will be set to <b>false</b>.
+ * @param name queue name
+ * @param durable <b>true</b> to make the queue durable else <b>false</b>
+ */
+ void init(
+ const std::string& name,
+ const bool durable);
+
+ /**
+ * @brief initialize the object
+ * @param name queue name
+ * @param durable <b>true</b> to make the queue durable else <b>false</b>
+ * @param exclusive <b>true</b> to make the queue exclusive else <b>false</b>
+ * @param autoDelete <b>true</b> to make the queue auto-delete else <b>false</b>
+ */
+ void init(
+ const std::string& name,
+ const bool durable,
+ const bool exclusive,
+ const bool autoDelete);
+
+ std::string getName() const;
+
+ bool isDurable() const;
+
+ bool isExclusive() const;
+
+ bool isAutoDelete() const;
+
+private:
+ std::string _name;
+ bool _durable;
+ bool _exclusive;
+ bool _autoDelete;
+ CAF_CM_DECLARE_NOCOPY(QueueImpl);
+};
+CAF_DECLARE_SMART_POINTER(QueueImpl);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: Jun 14, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_QUEUEINTERNAL_H_
+#define AMQPINTEGRATIONCORE_QUEUEINTERNAL_H_
+
+
+#include "ICafObject.h"
+
+#include "amqpCore/Queue.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @ingroup IntObjImpl
+ * @brief Interface allowing for internal management of queue integration objects
+ */
+struct __declspec(novtable) QueueInternal : public ICafObject {
+ CAF_DECL_UUID("E15F4DA8-C4DC-4813-82B9-1B15C69915D1")
+
+ /**
+ * @brief Sets the delegated Queue object
+ * @param queue the delegated queue
+ */
+ virtual void setQueueInternal(SmartPtrQueue queue) = 0;
+};
+CAF_DECLARE_SMART_INTERFACE_POINTER(QueueInternal);
+
+}}
+#endif
--- /dev/null
+/*
+ * Created on: Jun 12, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_RABBITADMIN_H_
+#define AMQPINTEGRATIONCORE_RABBITADMIN_H_
+
+#include "amqpClient/api/Channel.h"
+#include "amqpCore/Binding.h"
+#include "amqpClient/api/ConnectionFactory.h"
+#include "amqpCore/Exchange.h"
+#include "amqpCore/Queue.h"
+#include "amqpCore/RabbitTemplate.h"
+#include "amqpCore/AmqpAdmin.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @ingroup IntObjImpl
+ * @brief Implementation of the RabbitAdmin Integration Object
+ */
+class AMQPINTEGRATIONCORE_LINKAGE RabbitAdmin : public AmqpAdmin {
+public:
+ RabbitAdmin();
+ virtual ~RabbitAdmin();
+
+ void init(SmartPtrConnectionFactory connectionFactory);
+
+ void term();
+
+public: // AmqpAdmin
+ void declareExchange(SmartPtrExchange exchange);
+
+ bool deleteExchange(const std::string& exchange);
+
+ SmartPtrQueue declareQueue();
+
+ void declareQueue(SmartPtrQueue queue);
+
+ bool deleteQueue(const std::string& queue);
+
+ void deleteQueue(
+ const std::string& queue,
+ const bool unused,
+ const bool empty);
+
+ void purgeQueue(const std::string& queue);
+
+ void declareBinding(SmartPtrBinding binding);
+
+ void removeBinding(SmartPtrBinding binding);
+
+private: // Executors
+ class DeclareExchangeExecutor : public AmqpTemplate::Executor {
+ public:
+ gpointer execute(AmqpClient::SmartPtrChannel channel, gpointer data);
+ };
+ CAF_DECLARE_SMART_POINTER(DeclareExchangeExecutor);
+
+ class DeleteExchangeExecutor : public AmqpTemplate::Executor {
+ gpointer execute(AmqpClient::SmartPtrChannel channel, gpointer data);
+ };
+ CAF_DECLARE_SMART_POINTER(DeleteExchangeExecutor);
+
+ class DeclareQueueExecutor : public AmqpTemplate::Executor {
+ gpointer execute(AmqpClient::SmartPtrChannel channel, gpointer data);
+ };
+ CAF_DECLARE_SMART_POINTER(DeclareQueueExecutor);
+
+ class DeleteQueueExecutor : public AmqpTemplate::Executor {
+ gpointer execute(AmqpClient::SmartPtrChannel channel, gpointer data);
+ };
+ CAF_DECLARE_SMART_POINTER(DeleteQueueExecutor);
+
+ class DeleteQueueExExecutor : public AmqpTemplate::Executor {
+ gpointer execute(AmqpClient::SmartPtrChannel channel, gpointer data);
+ };
+ CAF_DECLARE_SMART_POINTER(DeleteQueueExExecutor);
+
+ class PurgeQueueExecutor : public AmqpTemplate::Executor {
+ gpointer execute(AmqpClient::SmartPtrChannel channel, gpointer data);
+ };
+ CAF_DECLARE_SMART_POINTER(PurgeQueueExecutor);
+
+ class DeclareBindingExecutor : public AmqpTemplate::Executor {
+ gpointer execute(AmqpClient::SmartPtrChannel channel, gpointer data);
+ };
+ CAF_DECLARE_SMART_POINTER(DeclareBindingExecutor);
+
+ class RemoveBindingExecutor : public AmqpTemplate::Executor {
+ gpointer execute(AmqpClient::SmartPtrChannel channel, gpointer data);
+ };
+ CAF_DECLARE_SMART_POINTER(RemoveBindingExecutor);
+
+private:
+ bool _isInitialized;
+ SmartPtrRabbitTemplate _rabbitTemplate;
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(RabbitAdmin);
+};
+
+CAF_DECLARE_SMART_POINTER(RabbitAdmin);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: Jun 5, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_RABBITTEMPLATE_H_
+#define AMQPINTEGRATIONCORE_RABBITTEMPLATE_H_
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Exception/CCafException.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/api/Channel.h"
+#include "amqpClient/api/Envelope.h"
+#include "amqpCore/AmqpHeaderMapper.h"
+#include "amqpCore/AmqpTemplate.h"
+#include "amqpClient/api/Connection.h"
+#include "amqpCore/ConnectionFactory.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @ingroup IntObjImpl
+ * @brief Implementation of the RabbitTemplate Integration Object
+ */
+class AMQPINTEGRATIONCORE_LINKAGE RabbitTemplate : public AmqpTemplate {
+public:
+ RabbitTemplate();
+ virtual ~RabbitTemplate();
+
+ void init(SmartPtrConnectionFactory connectionFactory);
+
+ void term();
+
+ void setExchange(const std::string& exchange);
+
+ void setRoutingKey(const std::string& routingKey);
+
+ void setQueue(const std::string& queue);
+
+ void setReplyTimeout(const uint32 replyTimeout);
+
+ void setHeaderMapper(const SmartPtrAmqpHeaderMapper& headerMapper);
+
+public: // AmqpTemplate
+ void send(
+ SmartPtrIIntMessage message,
+ SmartPtrAmqpHeaderMapper headerMapper = SmartPtrAmqpHeaderMapper());
+
+ void send(
+ const std::string& routingKey,
+ SmartPtrIIntMessage message,
+ SmartPtrAmqpHeaderMapper headerMapper = SmartPtrAmqpHeaderMapper());
+
+ void send(
+ const std::string& exchange,
+ const std::string& routingKey,
+ SmartPtrIIntMessage message,
+ SmartPtrAmqpHeaderMapper headerMapper = SmartPtrAmqpHeaderMapper());
+
+ SmartPtrIIntMessage receive(
+ SmartPtrAmqpHeaderMapper headerMapper = SmartPtrAmqpHeaderMapper());
+
+ SmartPtrIIntMessage receive(
+ const std::string& queueName,
+ SmartPtrAmqpHeaderMapper headerMapper = SmartPtrAmqpHeaderMapper());
+
+ SmartPtrIIntMessage sendAndReceive(
+ SmartPtrIIntMessage message,
+ SmartPtrAmqpHeaderMapper requestHeaderMapper = SmartPtrAmqpHeaderMapper(),
+ SmartPtrAmqpHeaderMapper responseHeaderMapper = SmartPtrAmqpHeaderMapper());
+
+ SmartPtrIIntMessage sendAndReceive(
+ const std::string& routingKey,
+ SmartPtrIIntMessage message,
+ SmartPtrAmqpHeaderMapper requestHeaderMapper = SmartPtrAmqpHeaderMapper(),
+ SmartPtrAmqpHeaderMapper responseHeaderMapper = SmartPtrAmqpHeaderMapper());
+
+ SmartPtrIIntMessage sendAndReceive(
+ const std::string& exchange,
+ const std::string& routingKey,
+ SmartPtrIIntMessage message,
+ SmartPtrAmqpHeaderMapper requestHeaderMapper = SmartPtrAmqpHeaderMapper(),
+ SmartPtrAmqpHeaderMapper responseHeaderMapper = SmartPtrAmqpHeaderMapper());
+
+ gpointer execute(SmartPtrExecutor executor, gpointer data);
+
+private:
+ void doSend(
+ AmqpClient::SmartPtrChannel channel,
+ const std::string& exchange,
+ const std::string& routingKey,
+ SmartPtrIIntMessage message,
+ SmartPtrAmqpHeaderMapper headerMapper = SmartPtrAmqpHeaderMapper());
+
+ SmartPtrIIntMessage doSendAndReceive(
+ AmqpClient::SmartPtrChannel channel,
+ const std::string& exchange,
+ const std::string& routingKey,
+ SmartPtrIIntMessage message,
+ SmartPtrAmqpHeaderMapper requestHeaderMapper = SmartPtrAmqpHeaderMapper(),
+ SmartPtrAmqpHeaderMapper responseHeaderMapper = SmartPtrAmqpHeaderMapper());
+
+private:
+ typedef TBlockingCell<SmartPtrIIntMessage> SynchronousHandoff;
+ CAF_DECLARE_SMART_POINTER(SynchronousHandoff);
+
+ class DefaultConsumer : public AmqpClient::Consumer {
+ public:
+ DefaultConsumer();
+ virtual ~DefaultConsumer();
+
+ void init(
+ SmartPtrAmqpHeaderMapper mapper,
+ SmartPtrSynchronousHandoff handoff);
+
+ void handleConsumeOk(
+ const std::string& consumerTag);
+
+ void handleCancelOk(
+ const std::string& consumerTag);
+
+ void handleRecoverOk(
+ const std::string& consumerTag);
+
+ void handleDelivery(
+ const std::string& consumerTag,
+ const AmqpClient::SmartPtrEnvelope& envelope,
+ const AmqpClient::AmqpContentHeaders::SmartPtrBasicProperties& properties,
+ const SmartPtrCDynamicByteArray& body);
+
+ void handleShutdown(
+ const std::string& consumerTag,
+ SmartPtrCCafException& reason);
+
+ private:
+ SmartPtrAmqpHeaderMapper _mapper;
+ SmartPtrSynchronousHandoff _handoff;
+ };
+ CAF_DECLARE_SMART_POINTER(DefaultConsumer);
+
+private:
+ static std::string DEFAULT_EXCHANGE;
+ static std::string DEFAULT_ROUTING_KEY;
+ static int32 DEFAULT_REPLY_TIMEOUT;
+
+private:
+ bool _isInitialized;
+ std::string _exchange;
+ std::string _routingKey;
+ std::string _queue;
+ uint32 _replyTimeout;
+ SmartPtrConnectionFactory _connectionFactory;
+ SmartPtrConnection _connection;
+ SmartPtrAmqpHeaderMapper _headerMapper;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(RabbitTemplate);
+};
+CAF_DECLARE_SMART_POINTER(RabbitTemplate);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: May 25, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AMQPINTEGRATIONCORE_SIMPLECONNECTION_H_
+#define AMQPINTEGRATIONCORE_SIMPLECONNECTION_H_
+
+#include "amqpClient/api/Channel.h"
+#include "amqpClient/api/Connection.h"
+#include "amqpCore/Connection.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @ingroup IntObjImpl
+ * @brief A simple object that wraps a AmqpClient::Connection and exposes
+ * it as an AmqpIntegration::Connection.
+ */
+class AMQPINTEGRATIONCORE_LINKAGE SimpleConnection : public Connection {
+public:
+ SimpleConnection();
+ virtual ~SimpleConnection();
+
+ /**
+ * @brief Initialize the object with the given AmqpClient::Connection
+ * @param delegate the wrapped AmqpClient::Connection
+ */
+ void init(const AmqpClient::SmartPtrConnection& delegate);
+
+public: // Connection
+ AmqpClient::SmartPtrChannel createChannel();
+ void close();
+ bool isOpen();
+
+private:
+ AmqpClient::SmartPtrConnection _delegate;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(SimpleConnection);
+};
+CAF_DECLARE_SMART_POINTER(SimpleConnection);
+
+}}
+
+#endif
--- /dev/null
+/*
+ * Created on: Aug 1, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef SIMPLEMESSAGELISTENERCONTAINER_H_
+#define SIMPLEMESSAGELISTENERCONTAINER_H_
+
+
+
+#include "Integration/IErrorHandler.h"
+
+#include "Exception/CCafException.h"
+#include "Integration/Core/CSimpleAsyncTaskExecutor.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IThrowable.h"
+#include "amqpClient/api/Channel.h"
+#include "amqpCore/BlockingQueueConsumer.h"
+#include "amqpClient/api/ConnectionFactory.h"
+#include "amqpCore/MessageListener.h"
+#include "Integration/ILifecycle.h"
+#include "Integration/IRunnable.h"
+
+namespace Caf { namespace AmqpIntegration {
+
+/**
+ * @ingroup IntObjImpl
+ * @brief A simple message listener used by channels to retrieve messages
+ * <p>
+ * This container manages message acknowledgment, broker connection recoverability and
+ * other aspects of consuming from queues.
+ */
+class AMQPINTEGRATIONCORE_LINKAGE SimpleMessageListenerContainer :
+ public ILifecycle {
+public:
+ SimpleMessageListenerContainer();
+ virtual ~SimpleMessageListenerContainer();
+
+ /**
+ * @brief initialize the object
+ */
+ void init();
+
+ /**
+ * @brief initialize the object
+ * @param connectionFactory the ConnectionFactory
+ */
+ void init(
+ SmartPtrConnectionFactory connectionFactory);
+
+public:
+ /**
+ * @brief Set the message acknowledgment mode
+ * @param acknowledgeMode acknowledgment mode
+ */
+ void setAcknowledgeMode(AcknowledgeMode acknowledgeMode);
+
+ void setPrefetchCount(const uint32 prefetchCount);
+
+ void setReceiveTimeout(const uint32 receiveTimeout);
+
+ void setRecoveryInterval(const uint32 recoveryInterval);
+
+ void setTxSize(const uint32 txSize);
+
+ void setQueue(const std::string& queue);
+
+ void setConnectionFactory(SmartPtrConnectionFactory connectionFactory);
+
+ void setMessagerListener(SmartPtrMessageListener messageListener);
+
+ SmartPtrMessageListener getMessageListener();
+
+public: // ILifecycle
+ void start(const uint32 timeoutMs);
+
+ void stop(const uint32 timeoutMs);
+
+ bool isRunning() const;
+
+private:
+ void validateConfig();
+
+ bool isActive();
+
+ bool receiveAndExecute(SmartPtrBlockingQueueConsumer consumer);
+
+ void executeListener(
+ AmqpClient::SmartPtrChannel channel,
+ SmartPtrIIntMessage message);
+
+ void doInvokeListener(
+ SmartPtrIIntMessage message);
+
+ void restart();
+
+private:
+ typedef TBlockingCell<SmartPtrCCafException> StartupExceptionHandoff;
+ CAF_DECLARE_SMART_POINTER(StartupExceptionHandoff);
+
+private:
+ class AsyncMessageProcessingConsumer :
+ public IRunnable,
+ public IErrorHandler {
+ public:
+ AsyncMessageProcessingConsumer();
+ ~AsyncMessageProcessingConsumer();
+ void init(
+ SimpleMessageListenerContainer *parent,
+ SmartPtrBlockingQueueConsumer consumer,
+ SmartPtrStartupExceptionHandoff startupException,
+ const uint32 timeout,
+ const uint32 recoveryInterval);
+ void run();
+ void cancel();
+ void handleError(
+ const SmartPtrIThrowable& throwable,
+ const SmartPtrIIntMessage& message) const;
+
+ private:
+ void handleStartupFailure();
+
+ private:
+ SimpleMessageListenerContainer *_parent;
+ SmartPtrBlockingQueueConsumer _consumer;
+ SmartPtrStartupExceptionHandoff _startupException;
+ uint32 _timeout;
+ uint32 _recoveryInterval;
+ bool _isCanceled;
+
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(AsyncMessageProcessingConsumer);
+ };
+ CAF_DECLARE_SMART_POINTER(AsyncMessageProcessingConsumer);
+
+private:
+ bool _isInitialized;
+ volatile bool _isRunning;
+ volatile bool _isActive;
+ bool _debugTrace;
+ SmartPtrBlockingQueueConsumer _consumer;
+ SmartPtrCSimpleAsyncTaskExecutor _executor;
+ SmartPtrStartupExceptionHandoff _startupException;
+
+ SmartPtrConnectionFactory _connectionFactory;
+ SmartPtrMessageListener _messageListener;
+ std::string _queue;
+ AcknowledgeMode _acknowledgeMode;
+ uint32 _receiveTimeout;
+ uint32 _prefetchCount;
+ uint32 _txSize;
+ uint32 _recoveryInterval;
+
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(SimpleMessageListenerContainer);
+};
+CAF_DECLARE_SMART_POINTER(SimpleMessageListenerContainer);
+
+}}
+
+#endif /* SIMPLEMESSAGELISTENERCONTAINER_H_ */
*/
#include "stdafx.h"
-#include "AMQChannel.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/AMQCommand.h"
+#include "amqpClient/BlockingRpcContinuation.h"
+#include "amqpClient/CAmqpFrame.h"
+#include "amqpClient/ConsumerWorkService.h"
+#include "amqpClient/IConnectionInt.h"
+#include "amqpClient/IRpcContinuation.h"
+#include "amqpClient/TCopyOnWriteContainer.h"
+#include "amqpClient/amqpImpl/BasicAckMethod.h"
+#include "amqpClient/amqpImpl/BasicCancelMethod.h"
+#include "amqpClient/amqpImpl/BasicConsumeMethod.h"
+#include "amqpClient/amqpImpl/BasicGetMethod.h"
+#include "amqpClient/amqpImpl/BasicPublishMethod.h"
+#include "amqpClient/amqpImpl/BasicQosMethod.h"
+#include "amqpClient/amqpImpl/BasicRecoverMethod.h"
+#include "amqpClient/amqpImpl/BasicRejectMethod.h"
+#include "amqpClient/amqpImpl/ChannelCloseOkMethod.h"
+#include "amqpClient/amqpImpl/EnvelopeImpl.h"
+#include "amqpClient/amqpImpl/ExchangeDeclareMethod.h"
+#include "amqpClient/amqpImpl/ExchangeDeleteMethod.h"
+#include "amqpClient/amqpImpl/GetResponseImpl.h"
+#include "amqpClient/amqpImpl/IContentHeader.h"
+#include "amqpClient/amqpImpl/IMethod.h"
+#include "amqpClient/amqpImpl/IServerMethod.h"
+#include "amqpClient/amqpImpl/QueueBindMethod.h"
+#include "amqpClient/amqpImpl/QueueDeclareMethod.h"
+#include "amqpClient/amqpImpl/QueueDeleteMethod.h"
+#include "amqpClient/amqpImpl/QueuePurgeMethod.h"
+#include "amqpClient/amqpImpl/QueueUnbindMethod.h"
+#include "amqpClient/api/AmqpMethods.h"
+#include "amqpClient/api/Consumer.h"
+#include "amqpClient/api/GetResponse.h"
+#include "amqpClient/api/ReturnListener.h"
+#include "amqpClient/api/amqpClient.h"
+#include "amqpClient/AMQChannel.h"
+#include "Exception/CCafException.h"
+#include "Common/IAppConfig.h"
#include "AMQUtil.h"
-#include "BlockingRpcContinuation.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "AMQChannelManager.h"
+
+#include "amqpClient/AMQChannel.h"
+#include "amqpClient/ConsumerWorkService.h"
+#include "amqpClient/api/Channel.h"
+#include "amqpClient/AMQChannelManager.h"
+#include "Exception/CCafException.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "AMQCommand.h"
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/CAmqpFrame.h"
+#include "amqpClient/amqpImpl/IContentHeader.h"
+#include "amqpClient/amqpImpl/IMethod.h"
+#include "amqpClient/AMQCommand.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "AMQConnection.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/AMQChannelManager.h"
+#include "amqpClient/CAmqpConnection.h"
+#include "amqpClient/ConnectionWeakReference.h"
+#include "amqpClient/api/Address.h"
+#include "amqpClient/api/CertInfo.h"
+#include "amqpClient/api/Channel.h"
+#include "amqpClient/AMQConnection.h"
+#include "Exception/CCafException.h"
#include "AMQUtil.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
+
+#include "amqpClient/amqpImpl/FieldImpl.h"
+#include "amqpClient/api/amqpClient.h"
+#include "Exception/CCafException.h"
#include "AMQUtil.h"
using namespace Caf::AmqpClient;
#ifndef AMQUTIL_H_
#define AMQUTIL_H_
+
+#include "amqpClient/api/amqpClient.h"
+
namespace Caf { namespace AmqpClient {
/**
*/
#include "stdafx.h"
-#include "api/Address.h"
+#include "amqpClient/api/Address.h"
+#include "Exception/CCafException.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
+
+#include "amqpClient/CAmqpAuthMechanism.h"
+#include "AmqpAuthPlain.h"
#include "AmqpUtil.h"
using namespace Caf::AmqpClient;
#ifndef AMQPCORE_AMQPAUTHPLAIN_H_
#define AMQPCORE_AMQPAUTHPLAIN_H_
+
+#include "amqpClient/CAmqpAuthMechanism.h"
+
namespace Caf { namespace AmqpClient {
#define SHA256_HASH_LEN 32
*/
#include "stdafx.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/CAmqpFrame.h"
+#include "AmqpChannel.h"
#include "AmqpUtil.h"
using namespace Caf::AmqpClient;
#include "AmqpCommon.h"
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/CAmqpFrame.h"
+
namespace Caf { namespace AmqpClient {
/** AMQP channel state. */
*/
#include "stdafx.h"
+#include "Exception/CCafException.h"
#include "AmqpCommon.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/CAmqpAuthMechanism.h"
+#include "amqpClient/CAmqpConnection.h"
+#include "amqpClient/api/Address.h"
+#include "amqpClient/api/CertInfo.h"
#include "AmqpConnection.h"
using namespace Caf::AmqpClient;
#ifndef AMQPCORE_AMQPCONNECTION_H_
#define AMQPCORE_AMQPCONNECTION_H_
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/CAmqpAuthMechanism.h"
+#include "amqpClient/CAmqpConnection.h"
+#include "amqpClient/api/Address.h"
+#include "amqpClient/api/CertInfo.h"
+
namespace Caf { namespace AmqpClient {
/** Default maximum number of channels. */
*/
#include "stdafx.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
#include "AmqpUtil.h"
using namespace Caf::AmqpClient;
#ifndef AMQPCORE_AMQPUTIL_H_
#define AMQPCORE_AMQPUTIL_H_
+#include "amqpClient/CAmqpChannel.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+
namespace Caf { namespace AmqpClient {
class AmqpUtil {
*/
#include "stdafx.h"
-#include "BlockingRpcContinuation.h"
+
+#include "Exception/CCafException.h"
+#include "amqpClient/AMQCommand.h"
+#include "amqpClient/BlockingRpcContinuation.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "CAmqpAuthMechanism.h"
+#include "amqpClient/CAmqpAuthMechanism.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "CAmqpChannel.h"
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/CAmqpConnection.h"
+#include "amqpClient/CAmqpFrame.h"
+#include "amqpClient/CAmqpChannel.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "CAmqpConnection.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/CAmqpAuthMechanism.h"
+#include "amqpClient/CAmqpFrame.h"
+#include "amqpClient/api/Address.h"
+#include "amqpClient/api/CertInfo.h"
+#include "amqpClient/CAmqpConnection.h"
+#include "Exception/CCafException.h"
using namespace Caf::AmqpClient;
const SmartPtrCertInfo& certInfo,
const uint16 channelMax,
const uint32 frameMax,
- const uint16 heartbeat,
+ const uint16 heartbeat,
const uint16 retries,
const uint16 secondsToWait) {
CAF_CM_FUNCNAME("connectionCreate");
*/
#include "stdafx.h"
-#include "CAmqpFrame.h"
+#include "amqpClient/CAmqpFrame.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "api/CertInfo.h"
+#include "amqpClient/api/CertInfo.h"
using namespace Caf::AmqpClient;
* -- VMware Confidential
*/
#include "stdafx.h"
-#include "CommandAssembler.h"
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/CAmqpFrame.h"
+#include "amqpClient/amqpImpl/IContentHeader.h"
+#include "amqpClient/amqpImpl/IMethod.h"
+#include "amqpClient/CommandAssembler.h"
+#include "Exception/CCafException.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "ConnectionFactoryImpl.h"
-#include "AMQConnection.h"
+
+#include "amqpClient/AMQConnection.h"
+#include "amqpClient/api/Address.h"
+#include "amqpClient/api/CertInfo.h"
+#include "amqpClient/api/Connection.h"
+#include "amqpClient/api/ConnectionFactory.h"
+#include "amqpClient/ConnectionFactoryImpl.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "ConnectionWeakReference.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/ConnectionWeakReference.h"
+#include "Exception/CCafException.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "ConsumerDispatcher.h"
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/ConsumerWorkService.h"
+#include "amqpClient/api/Consumer.h"
+#include "amqpClient/api/Envelope.h"
+#include "amqpClient/ConsumerDispatcher.h"
+#include "Exception/CCafException.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "ConsumerWorkService.h"
+
+#include "Common/CManagedThreadPool.h"
+#include "amqpClient/ConsumerWorkService.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
+#include "amqpClient/api/amqpClient.h"
namespace Caf {
namespace AmqpClient {
*/
#include "stdafx.h"
-#include "../api/AMQExceptions.h"
+#include "amqpClient/api/AMQExceptions.h"
using namespace Caf::AmqpClient::AmqpExceptions;
*/
#include "stdafx.h"
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "amqpClient/CAmqpFrame.h"
+#include "amqpClient/amqpImpl/IContentHeader.h"
+#include "amqpClient/amqpImpl/IMethod.h"
+#include "Exception/CCafException.h"
#include "AMQPImpl.h"
#include "amqpImplInt.h"
#ifndef AMQPIMPL_H_
#define AMQPIMPL_H_
+
+#include "amqpClient/amqpImpl/IContentHeader.h"
+#include "amqpClient/amqpImpl/IMethod.h"
+
namespace Caf { namespace AmqpClient {
/**
#include "stdafx.h"
+#include "amqpClient/amqpImpl/FieldImpl.h"
+#include "amqpClient/api/amqpClient.h"
+#include "Exception/CCafException.h"
+
using namespace Caf;
using namespace Caf::AmqpClient;
#include "stdafx.h"
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "amqpClient/api/amqpClient.h"
+
using namespace Caf::AmqpClient;
const uint32 AmqpContentHeaders::BASIC_PROPERTY_CONTENT_TYPE_FLAG = 0x8000;
*/
#include "stdafx.h"
-#include "BasicAckMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/amqpImpl/BasicAckMethod.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "BasicCancelMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/amqpImpl/BasicCancelMethod.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "BasicConsumeMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/api/amqpClient.h"
+#include "amqpClient/amqpImpl/BasicConsumeMethod.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "BasicGetMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/amqpImpl/BasicGetMethod.h"
using namespace Caf::AmqpClient;
#ifndef BASICGETOKMETHOD_H_
#define BASICGETOKMETHOD_H_
+#include "amqpClient/api/AmqpMethods.h"
+
namespace Caf { namespace AmqpClient {
/**
*/
#include "stdafx.h"
-#include "BasicProperties.h"
+
+#include "amqpClient/CAmqpFrame.h"
+#include "amqpClient/api/amqpClient.h"
+#include "Exception/CCafException.h"
+#include "amqpClient/amqpImpl/BasicProperties.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "BasicPublishMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/amqpImpl/BasicPublishMethod.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "BasicQosMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/amqpImpl/BasicQosMethod.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "BasicRecoverMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/amqpImpl/BasicRecoverMethod.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "BasicRejectMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/amqpImpl/BasicRejectMethod.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "ChannelCloseOkMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/amqpImpl/ChannelCloseOkMethod.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
#include "ChannelOpenOkMethod.h"
using namespace Caf::AmqpClient;
#ifndef CHANNELOPENOKMETHOD_H_
#define CHANNELOPENOKMETHOD_H_
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+
namespace Caf { namespace AmqpClient {
/**
* @author mdonahue
*/
#include "stdafx.h"
-#include "EnvelopeImpl.h"
+#include "amqpClient/amqpImpl/EnvelopeImpl.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "ExchangeDeclareMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/api/amqpClient.h"
+#include "amqpClient/amqpImpl/ExchangeDeclareMethod.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "ExchangeDeleteMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/amqpImpl/ExchangeDeleteMethod.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "FieldImpl.h"
+#include "amqpClient/amqpImpl/FieldImpl.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "GetResponseImpl.h"
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/api/Envelope.h"
+#include "amqpClient/amqpImpl/GetResponseImpl.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "QueueBindMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/api/amqpClient.h"
+#include "amqpClient/amqpImpl/QueueBindMethod.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "QueueDeclareMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/api/amqpClient.h"
+#include "amqpClient/amqpImpl/QueueDeclareMethod.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "QueueDeleteMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/amqpImpl/QueueDeleteMethod.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "QueuePurgeMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/amqpImpl/QueuePurgeMethod.h"
using namespace Caf::AmqpClient;
*/
#include "stdafx.h"
-#include "QueueUnbindMethod.h"
+
+#include "amqpClient/CAmqpChannel.h"
+#include "amqpClient/api/amqpClient.h"
+#include "amqpClient/amqpImpl/QueueUnbindMethod.h"
using namespace Caf::AmqpClient;
#ifndef TMETHODIMPL_H_
#define TMETHODIMPL_H_
+
+#include "amqpClient/amqpImpl/IMethod.h"
+
namespace Caf { namespace AmqpClient {
/**
using namespace Caf::AmqpClient;
-#include "IMethod.h"
#include "TMethodImpl.h"
-#include "IContentHeader.h"
-#include "IServerMethod.h"
#include "AMQPImpl.h"
-#include "FieldImpl.h"
-#include "EnvelopeImpl.h"
-#include "GetResponseImpl.h"
-#include "BasicProperties.h"
-#include "BasicAckMethod.h"
-#include "BasicGetMethod.h"
+#include "amqpClient/amqpImpl/BasicProperties.h"
#include "BasicGetOkMethod.h"
#include "BasicGetEmptyMethod.h"
-#include "BasicPublishMethod.h"
-#include "BasicConsumeMethod.h"
#include "BasicConsumeOkMethod.h"
#include "BasicDeliverMethod.h"
-#include "BasicCancelMethod.h"
#include "BasicCancelOkMethod.h"
#include "BasicReturnMethod.h"
-#include "BasicRecoverMethod.h"
#include "BasicRecoverOkMethod.h"
-#include "BasicQosMethod.h"
#include "BasicQosOkMethod.h"
-#include "BasicRejectMethod.h"
#include "ChannelOpenOkMethod.h"
#include "ChannelCloseMethod.h"
-#include "ChannelCloseOkMethod.h"
#include "ChannelCloseOkFromServerMethod.h"
-#include "ExchangeDeclareMethod.h"
#include "ExchangeDeclareOkMethod.h"
-#include "ExchangeDeleteMethod.h"
#include "ExchangeDeleteOkMethod.h"
-#include "QueueDeclareMethod.h"
#include "QueueDeclareOkMethod.h"
-#include "QueueDeleteMethod.h"
#include "QueueDeleteOkMethod.h"
-#include "QueuePurgeMethod.h"
#include "QueuePurgeOkMethod.h"
-#include "QueueBindMethod.h"
#include "QueueBindOkMethod.h"
-#include "QueueUnbindMethod.h"
#include "QueueUnbindOkMethod.h"
#endif
#ifndef STDAFX_H_
#define STDAFX_H_
-#include "AmqpClientLink.h"
+#include "amqpClient/AmqpClientLink.h"
#include <CommonDefines.h>
-#include "api/amqpClient.h"
//extern "C" {
#include <amqp_tcp_socket.h>
}}
#include "AmqpCommon.h"
-#include "CAmqpFrame.h"
-#include "CAmqpAuthMechanism.h"
-#include "CAmqpChannel.h"
-#include "CAmqpConnection.h"
+#include "amqpClient/CAmqpChannel.h"
#include "AmqpConnection.h"
#include "AmqpAuthPlain.h"
*/
#include "stdafx.h"
-#include "AbstractConnectionFactory.h"
+
+#include "amqpClient/api/Connection.h"
+#include "amqpCore/ConnectionListener.h"
+#include "amqpCore/SimpleConnection.h"
+#include "amqpCore/AbstractConnectionFactory.h"
using namespace Caf::AmqpIntegration;
*/
#include "stdafx.h"
-#include "AmqpHeaderMapper.h"
+#include "amqpCore/AmqpHeaderMapper.h"
using namespace Caf::AmqpIntegration;
#ifndef AMQPINTEGRATIONCOREFUNC_H_
#define AMQPINTEGRATIONCOREFUNC_H_
-#include "Queue.h"
-#include "Exchange.h"
-#include "Binding.h"
+
+
+#include "amqpCore/Binding.h"
+#include "amqpCore/Exchange.h"
+#include "amqpCore/Queue.h"
namespace Caf {
#ifndef AMQPINTEGRATIONCORE_AMQPINTEGRATIONEXCEPTIONS_H_
#define AMQPINTEGRATIONCORE_AMQPINTEGRATIONEXCEPTIONS_H_
+#include "amqpClient/api/AMQExceptions.h"
+
namespace Caf { namespace AmqpIntegration {
/**
*/
#include "stdafx.h"
-#include "AmqpMessageListenerSource.h"
+
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/Dependencies/CPollerMetadata.h"
+#include "Integration/IIntMessage.h"
+#include "amqpCore/AmqpHeaderMapper.h"
+#include "amqpCore/AmqpMessageListenerSource.h"
+#include "Exception/CCafException.h"
using namespace Caf::AmqpIntegration;
*/
#include "stdafx.h"
-#include "AmqpOutboundEndpoint.h"
-#include "DefaultAmqpHeaderMapper.h"
+
+#include "Common/IAppConfig.h"
+#include "Common/IAppContext.h"
+#include "IVariant.h"
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "amqpCore/AmqpTemplate.h"
+#include "amqpCore/DefaultAmqpHeaderMapper.h"
+#include "Exception/CCafException.h"
+#include "amqpCore/AmqpOutboundEndpoint.h"
+#include "Integration/Core/MessageHeaders.h"
using namespace Caf::AmqpIntegration;
*/
#include "stdafx.h"
+
+#include "amqpClient/api/Channel.h"
#include "AutoChannelClose.h"
using namespace Caf::AmqpIntegration;
#ifndef AMQPINTEGRATIONCORE_AUTOCHANNELCLOSE_H_
#define AMQPINTEGRATIONCORE_AUTOCHANNELCLOSE_H_
+
+#include "amqpClient/api/Channel.h"
+
namespace Caf { namespace AmqpIntegration {
/**
*/
#include "stdafx.h"
-#include "Binding.h"
-#include "BindingImpl.h"
+
+#include "amqpCore/Binding.h"
+#include "amqpCore/BindingImpl.h"
using namespace Caf::AmqpIntegration;
*/
#include "stdafx.h"
-#include "BlockingQueueConsumer.h"
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/api/Channel.h"
+#include "amqpClient/api/Envelope.h"
+#include "amqpCore/AmqpHeaderMapper.h"
+#include "amqpClient/api/ConnectionFactory.h"
+#include "amqpCore/BlockingQueueConsumer.h"
+#include "Integration/Core/CIntException.h"
+#include "Exception/CCafException.h"
using namespace Caf::AmqpIntegration;
*/
#include "stdafx.h"
-#include "CachingConnectionFactory.h"
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Exception/CCafException.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/api/AmqpMethods.h"
+#include "amqpClient/api/Channel.h"
+#include "amqpClient/api/Consumer.h"
+#include "amqpClient/api/GetResponse.h"
+#include "amqpClient/api/ReturnListener.h"
+#include "amqpClient/api/amqpClient.h"
+#include "amqpCore/CachingConnectionFactory.h"
using namespace Caf::AmqpIntegration;
*/
#include "stdafx.h"
-#include "CachingConnectionFactory.h"
+
+#include "amqpClient/api/Channel.h"
+#include "amqpClient/api/Connection.h"
+#include "amqpCore/ChannelProxy.h"
+#include "amqpCore/ConnectionListener.h"
+#include "amqpCore/CachingConnectionFactory.h"
using namespace Caf::AmqpIntegration;
*/
#include "stdafx.h"
-#include "CachingConnectionFactory.h"
+
+#include "amqpClient/api/Channel.h"
+#include "amqpClient/api/Connection.h"
+#include "amqpCore/CachingConnectionFactory.h"
using namespace Caf::AmqpIntegration;
*/
#include "stdafx.h"
-#include "CompositeConnectionListener.h"
+
+#include "amqpClient/api/Connection.h"
+#include "amqpCore/CompositeConnectionListener.h"
using namespace Caf::AmqpIntegration;
*/
#include "stdafx.h"
-#include "DefaultAmqpHeaderMapper.h"
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Common/CVariant.h"
+#include "Integration/IIntMessage.h"
+#include "amqpClient/api/Envelope.h"
+#include "amqpClient/api/amqpClient.h"
+#include "amqpCore/DefaultAmqpHeaderMapper.h"
+#include "Integration/Core/CIntMessageHeaders.h"
+#include "Exception/CCafException.h"
#include "HeaderUtils.h"
using namespace Caf::AmqpIntegration;
*/
#include "stdafx.h"
-#include "Exchange.h"
-#include "ExchangeImpl.h"
+
+#include "amqpCore/Exchange.h"
+#include "amqpCore/ExchangeImpl.h"
using namespace Caf::AmqpIntegration;
*/
#include "stdafx.h"
+
+#include "Common/CVariant.h"
+#include "Integration/IIntMessage.h"
#include "HeaderUtils.h"
using namespace Caf::AmqpIntegration;
#ifndef AMQPINTEGRATIONCORE_HEADERUTILS_H_
#define AMQPINTEGRATIONCORE_HEADERUTILS_H_
+#include "Common/CVariant.h"
+#include "Integration/IIntMessage.h"
+
namespace Caf { namespace AmqpIntegration {
/**
*/
#include "stdafx.h"
-#include "Queue.h"
-#include "QueueImpl.h"
+
+#include "amqpCore/Queue.h"
+#include "amqpCore/QueueImpl.h"
using namespace Caf::AmqpIntegration;
*/
#include "stdafx.h"
-#include "RabbitAdmin.h"
+
+#include "Common/CVariant.h"
+#include "amqpClient/api/AmqpMethods.h"
+#include "amqpClient/api/Channel.h"
+#include "amqpCore/Binding.h"
+#include "amqpClient/api/ConnectionFactory.h"
+#include "amqpCore/Exchange.h"
+#include "amqpCore/Queue.h"
+#include "amqpCore/RabbitAdmin.h"
using namespace Caf::AmqpIntegration;
*/
#include "stdafx.h"
-#include "RabbitTemplate.h"
+
+#include "amqpClient/amqpImpl/BasicProperties.h"
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "amqpClient/api/AmqpMethods.h"
+#include "amqpClient/api/Channel.h"
+#include "amqpClient/api/Envelope.h"
+#include "amqpClient/api/GetResponse.h"
+#include "amqpCore/AmqpHeaderMapper.h"
+#include "amqpCore/AmqpTemplate.h"
+#include "amqpClient/api/ConnectionFactory.h"
+#include "amqpCore/DefaultAmqpHeaderMapper.h"
+#include "amqpCore/RabbitTemplate.h"
+#include "Exception/CCafException.h"
#include "AutoChannelClose.h"
-#include "DefaultAmqpHeaderMapper.h"
using namespace Caf::AmqpIntegration;
*/
#include "stdafx.h"
-#include "SimpleConnection.h"
+
+#include "amqpClient/api/Channel.h"
+#include "amqpCore/SimpleConnection.h"
using namespace Caf::AmqpIntegration;
*/
#include "stdafx.h"
-#include "SimpleMessageListenerContainer.h"
-#include "DefaultAmqpHeaderMapper.h"
+
+#include "Integration/IIntMessage.h"
+#include "Integration/IThrowable.h"
+#include "amqpClient/api/Channel.h"
+#include "amqpCore/BlockingQueueConsumer.h"
+#include "amqpClient/api/ConnectionFactory.h"
+#include "amqpCore/DefaultAmqpHeaderMapper.h"
+#include "amqpCore/MessageListener.h"
+#include "amqpCore/SimpleMessageListenerContainer.h"
+#include "Integration/Core/CIntException.h"
+#include "Exception/CCafException.h"
using namespace Caf::AmqpIntegration;
#endif
#endif
-#include "../amqpClient/api/amqpClient.h"
-#include "Exchange.h"
-#include "ExchangeImpl.h"
-#include "Queue.h"
-#include "QueueImpl.h"
-#include "Binding.h"
-#include "BindingImpl.h"
-#include "ExchangeInternal.h"
-#include "QueueInternal.h"
-#include "BindingInternal.h"
-#include "AbstractConnectionFactory.h"
-#include "AmqpAdmin.h"
-#include "AmqpHeaderMapper.h"
#include "AmqpIntegrationCoreDefines.h"
#include "AmqpIntegrationCoreFunc.h"
#include "AmqpIntegrationExceptions.h"
-#include "AmqpMessageListenerSource.h"
-#include "AmqpOutboundEndpoint.h"
-#include "AmqpTemplate.h"
+#include "amqpCore/AmqpOutboundEndpoint.h"
#include "AutoChannelClose.h"
-#include "BlockingQueueConsumer.h"
-#include "CachingConnectionFactory.h"
-#include "Connection.h"
-#include "ConnectionFactory.h"
-#include "ConnectionListener.h"
-#include "ConnectionProxy.h"
-#include "DefaultAmqpHeaderMapper.h"
#include "HeaderUtils.h"
-#include "MessageListener.h"
-#include "RabbitAdmin.h"
-#include "RabbitTemplate.h"
-#include "SimpleConnection.h"
-#include "SimpleMessageListenerContainer.h"
#endif /* AMQPINTEGRATIONCORELINK_H_ */
#include <CommonDefines.h>
#include <Integration.h>
-#include "../amqpClient/api/amqpClient.h"
#include "AmqpIntegrationCoreFunc.h"
#include "AmqpIntegrationCoreDefines.h"
#include "AmqpIntegrationExceptions.h"
--- /dev/null
+/*
+ * Created on: Aug 20, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef AmqpListenerWorker_h
+#define AmqpListenerWorker_h
+
+#include "Common/CThreadSignal.h"
+#include "Common/IWork.h"
+
+namespace Caf {
+
+class AmqpListenerWorker :
+ public IWork
+{
+public:
+ AmqpListenerWorker();
+ virtual ~AmqpListenerWorker();
+
+ void doWork();
+ void stopWork();
+
+private:
+ CThreadSignal _stopSignal;
+ CAF_THREADSIGNAL_CREATE;
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(AmqpListenerWorker);
+};
+CAF_DECLARE_SMART_POINTER(AmqpListenerWorker);
+}
+
+#endif /* AmqpListenerWorker_h */
#define NOMINMAX
#include "stdafx.h"
+
+#include "Integration/Core/CIntegrationAppContext.h"
#include "AmqpListenerWorker.h"
+#include "Common/CLoggingUtils.h"
+#include "amqpClient/api/AMQExceptions.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "AmqpListenerWorker.h"
+#include "Common/CLoggingUtils.h"
+#include "Exception/CCafException.h"
+#include "Common/IAppConfig.h"
#ifndef WIN32
#include <syslog.h>
#endif
-#include "AmqpListenerWorker.h"
bool _gDaemonized = true;
bool _gSysLogInfos = false;
CWinService::initialize(_gAmqpListenerWorker);
CWinService::execute(argc, argv);
#else
- const std::string procPath = argv[0];
+ const std::string procPath(reinterpret_cast<const char*>(argv[0]));
Cdeqstr parts = CStringUtils::split(procPath, G_DIR_SEPARATOR);
std::string procName = "CommAmqpListener";
if (parts.size()) {
#include "CWinService.h"
#endif
-#include "../../amqpCore/src/amqpClient/api/amqpClient.h"
#endif /* stdafx_h */
#include <typeinfo>
#include <stdexcept>
-#include "../src/BasePlatformLink.h"
+#include "BasePlatformLink.h"
#endif /* SYS_INC_BASEDEFINES_H_ */
--- /dev/null
+/*
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef BasePlatformInc_h_
+#define BasePlatformInc_h_
+
+#ifndef BASEPLATFORM_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define BASEPLATFORM_LINKAGE __declspec(dllexport)
+ #else
+ #define BASEPLATFORM_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define BASEPLATFORM_LINKAGE
+ #endif
+#endif
+
+#include "PlatformTypes.h"
+#include "PlatformDefines.h"
+#include "PlatformErrors.h"
+#include "PlatformIID.h"
+#include "PlatformStringFunc.h"
+#include "ICafObject.h"
+#include "TCafObject.h"
+#include "TCafQIObject.h"
+#include "TCafSmartPtr.h"
+#include "TCafStackObject.h"
+
+CAF_DECLARE_SMART_INTERFACE_POINTER(ICafObject);
+
+#endif
--- /dev/null
+/*
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef BasePlatformLink_h_
+#define BasePlatformLink_h_
+
+#include "BasePlatformInc.h"
+
+#include <deque>
+#include <vector>
+#include <set>
+#include <list>
+#include <map>
+
+namespace Caf {
+
+// Basic string containers
+typedef std::deque<std::string> Cdeqstr;
+typedef std::set<std::string> Csetstr;
+typedef std::vector<std::string> Cvecstr;
+typedef std::map<std::string, std::string> Cmapstrstr;
+typedef std::multimap<std::string, std::string> Cmmapstrstr;
+CAF_DECLARE_SMART_POINTER(Cdeqstr);
+CAF_DECLARE_SMART_POINTER(Csetstr);
+CAF_DECLARE_SMART_POINTER(Cvecstr);
+CAF_DECLARE_SMART_POINTER(Cmapstrstr);
+CAF_DECLARE_SMART_POINTER(Cmmapstrstr);
+
+// GUID containers
+typedef std::vector<GUID> Cvecguid;
+typedef std::deque<GUID> Cdeqguid;
+CAF_DECLARE_SMART_POINTER(Cvecguid);
+CAF_DECLARE_SMART_POINTER(Cdeqguid);
+
+struct SGuidLessThan
+{
+ bool operator()(const GUID clhs, const GUID crhs) const
+ {
+ return ::memcmp(&clhs, &crhs, sizeof(GUID)) < 0;
+ }
+};
+
+typedef std::set<GUID, SGuidLessThan> Csetguid;
+CAF_DECLARE_SMART_POINTER(Csetguid);
+
+// class to extract first part of a pair
+template <typename T>
+struct select1st
+{
+ typename T::first_type operator()(const T & p) const { return p.first; }
+};
+
+// template function to make use of select1st easy.
+// T is a container whose value_type is a pair
+template <typename T>
+select1st<typename T::value_type> make_select1st(const T &) { return select1st<typename T::value_type>(); };
+
+// class to extract second part of a pair
+template <typename T>
+struct select2nd
+{
+ typename T::second_type operator()(const T & p) const { return p.second; }
+};
+
+// template function to make use of select2nd easy.
+// T is a container whose value_type is a pair
+template <typename T>
+select2nd<typename T::value_type> make_select2nd(const T &) { return select2nd<typename T::value_type>(); };
+
+}
+
+#ifdef WIN32
+#include "PlatformApi.h"
+#endif
+
+#endif
+
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Jul 2009
+ *
+ * Copyright (c) 2009-2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CApplicationContext_h_
+#define CApplicationContext_h_
+
+
+#include "Common/IAppContext.h"
+
+#include "IBean.h"
+
+namespace Caf {
+
+CAF_DECLARE_CLASS_AND_SMART_POINTER( CApplicationContext);
+
+class COMMONAGGREGATOR_LINKAGE CApplicationContext : public IAppContext {
+private:
+ // Bean constructor arguments
+ struct CBeanCtorArg {
+ typedef enum {
+ NOT_SET,
+ REFERENCE,
+ VALUE
+ } ARG_TYPE;
+
+ CBeanCtorArg(const ARG_TYPE type, const std::string& value) :
+ _type(type),
+ _value(value) {}
+
+ ARG_TYPE _type;
+ std::string _value;
+ };
+
+ // key=constructor-arg index
+ typedef std::map<uint32, CBeanCtorArg> CBeanCtorArgCollection;
+
+ struct CBeanNode {
+ CBeanNode() :
+ _isInitialized(false) {}
+
+ std::string _id;
+ std::string _class;
+ SmartPtrIBean _bean;
+ CBeanCtorArgCollection _ctorArgs;
+ Cmapstrstr _properties;
+ bool _isInitialized;
+ };
+ CAF_DECLARE_SMART_POINTER(CBeanNode);
+
+ struct CBeanNodeLess {
+ bool operator()(
+ const SmartPtrCBeanNode& lhs,
+ const SmartPtrCBeanNode& rhs) const {
+ return std::less<std::string>()(lhs->_id, rhs->_id);
+ }
+ };
+
+ typedef TEdgeListGraph<SmartPtrCBeanNode, CBeanNodeLess> CBeanGraph;
+
+ // key=bean id
+ typedef std::map<std::string, SmartPtrCBeanNode> CBeanCollection;
+
+public:
+ CApplicationContext();
+ virtual ~CApplicationContext();
+
+public:
+ void initialize();
+ void initialize(const Cdeqstr& filenameCollection);
+
+ void terminate();
+
+ SmartPtrCBeans getBeans() const;
+
+public: // IApplicationContext
+ SmartPtrIBean getBean(const std::string& name) const;
+
+private:
+ bool m_isInitialized;
+ CBeanCollection _beanCollection;
+ CBeanGraph::ClistVertexEdges _beanTopologySort;
+ Cdeqstr _filenameCollection;
+
+private:
+ std::string getDefaultBeanConfigFile() const;
+
+ void parseBeanConfig(
+ const std::string& beanConfigFile,
+ CBeanCollection& beanCollection) const;
+
+ void createBeanGraph(
+ CBeanCollection& beanCollection,
+ CBeanGraph& beanGraph,
+ CBeanGraph::ClistVertexEdges& beanTopologySort) const;
+
+ void initializeBeans(
+ CBeanCollection& beanCollection,
+ CBeanGraph::ClistVertexEdges& beanTopologySort) const;
+
+ void terminateBeans(CBeanGraph::ClistVertexEdges& beanTopologySort) const;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CApplicationContext);
+};
+
+}
+
+#endif // #ifndef CApplicationContext_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 29, 2014
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CAUTOCONDITION_H_
+#define CAUTOCONDITION_H_
+
+#include "Common/CAutoCondition.h"
+
+#include "Common/CAutoMutex.h"
+
+namespace Caf {
+
+class COMMONAGGREGATOR_LINKAGE CAutoCondition {
+public:
+ CAutoCondition();
+ ~CAutoCondition();
+
+ void initialize(const std::string& name);
+ bool isInitialized() const;
+
+ void close();
+
+ std::string getName() const;
+
+ void signal();
+ void wait(SmartPtrCAutoMutex& mutex);
+ bool waitUntil(SmartPtrCAutoMutex& mutex, gint64 endTime);
+
+private:
+ GCond _condition;
+ std::string _name;
+ bool _isInitialized;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CAutoCondition);
+};
+CAF_DECLARE_SMART_POINTER(CAutoCondition);
+}
+
+#endif /* CAUTOCONDITION_H_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 29, 2014
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CAUTOMUTEX_H_
+#define CAUTOMUTEX_H_
+
+namespace Caf {
+
+class COMMONAGGREGATOR_LINKAGE CAutoMutex {
+public:
+ CAutoMutex();
+ ~CAutoMutex();
+
+ void initialize();
+ bool isInitialized() const;
+
+ void lock(const char* className = NULL, const char* funcName = NULL, const int32 lineNumber = 0);
+ void unlock(const char* className = NULL, const char* funcName = NULL, const int32 lineNumber = 0);
+
+ GMutex* getNonConstPtr();
+
+private:
+ GMutex _mutex;
+ bool _isInitialized;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CAutoMutex);
+};
+CAF_DECLARE_SMART_POINTER(CAutoMutex);
+
+}
+
+#endif /* CAUTOMUTEX_H_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 29, 2014
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CAUTORECMUTEX_H_
+#define CAUTORECMUTEX_H_
+
+namespace Caf {
+
+class COMMONAGGREGATOR_LINKAGE CAutoRecMutex {
+public:
+ CAutoRecMutex();
+ ~CAutoRecMutex();
+
+ void initialize();
+ bool isInitialized() const;
+
+ void lock(const char* className = NULL, const char* funcName = NULL, const int32 lineNumber = 0);
+ void unlock(const char* className = NULL, const char* funcName = NULL, const int32 lineNumber = 0);
+
+ GRecMutex* getNonConstPtr();
+
+private:
+ GRecMutex _mutex;
+ bool _isInitialized;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CAutoRecMutex);
+};
+CAF_DECLARE_SMART_POINTER(CAutoRecMutex);
+
+}
+
+#endif /* CAUTORECMUTEX_H_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Jan 21, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CCAFREGEX_H_
+#define CCAFREGEX_H_
+
+#include "Common/CCafRegex.h"
+
+namespace Caf {
+
+class COMMONAGGREGATOR_LINKAGE CCafRegex {
+public:
+ CCafRegex();
+ virtual ~CCafRegex();
+
+public:
+ void initialize(const std::string& regex);
+
+ bool isMatched(const std::string& source);
+
+ std::map<std::string, std::string> matchNames(
+ const std::string& source,
+ const std::set<std::string>& names);
+
+ std::deque<std::string> matchName(
+ const std::string& source,
+ const std::string& name);
+
+ std::string match(
+ const std::string& source,
+ const int32 matchNum);
+
+ std::string replaceLiteral(
+ const std::string& source,
+ const std::string& replacement);
+
+public:
+ static std::string replaceLiteral(
+ const std::string& regex,
+ const std::string& source,
+ const std::string& replacement);
+
+private:
+ bool _isInitialized;
+ GRegex* _gRegex;
+ std::string _regex;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CCafRegex);
+};
+
+CAF_DECLARE_SMART_POINTER(CCafRegex);
+
+}
+
+#endif /* CCAFREGEX_H_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Jul 2009
+ *
+ * Copyright (c) 2009-2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CCmdLineOptions_h_
+#define CCmdLineOptions_h_
+
+namespace Caf {
+
+class COMMONAGGREGATOR_LINKAGE CCmdLineOptions {
+private:
+ typedef std::map<std::string, gchar*> CStringOptions;
+ typedef std::map<std::string, gint> CIntOptions;
+ typedef std::map<std::string, gboolean> CBoolOptions;
+
+public:
+ CCmdLineOptions();
+ virtual ~CCmdLineOptions();
+
+public:
+ void initialize(const std::string& cmdDescription, const uint32 maxOptions);
+ void parse(int32 argc, char* argv[]);
+
+ void addStringOption(const std::string& longName, const char shortName, const std::string& optionDescription);
+ void addIntOption(const std::string& longName, const char shortName, const std::string& optionDescription);
+ void addBoolOption(const std::string& longName, const char shortName, const std::string& optionDescription);
+
+ std::string findStringOption(const std::string& longName);
+ int32 findIntOption(const std::string& longName);
+ bool findBoolOption(const std::string& longName);
+
+private:
+ bool _isInitialized;
+ uint32 _optionCnt;
+ std::string _cmdDescription;
+
+ uint32 _maxOptions;
+ GOptionEntry* _gOptions;
+
+ CStringOptions _stringOptions;
+ CIntOptions _intOptions;
+ CBoolOptions _boolOptions;
+
+ // Temporary for storing longNames and optionDescription for addFooOption() methods above.
+ std::vector<std::string> _longNames, _optionDescriptions;
+
+private:
+ void checkOptionCnt(
+ const std::string& longName,
+ const uint32 optionCnt,
+ const uint32 maxOptions) const;
+ void populateOption(
+ GOptionEntry& optionEntry,
+ const std::string& longName,
+ const char shortName,
+ const std::string& optionDescription);
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CCmdLineOptions);
+};
+
+CAF_DECLARE_SMART_POINTER( CCmdLineOptions);
+
+}
+
+#endif // #ifndef CCmdLineOptions_h_
--- /dev/null
+/*
+ * Author: mdonahue
+ * Created: Jan 17, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CCONFIGPARAMS_H_
+#define CCONFIGPARAMS_H_
+
+#include "Common/IConfigParams.h"
+
+namespace Caf {
+
+/*
+ * This class wraps a GHashTable object where the key is a const char* and
+ * the value is a GVariant*.
+ *
+ * The key and value pointers inserted must exist for the lifetime of this object.
+ * Use the EKeyManagement and EValueMangement flags to control how this
+ * object destroys the contained hash table.
+ *
+ */
+class COMMONAGGREGATOR_LINKAGE CConfigParams : public IConfigParams {
+public:
+ typedef enum {
+ EKeysUnmanaged, // Set if the caller will manage the lifetime of the keys
+ EKeysManaged // Set if this object is to detroy the keys upon destruction
+ } EKeyManagement;
+
+ typedef enum {
+ EValuesUnmanaged, // Set if the caller will manage the lifetime of the values
+ EValuesManaged // Set if this object is to detroy the values upon destruction
+ } EValueManagement;
+
+ CConfigParams();
+ virtual ~CConfigParams();
+
+ void initialize(
+ const std::string& sectionName,
+ EKeyManagement keyManagement,
+ EValueManagement valueManagement);
+
+public: // IConfigParams
+ GVariant* lookup(
+ const char* key,
+ const EParamDisposition disposition = PARAM_REQUIRED) const;
+
+ std::string getSectionName() const;
+
+ void insert(const char* key, GVariant* value);
+
+private:
+ static void destroyKeyCallback(gpointer ptr);
+ static void destroyValueCallback(gpointer ptr);
+
+private:
+ std::string _sectionName;
+ GHashTable* _table;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CConfigParams);
+};
+
+CAF_DECLARE_SMART_POINTER(CConfigParams);
+
+}
+
+#endif /* CCONFIGPARAMS_H_ */
--- /dev/null
+/*
+ * Author: mdonahue
+ * Created: Jan 17, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CCONFIGPARAMSCHAIN_H_
+#define CCONFIGPARAMSCHAIN_H_
+
+#include "Common/IConfigParams.h"
+
+#include "Common/CConfigParams.h"
+
+namespace Caf {
+
+class COMMONAGGREGATOR_LINKAGE CConfigParamsChain : public IConfigParams {
+public:
+ CConfigParamsChain();
+ virtual ~CConfigParamsChain();
+
+ void initialize(CConfigParams::EKeyManagement keyManagement,
+ CConfigParams::EValueManagement valueManagement,
+ const SmartPtrIConfigParams& baseParams);
+
+ void insert(const char* key, GVariant* value);
+
+public: // IConfigParams
+ GVariant* lookup(const char* key, const EParamDisposition disposition = PARAM_REQUIRED) const;
+
+ std::string getSectionName() const;
+
+private:
+ static void destroyValueCallback(gpointer ptr);
+
+private:
+ SmartPtrCConfigParams _theseParams;
+ SmartPtrIConfigParams _baseParams;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CConfigParamsChain);
+};
+
+CAF_DECLARE_SMART_POINTER(CConfigParamsChain);
+
+}
+
+#endif /* CCONFIGPARAMSCHAIN_H_ */
--- /dev/null
+/*
+ * Copyright (c) 2004-2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CFileLock_h_
+#define CFileLock_h_
+
+namespace Caf {
+
+class COMMONAGGREGATOR_LINKAGE CFileLock
+{
+public:
+ enum ELockLevel
+ {
+ UNLOCK,
+ SHARED_LOCK,
+ EXCLUSIVE_LOCK
+ };
+
+public:
+ // Ctor
+ CFileLock();
+
+ // dtor
+ ~CFileLock();
+
+ // initialize the lock for the specified file
+ void initialize(int32 iFileDescriptor);
+
+ // initialize the lock for the specified file
+ void initialize(const char * cszFileName, bool bCreateFile = true);
+
+ // Set the lock to the specified scope
+ void setLockLevel(ELockLevel eLockLevel, bool bDowngradeLock = false);
+
+ // Set the lock to the specified if possible
+ bool attemptSetLockLevel(ELockLevel eLockLevel, bool bDowngradeLock = false);
+
+ // Get the current lock level
+ ELockLevel getLockLevel() const;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CFileLock);
+
+ bool _isInitialized;
+ bool _isFileDescriptorLocal;
+ int32 _fileDescriptor;
+ ELockLevel _lockLevel;
+};
+
+CAF_DECLARE_SMART_POINTER(CFileLock);
+
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: May 18, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CINIFILE_H_
+#define CINIFILE_H_
+
+
+#include "Common/CCafRegex.h"
+
+namespace Caf {
+
+class COMMONAGGREGATOR_LINKAGE CIniFile {
+public:
+ struct SIniEntry {
+ std::string _name;
+ std::string _valueRaw;
+ std::string _valueExpanded;
+ };
+ CAF_DECLARE_SMART_POINTER(SIniEntry);
+
+ struct SIniSection {
+ std::string _sectionName;
+ std::deque<SmartPtrSIniEntry> _entryCollection;
+ };
+ CAF_DECLARE_SMART_POINTER(SIniSection);
+
+public:
+ CIniFile();
+ virtual ~CIniFile();
+
+public:
+ void initialize(const std::string& configFilePath);
+
+ std::deque<SmartPtrSIniSection> getSectionCollection();
+
+ std::deque<SmartPtrSIniEntry> getEntryCollection(
+ const std::string& sectionName);
+
+ SmartPtrSIniEntry findOptionalEntry(
+ const std::string& sectionName,
+ const std::string& keyName);
+
+ SmartPtrSIniEntry findRequiredEntry(
+ const std::string& sectionName,
+ const std::string& keyName);
+
+ std::string findOptionalString(
+ const std::string& sectionName,
+ const std::string& keyName);
+
+ std::string findRequiredString(
+ const std::string& sectionName,
+ const std::string& keyName);
+
+ std::string findOptionalRawString(
+ const std::string& sectionName,
+ const std::string& keyName);
+
+ std::string findRequiredRawString(
+ const std::string& sectionName,
+ const std::string& keyName);
+
+ void log();
+
+ void setValue(
+ const std::string& sectionName,
+ const std::string& keyName,
+ const std::string& value);
+
+ void deleteValue(
+ const std::string& sectionName,
+ const std::string& keyName);
+
+private:
+ struct SReplacement {
+ SmartPtrCCafRegex _regex;
+ std::string _value;
+ };
+ CAF_DECLARE_SMART_POINTER(SReplacement);
+
+private:
+ std::deque<SmartPtrSIniSection> parse(
+ const std::string& configFilePath) const;
+
+ SmartPtrSReplacement createReplacement(
+ const std::string& keyName,
+ const std::string& value) const;
+
+ SmartPtrSIniEntry createIniEntry(
+ const std::string& keyName,
+ const std::string& valueRaw,
+ const std::string& valueExpanded) const;
+
+ void parseValuePath(
+ const std::string& valuePath,
+ std::string& valueName,
+ std::string& valueValue);
+
+private:
+ bool _isInitialized;
+ std::string _configFilePath;
+ std::deque<SmartPtrSIniSection> _sectionCollection;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CIniFile);
+};
+
+CAF_DECLARE_SMART_POINTER(CIniFile);
+
+}
+
+#endif /* CINIFILE_H_ */
--- /dev/null
+/*
+ * Copyright (c) 2004-2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CLoggingSetter_h_
+#define CLoggingSetter_h_
+
+namespace Caf {
+
+class COMMONAGGREGATOR_LINKAGE CLoggingSetter {
+public:
+ CLoggingSetter();
+ virtual ~CLoggingSetter();
+
+public:
+ void initialize(const std::string& logDir);
+
+private:
+ bool _isInitialized;
+ bool _remapLoggingLocation;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CLoggingSetter);
+};
+
+CAF_DECLARE_SMART_POINTER(CLoggingSetter);
+
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Jan 21, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CLoggingUtils_H_
+#define CLoggingUtils_H_
+
+#ifndef WIN32
+#include <sys/time.h>
+#include "Common/CLoggingUtils.h"
+#endif
+
+namespace Caf {
+
+class CLoggingUtils;
+CAF_DECLARE_SMART_POINTER(CLoggingUtils);
+
+class COMMONAGGREGATOR_LINKAGE CLoggingUtils {
+private:
+ typedef std::map<std::string, std::string> PropertyMap;
+
+public:
+ static bool isConsoleAppenderUsed();
+ static void setStartupConfigFile(
+ const std::string& configFile = "log4cpp_config",
+ const std::string& logDir = std::string());
+ static std::string getConfigFile();
+ static void resetConfigFile();
+ static void setLogDir(const std::string& logDir);
+
+public:
+ CLoggingUtils();
+
+private:
+ static SmartPtrCLoggingUtils getInstance();
+
+ static void loadConfig(const std::string& configFile);
+
+ void loadProperties();
+
+private:
+ static GRecMutex _sOpMutex;
+ static SmartPtrCLoggingUtils _sInstance;
+
+ std::string _configFile;
+ PropertyMap _properties;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CLoggingUtils);
+};
+
+}
+
+#endif /* CLoggingUtils_H_ */
--- /dev/null
+/*
+ * Created on: May 9, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CMANAGEDTHREADPOOL_H_
+#define CMANAGEDTHREADPOOL_H_
+
+
+#include "ICafObject.h"
+
+namespace Caf {
+
+/**
+ * @author mdonahue
+ * @brief This class wraps a GThreadPool and makes it a bit more friendly to use. It
+ * also allows tasks to partially complete and be requeued.
+ * The shutdown behavior is to wait for all active tasks to finish. Inactive
+ * (unscheduled) tasks will be aborted.
+ */
+class COMMONAGGREGATOR_LINKAGE CManagedThreadPool {
+public:
+ /**
+ * @brief Interface for task objects
+ */
+ struct __declspec(novtable) IThreadTask : public ICafObject {
+ /**
+ * @brief execute task
+ * @retval true the task has completed its work and will be removed from the pool
+ * @retval false the task has not completed its work and will be requeued in the pool
+ */
+ virtual bool run() = 0;
+ };
+ CAF_DECLARE_SMART_INTERFACE_POINTER(IThreadTask);
+ typedef std::deque<SmartPtrIThreadTask> TaskDeque;
+
+public:
+ CManagedThreadPool();
+ virtual ~CManagedThreadPool();
+
+ /**
+ * @brief initialize the thread pool
+ * @param poolName a friendly name for the pool to aid in debugging
+ * @param threadCount the number of task threads
+ * @param taskUpdateInterval optional task queue refresh rate in milliseconds
+ */
+ void init(
+ const std::string& poolName,
+ uint32 threadCount,
+ uint32 taskUpdateInterval = 0);
+
+ /**
+ * @brief terminate the thread pool
+ * All active tasks will be allowed to finish before this method returns
+ */
+ void term();
+
+ /**
+ * @brief add a task to the pool
+ * @param task the task to add
+ */
+ void enqueue(const SmartPtrIThreadTask& task);
+
+ /**
+ * @brief add a collection of tasks to the pool
+ * @param tasks the tasks to add
+ */
+ void enqueue(const TaskDeque& tasks);
+
+ /** @brief A simple structure to report some statistics
+ *
+ */
+ struct Stats {
+ /** The number of tasks under management */
+ uint32 taskCount;
+
+ /** The number of tasks waiting to be assigned to threads for execution */
+ uint32 inactiveTaskCount;
+
+ /** The number of tasks assigned to threads for execution */
+ uint32 activeTaskCount;
+
+ /** The number of tasks that have completed execution */
+ uint32 completeTaskCount;
+
+ /** The number of tasks that have executed but need to be requeued */
+ uint32 incompleteTaskCount;
+ };
+
+ /** @return the current statistics */
+ Stats getStats() const;
+
+private:
+ static gpointer poolWorkerFunc(gpointer context);
+ static void taskWorkerFunc(gpointer threadContext, gpointer NOT_USED);
+
+private:
+ void runPool();
+
+private:
+ /** Default task update interval in milliseconds */
+ static uint32 DEFAULT_TASK_UPDATE_INTERVAL;
+
+private:
+ bool _isInitialized;
+ volatile bool _isShuttingDown;
+ std::string _poolName;
+ GThreadPool *_threadPool;
+ typedef std::set<IThreadTask*> TaskSet;
+ TaskSet _tasks;
+ GThread* _workerThread;
+ uint32 _taskUpdateInterval;
+
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_CM_DECLARE_NOCOPY(CManagedThreadPool);
+};
+CAF_DECLARE_SMART_POINTER(CManagedThreadPool);
+
+}
+
+#endif /* CMANAGEDTHREADPOOL_H_ */
--- /dev/null
+/*
+ * CThreadPool.h
+ *
+ * Created on: May 9, 2012
+ * Author: mdonahue
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CTHREADPOOL_H_
+#define CTHREADPOOL_H_
+
+
+#include "ICafObject.h"
+
+#include "Common/CManagedThreadPool.h"
+
+namespace Caf {
+
+/**
+ * @author mdonahue
+ * @brief This class wraps a GThreadPool and makes it a bit more friendly to use.
+ * This class wraps up a GThreadPool as a lifetime-managed object that can be shared.
+ * The shutdown behavior is to wait for all tasks to finish.
+ */
+class COMMONAGGREGATOR_LINKAGE CThreadPool {
+public:
+ /**
+ * @brief This is the interface for tasks queued in this thread pool
+ */
+ struct __declspec(novtable) IThreadTask : public ICafObject {
+ /**
+ * @brief execute task
+ * @param userData the userData passed into the thread pool init() method
+ */
+ virtual void run(gpointer userData) = 0;
+ };
+ CAF_DECLARE_SMART_INTERFACE_POINTER(IThreadTask);
+
+public:
+ CThreadPool();
+ virtual ~CThreadPool();
+
+ /**
+ * @brief Initialize the thread pool
+ * @param userData opaque data to be passed to each thread
+ * @param maxThreads the number of threads to create
+ */
+ void init(gpointer userData, gint maxThreads);
+
+ /**
+ * @brief Terminate the thread pool
+ * All tasks will be allowed to finish before this method returns
+ */
+ void term();
+
+ /**
+ * @brief Add a task to the thread pool
+ * @param task interface to the task to add
+ */
+ void addTask(const SmartPtrIThreadTask& task);
+
+private:
+ static void ThreadFunc(gpointer data, gpointer userData);
+
+private:
+ bool _isInitialized;
+ GThreadPool *_threadPool;
+ gpointer _userData;
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_CM_DECLARE_NOCOPY(CThreadPool);
+};
+CAF_DECLARE_SMART_POINTER(CThreadPool);
+
+}
+
+#endif /* CTHREADPOOL_H_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Jul 2009
+ *
+ * Copyright (c) 2009-2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CThreadSignal_h_
+#define CThreadSignal_h_
+
+#include "Common/CThreadSignal.h"
+
+#include "Common/CAutoMutex.h"
+#include "Common/CAutoCondition.h"
+
+namespace Caf {
+
+// Class-level thread safety macros
+#define CAF_THREADSIGNAL_CREATE \
+ private: \
+ mutable SmartPtrCAutoMutex _threadsync_mutex_
+
+#define CAF_THREADSIGNAL_INIT \
+ _threadsync_mutex_.CreateInstance(); \
+ _threadsync_mutex_->initialize()
+
+#define CAF_THREADSIGNAL_MUTEX \
+ _threadsync_mutex_
+
+#define CAF_THREADSIGNAL_LOCK_UNLOCK \
+ Caf::CAutoMutexLockUnlock _threadsync_auto_lock(CAF_THREADSIGNAL_MUTEX)
+
+#define CAF_THREADSIGNAL_LOCK_UNLOCK_LOG \
+ Caf::CAutoMutexLockUnlock _threadsync_auto_lock(CAF_THREADSIGNAL_MUTEX, CAF_CM_GET_CLASSNAME, CAF_CM_GET_FUNCNAME)
+
+class COMMONAGGREGATOR_LINKAGE CThreadSignal {
+public:
+ CThreadSignal();
+ virtual ~CThreadSignal();
+
+public:
+ void initialize(const std::string& conditionName);
+ bool isInitialized() const;
+ void signal();
+ void wait(SmartPtrCAutoMutex& mutex, const uint32 timeoutMs);
+ bool waitOrTimeout(SmartPtrCAutoMutex& mutex, const uint32 timeoutMs);
+ std::string getName() const;
+ void close();
+
+private:
+ bool _isInitialized;
+ CAutoCondition _condition;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_CM_DECLARE_NOCOPY(CThreadSignal);
+};
+
+CAF_DECLARE_SMART_POINTER( CThreadSignal);
+
+}
+
+#endif // #ifndef CThreadSignal_h_
--- /dev/null
+/*
+ * Created on: Jun 7, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CVARIANT_H_
+#define CVARIANT_H_
+
+
+#include "IVariant.h"
+
+namespace Caf {
+
+/**
+ * @brief A class that holds a GVariant* to manage its lifetime
+ */
+CAF_DECLARE_CLASS_AND_SMART_POINTER(CVariant);
+
+class COMMONAGGREGATOR_LINKAGE CVariant : public IVariant {
+public:
+ CVariant();
+ virtual ~CVariant();
+
+ void set(GVariant *variant);
+
+public: // IVariant
+ GVariant *get() const;
+
+ std::string toString() const;
+
+ bool isString() const;
+ bool isBool() const;
+ bool isUint8() const;
+ bool isInt16() const;
+ bool isUint16() const;
+ bool isInt32() const;
+ bool isUint32() const;
+ bool isInt64() const;
+ bool isUint64() const;
+
+public:
+ static SmartPtrCVariant createString(const std::string& value);
+ static SmartPtrCVariant createBool(const bool value);
+ static SmartPtrCVariant createUint8(const uint8 value);
+ static SmartPtrCVariant createInt16(const int16 value);
+ static SmartPtrCVariant createUint16(const uint16 value);
+ static SmartPtrCVariant createInt32(const int32 value);
+ static SmartPtrCVariant createUint32(const uint32 value);
+ static SmartPtrCVariant createInt64(const int64 value);
+ static SmartPtrCVariant createUint64(const uint64 value);
+
+private:
+ bool isType(const GVariantType * varType) const;
+
+private:
+ GVariant *_variant;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CVariant);
+};
+
+}
+
+#endif /* CVARIANT_H_ */
--- /dev/null
+/*
+ * Author: mdonahue
+ * Created: Jan 19, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef IAPPCONFIG_H_
+#define IAPPCONFIG_H_
+
+#include "Common/IConfigParams.h"
+
+#include "ICafObject.h"
+#include "Common/IAppConfig.h"
+
+namespace Caf {
+
+struct __declspec(novtable)
+IAppConfig : public ICafObject {
+ CAF_DECL_UUID("e57f2252-ce11-4d15-9338-aa928333f7a3")
+
+ virtual SmartPtrIConfigParams getParameters(const std::string& sectionName) = 0;
+
+ virtual bool getString(
+ const std::string& sectionName,
+ const std::string& parameterName,
+ std::string& value,
+ const IConfigParams::EParamDisposition disposition = IConfigParams::PARAM_REQUIRED) = 0;
+
+ virtual bool getUint32(
+ const std::string& sectionName,
+ const std::string& parameterName,
+ uint32& value,
+ const IConfigParams::EParamDisposition disposition = IConfigParams::PARAM_REQUIRED) = 0;
+
+ virtual bool getInt32(
+ const std::string& sectionName,
+ const std::string& parameterName,
+ int32& value,
+ const IConfigParams::EParamDisposition disposition = IConfigParams::PARAM_REQUIRED) = 0;
+
+ virtual bool getBoolean(
+ const std::string& sectionName,
+ const std::string& parameterName,
+ bool& value,
+ const IConfigParams::EParamDisposition disposition = IConfigParams::PARAM_REQUIRED) = 0;
+
+ virtual bool getGlobalString(
+ const std::string& parameterName,
+ std::string& value,
+ const IConfigParams::EParamDisposition disposition = IConfigParams::PARAM_REQUIRED) = 0;
+
+ virtual bool getGlobalUint32(
+ const std::string& parameterName,
+ uint32& value,
+ const IConfigParams::EParamDisposition disposition = IConfigParams::PARAM_REQUIRED) = 0;
+
+ virtual bool getGlobalInt32(
+ const std::string& parameterName,
+ int32& value,
+ const IConfigParams::EParamDisposition disposition = IConfigParams::PARAM_REQUIRED) = 0;
+
+ virtual bool getGlobalBoolean(
+ const std::string& parameterName,
+ bool& value,
+ const IConfigParams::EParamDisposition disposition = IConfigParams::PARAM_REQUIRED) = 0;
+
+ virtual std::string resolveValue(const std::string& value) = 0;
+};
+
+CAF_DECLARE_SMART_INTERFACE_POINTER(IAppConfig);
+
+SmartPtrIAppConfig COMMONAGGREGATOR_LINKAGE getAppConfig();
+
+SmartPtrIAppConfig COMMONAGGREGATOR_LINKAGE getAppConfig(const std::string& configFile);
+
+SmartPtrIAppConfig COMMONAGGREGATOR_LINKAGE getAppConfig(const Cdeqstr& configFileCollection);
+
+SmartPtrIAppConfig COMMONAGGREGATOR_LINKAGE getAppConfigAppend(const std::string& configFile);
+
+SmartPtrIAppConfig COMMONAGGREGATOR_LINKAGE getAppConfigAppend(const Cdeqstr& configFileCollection);
+}
+
+#endif /* IAPPCONFIG_H_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Jan 28, 2015
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef IAPPCONFIGWRITE_H_
+#define IAPPCONFIGWRITE_H_
+
+#include "Common/IAppConfigWrite.h"
+
+#include "ICafObject.h"
+
+namespace Caf {
+
+struct __declspec(novtable)
+IAppConfigWrite : public ICafObject {
+ CAF_DECL_UUID("3cf708c6-b92d-46c3-83d8-edeccecf5ba4")
+
+ virtual void setString(
+ const std::string& sectionName,
+ const std::string& parameterName,
+ const std::string& value) = 0;
+
+ virtual void setUint32(
+ const std::string& sectionName,
+ const std::string& parameterName,
+ const uint32& value) = 0;
+
+ virtual void setInt32(
+ const std::string& sectionName,
+ const std::string& parameterName,
+ const int32& value) = 0;
+
+ virtual void setBoolean(
+ const std::string& sectionName,
+ const std::string& parameterName,
+ const bool& value) = 0;
+
+ virtual void setGlobalString(
+ const std::string& parameterName,
+ const std::string& value) = 0;
+
+ virtual void setGlobalUint32(
+ const std::string& parameterName,
+ const uint32& value) = 0;
+
+ virtual void setGlobalInt32(
+ const std::string& parameterName,
+ const int32& value) = 0;
+
+ virtual void setGlobalBoolean(
+ const std::string& parameterName,
+ const bool& value) = 0;
+};
+
+CAF_DECLARE_SMART_INTERFACE_POINTER(IAppConfigWrite);
+
+SmartPtrIAppConfigWrite COMMONAGGREGATOR_LINKAGE getAppConfigWrite();
+
+SmartPtrIAppConfigWrite COMMONAGGREGATOR_LINKAGE getAppConfigWrite(const std::string& configFile);
+
+SmartPtrIAppConfigWrite COMMONAGGREGATOR_LINKAGE getAppConfigWrite(const Cdeqstr& configFileCollection);
+}
+
+#endif /* IAPPCONFIGWRITE_H_ */
--- /dev/null
+/*
+ * Author: mdonahue
+ * Created: Jan 28, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef IAPPLICATIONCONTEXT_H_
+#define IAPPLICATIONCONTEXT_H_
+
+
+
+#include "ICafObject.h"
+
+#include "IBean.h"
+
+namespace Caf {
+
+struct __declspec(novtable)
+IAppContext : public ICafObject {
+ CAF_DECL_UUID("f1d65e47-0f12-4301-861c-6a8c90099dae")
+
+ // key=bean id
+ typedef std::map<std::string, SmartPtrIBean> CBeans;
+ CAF_DECLARE_SMART_POINTER(CBeans);
+
+ virtual SmartPtrIBean getBean(const std::string& name) const = 0;
+};
+
+CAF_DECLARE_SMART_INTERFACE_POINTER(IAppContext);
+}
+
+#endif /* IAPPLICATIONCONTEXT_H_ */
--- /dev/null
+/*
+ * Author: mdonahue
+ * Created: Jan 17, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef ICONFIGPARAMS_H_
+#define ICONFIGPARAMS_H_
+
+#include "Common/IConfigParams.h"
+
+namespace Caf {
+
+struct __declspec(novtable)
+IConfigParams : public ICafObject
+{
+ typedef enum {
+ PARAM_REQUIRED,
+ PARAM_OPTIONAL
+ } EParamDisposition;
+
+ virtual GVariant* lookup(
+ const char* key,
+ const EParamDisposition disposition = PARAM_REQUIRED) const = 0;
+
+ virtual std::string getSectionName() const = 0;
+
+ virtual void insert(const char* key, GVariant* value) = 0;
+};
+
+CAF_DECLARE_SMART_INTERFACE_POINTER(IConfigParams);
+
+}
+
+#endif /* ICONFIGPARAMS_H_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: June 29, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef _CommonAggregator_IWork_h_
+#define _CommonAggregator_IWork_h_
+
+
+#include "ICafObject.h"
+
+namespace Caf {
+
+/// TODO - describe interface
+struct __declspec(novtable)
+ IWork : public ICafObject {
+ CAF_DECL_UUID("76c269db-691f-439d-b47d-87ce55639c8f")
+
+public: // Read operations
+ virtual void doWork() = 0;
+ virtual void stopWork() = 0;
+};
+
+CAF_DECLARE_SMART_INTERFACE_POINTER(IWork);
+
+}
+
+#endif // #ifndef _CommonAggregator_IWork_h_
+
#ifndef CAddInsDoc_h_
#define CAddInsDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CAddInCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type AddIns
#ifndef CAttachmentCollectionDoc_h_
#define CAttachmentCollectionDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/CafCoreTypesDoc/CInlineAttachmentDoc.h"
+
namespace Caf {
/// A simple container for objects of type AttachmentCollection
#ifndef CAttachmentDoc_h_
#define CAttachmentDoc_h_
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+
namespace Caf {
/// A simple container for objects of type Attachment
#ifndef CAuthnAuthzCollectionDoc_h_
#define CAuthnAuthzCollectionDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CAuthnAuthzDoc.h"
+
namespace Caf {
/// Set of logging levels for different components
#ifndef CClassSpecifierDoc_h_
#define CClassSpecifierDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CClassFiltersDoc.h"
+#include "Doc/CafCoreTypesDoc/CFullyQualifiedClassGroupDoc.h"
+
namespace Caf {
/// A simple container for objects of type ClassSpecifier
#ifndef CInlineAttachmentCollectionDoc_h_
#define CInlineAttachmentCollectionDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CInlineAttachmentDoc.h"
+
namespace Caf {
/// A simple container for objects of type InlineAttachmentCollection
#ifndef CLoggingLevelCollectionDoc_h_
#define CLoggingLevelCollectionDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CLoggingLevelElemDoc.h"
+
namespace Caf {
/// Set of logging levels for different components
#ifndef CLoggingLevelElemDoc_h_
#define CLoggingLevelElemDoc_h_
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+
namespace Caf {
/// Logging level for a component
#ifndef COperationDoc_h_
#define COperationDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type Operation
#ifndef CParameterCollectionDoc_h_
#define CParameterCollectionDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CRequestInstanceParameterDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestParameterDoc.h"
+
namespace Caf {
/// A simple container for objects of type ParameterCollection
#ifndef CPropertyCollectionDoc_h_
#define CPropertyCollectionDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CPropertyDoc.h"
+
namespace Caf {
/// A simple container for objects of type PropertyCollection
#ifndef CPropertyDoc_h_
#define CPropertyDoc_h_
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+
namespace Caf {
/// A simple container for objects of type Property
#ifndef CProtocolCollectionDoc_h_
#define CProtocolCollectionDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CProtocolDoc.h"
+
namespace Caf {
/// Set of protocol
#ifndef CRequestConfigDoc_h_
#define CRequestConfigDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CAddInsDoc.h"
+#include "Doc/CafCoreTypesDoc/CLoggingLevelCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type RequestConfig
#ifndef CRequestHeaderDoc_h_
#define CRequestHeaderDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CAuthnAuthzCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CPropertyCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CProtocolCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestConfigDoc.h"
+
namespace Caf {
/// A simple container for objects of type RequestHeader
#ifndef CRequestParameterDoc_h_
#define CRequestParameterDoc_h_
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+
namespace Caf {
/// A simple container for objects of type RequestParameter
#ifndef CStatisticsDoc_h_
#define CStatisticsDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CPropertyCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type Statistics
#endif
#endif
-#include "Doc/CafCoreTypesDoc/CafCoreTypesDocInc.h"
#endif /* CafCoreTypesDoc_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CAFCORETYPESDOCTYPES_H_
+#define CAFCORETYPESDOCTYPES_H_
+
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+
+namespace Caf {
+ typedef enum {
+ PROPERTY_NONE,
+ PROPERTY_STRING,
+ PROPERTY_SINT32,
+ PROPERTY_UINT32,
+ PROPERTY_SINT64,
+ PROPERTY_UINT64,
+ PROPERTY_DECIMAL,
+ PROPERTY_DOUBLE,
+ PROPERTY_BOOLEAN,
+ PROPERTY_DATETIME
+ } PROPERTY_TYPE;
+
+ typedef enum {
+ PARAMETER_NONE,
+ PARAMETER_STRING,
+ PARAMETER_SINT32,
+ PARAMETER_UINT32,
+ PARAMETER_SINT64,
+ PARAMETER_UINT64,
+ PARAMETER_DECIMAL,
+ PARAMETER_DOUBLE,
+ PARAMETER_BOOLEAN,
+ PARAMETER_DATETIME
+ } PARAMETER_TYPE;
+
+ typedef enum {
+ LOGGINGLEVEL_NONE,
+ LOGGINGLEVEL_DEBUG,
+ LOGGINGLEVEL_INFO,
+ LOGGINGLEVEL_WARN,
+ LOGGINGLEVEL_ERROR,
+ LOGGINGLEVEL_CRITICAL
+ } LOGGINGLEVEL_TYPE;
+
+ typedef enum {
+ LOGGINGCOMPONENT_NONE,
+ LOGGINGCOMPONENT_COMMUNICATIONS,
+ LOGGINGCOMPONENT_MANAGEMENTAGENT,
+ LOGGINGCOMPONENT_UINT32,
+ LOGGINGCOMPONENT_PROVIDERFRAMEWORK,
+ LOGGINGCOMPONENT_PROVIDER
+ } LOGGINGCOMPONENT_TYPE;
+
+ typedef enum {
+ CMS_POLICY_NONE,
+ CMS_POLICY_CAF_ENCRYPTED,
+ CMS_POLICY_CAF_SIGNED,
+ CMS_POLICY_CAF_ENCRYPTED_AND_SIGNED,
+ CMS_POLICY_APP_SIGNED,
+ CMS_POLICY_APP_ENCRYPTED,
+ CMS_POLICY_APP_ENCRYPTED_AND_SIGNED
+ } CMS_POLICY;
+}
+
+#endif /* CAFCORETYPESDOCTYPES_H_ */
#ifndef CFullPackageElemDoc_h_
#define CFullPackageElemDoc_h_
+
+#include "Doc/CafInstallRequestDoc/CPackageDefnDoc.h"
+
namespace Caf {
/// A simple container for objects of type FullPackageElem
#ifndef CInstallBatchDoc_h_
#define CInstallBatchDoc_h_
+
+#include "Doc/CafInstallRequestDoc/CGetInventoryJobDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallProviderJobDoc.h"
+#include "Doc/CafInstallRequestDoc/CUninstallProviderJobDoc.h"
+
namespace Caf {
/// A simple container for objects of type InstallBatch
#ifndef CInstallPackageSpecDoc_h_
#define CInstallPackageSpecDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentNameCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type InstallPackageSpec
#ifndef CInstallProviderJobDoc_h_
#define CInstallProviderJobDoc_h_
+
+#include "Doc/CafInstallRequestDoc/CFullPackageElemDoc.h"
+#include "Doc/CafInstallRequestDoc/CafInstallRequestDocTypes.h"
+
namespace Caf {
/// A simple container for objects of type InstallProviderJob
#ifndef CInstallProviderSpecDoc_h_
#define CInstallProviderSpecDoc_h_
+
+#include "Doc/CafInstallRequestDoc/CMinPackageElemDoc.h"
+
namespace Caf {
/// A simple container for objects of type InstallProviderSpec
#ifndef CInstallRequestDoc_h_
#define CInstallRequestDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallBatchDoc.h"
+
namespace Caf {
/// A simple container for objects of type InstallRequest
#ifndef CPackageDefnDoc_h_
#define CPackageDefnDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CAttachmentNameCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type PackageDefn
#ifndef CUninstallProviderJobDoc_h_
#define CUninstallProviderJobDoc_h_
+#include "Doc/CafInstallRequestDoc/CafInstallRequestDocTypes.h"
+
namespace Caf {
/// A simple container for objects of type UninstallProviderJob
#endif
#endif
-#include "Doc/CafInstallRequestDoc/CafInstallRequestDocInc.h"
#endif /* CafInstallRequestDoc_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CAFINSTALLREQUESTDOCTYPES_H_
+#define CAFINSTALLREQUESTDOCTYPES_H_
+
+#include "Doc/CafInstallRequestDoc/CafInstallRequestDocTypes.h"
+
+namespace Caf {
+ typedef enum {
+ PACKAGE_OS_NONE,
+ PACKAGE_OS_ALL,
+ PACKAGE_OS_NIX,
+ PACKAGE_OS_WIN
+ } PACKAGE_OS_TYPE;
+}
+
+#endif /* CAFINSTALLREQUESTTYPES_H_ */
#ifndef CDiagRequestDoc_h_
#define CDiagRequestDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Doc/DiagTypesDoc/CDiagBatchDoc.h"
+
namespace Caf {
/// A simple container for objects of type DiagRequest
#endif
#endif
-#include "Doc/DiagRequestDoc/DiagRequestDocInc.h"
#endif /* DiagRequestDoc_Link_h_ */
#ifndef CDiagBatchDoc_h_
#define CDiagBatchDoc_h_
+
+#include "Doc/DiagTypesDoc/CDiagCollectInstancesDoc.h"
+#include "Doc/DiagTypesDoc/CDiagDeleteValueCollectionDoc.h"
+#include "Doc/DiagTypesDoc/CDiagSetValueCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type DiagBatch
#ifndef CDiagDeleteValueCollectionDoc_h_
#define CDiagDeleteValueCollectionDoc_h_
+
+#include "Doc/DiagTypesDoc/CDiagDeleteValueDoc.h"
+
namespace Caf {
/// A simple container for objects of type DiagDeleteValueCollection
#ifndef CDiagSetValueCollectionDoc_h_
#define CDiagSetValueCollectionDoc_h_
+
+#include "Doc/DiagTypesDoc/CDiagSetValueDoc.h"
+
namespace Caf {
/// A simple container for objects of type DiagSetValueCollection
#ifndef CDiagSetValueDoc_h_
#define CDiagSetValueDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CPropertyDoc.h"
+
namespace Caf {
/// A simple container for objects of type DiagSetValue
#endif
#endif
-#include "Doc/DiagTypesDoc/DiagTypesDocInc.h"
#endif /* DiagTypesDoc_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ */
+
+#ifndef EnumConvertersXml_h_
+#define EnumConvertersXml_h_
+
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+#include "Doc/CafInstallRequestDoc/CafInstallRequestDocTypes.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+
+namespace Caf {
+
+ namespace EnumConvertersXml {
+ /// Converts the parameter type to a string
+ std::string DOCUTILS_LINKAGE convertParameterTypeToString(
+ const PARAMETER_TYPE parameterType);
+
+ /// Converts the string to a parameter type
+ PARAMETER_TYPE DOCUTILS_LINKAGE convertStringToParameterType(
+ const std::string parameterType);
+
+ /// Converts the property type to a string
+ std::string DOCUTILS_LINKAGE convertPropertyTypeToString(
+ const PROPERTY_TYPE propertyType);
+
+ /// Converts the string to a property type
+ PROPERTY_TYPE DOCUTILS_LINKAGE convertStringToPropertyType(
+ const std::string propertyType);
+
+ /// Converts the validator type to a string
+ std::string DOCUTILS_LINKAGE convertValidatorTypeToString(
+ const VALIDATOR_TYPE validatorType);
+
+ /// Converts the string to a validator type
+ VALIDATOR_TYPE DOCUTILS_LINKAGE convertStringToValidatorType(
+ const std::string validatorType);
+
+ /// Converts the operator type to a string
+ std::string DOCUTILS_LINKAGE convertOperatorTypeToString(
+ const OPERATOR_TYPE operatorType);
+
+ /// Converts the string to a operator type
+ OPERATOR_TYPE DOCUTILS_LINKAGE convertStringToOperatorType(
+ const std::string operatorType);
+
+ /// Converts the arity type to a string
+ std::string DOCUTILS_LINKAGE convertArityTypeToString(
+ const ARITY_TYPE arityType);
+
+ /// Converts the string to an arity type
+ ARITY_TYPE DOCUTILS_LINKAGE convertStringToArityType(
+ const std::string arityType);
+
+ /// Converts the parameter type to a string
+ std::string DOCUTILS_LINKAGE convertPackageOSTypeToString(
+ const PACKAGE_OS_TYPE packageOSType);
+
+ /// Converts the string to a parameter type
+ PACKAGE_OS_TYPE DOCUTILS_LINKAGE convertStringToPackageOSType(
+ const std::string packageOSType);
+
+ /// Converts the logging level enum type to a string
+ std::string DOCUTILS_LINKAGE convertLoggingLevelTypeToString(
+ const LOGGINGLEVEL_TYPE loggingLevelType);
+
+ /// Converts the string to a logging level enum
+ LOGGINGLEVEL_TYPE DOCUTILS_LINKAGE convertStringToLoggingLevelType(
+ const std::string loggingLevelType);
+
+ /// Converts the logging component enum type to a string
+ std::string DOCUTILS_LINKAGE convertLoggingComponentTypeToString(
+ const LOGGINGCOMPONENT_TYPE loggingComponentType);
+
+ /// Converts the string to a logging component enum type
+ LOGGINGCOMPONENT_TYPE DOCUTILS_LINKAGE convertStringToLoggingComponentType(
+ const std::string loggingComponentType);
+
+ std::string DOCUTILS_LINKAGE convertCmsPolicyToString(
+ const CMS_POLICY cmsPolicy);
+
+ CMS_POLICY DOCUTILS_LINKAGE convertStringToCmsPolicy(
+ const std::string cmsPolicy);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef AddInCollectionXml_h_
+#define AddInCollectionXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CAddInCollectionDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the AddInCollection class to/from XML
+ namespace AddInCollectionXml {
+
+ /// Adds the AddInCollectionDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCAddInCollectionDoc addInCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the AddInCollectionDoc from the XML.
+ SmartPtrCAddInCollectionDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef AddInsXml_h_
+#define AddInsXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CAddInsDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the AddIns class to/from XML
+ namespace AddInsXml {
+
+ /// Adds the AddInsDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCAddInsDoc addInsDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the AddInsDoc from the XML.
+ SmartPtrCAddInsDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef AttachmentCollectionXml_h_
+#define AttachmentCollectionXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the AttachmentCollection class to/from XML
+ namespace AttachmentCollectionXml {
+
+ /// Adds the AttachmentCollectionDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCAttachmentCollectionDoc attachmentCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the AttachmentCollectionDoc from the XML.
+ SmartPtrCAttachmentCollectionDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef AttachmentNameCollectionXml_h_
+#define AttachmentNameCollectionXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CAttachmentNameCollectionDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the AttachmentNameCollection class to/from XML
+ namespace AttachmentNameCollectionXml {
+
+ /// Adds the AttachmentNameCollectionDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCAttachmentNameCollectionDoc attachmentNameCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the AttachmentNameCollectionDoc from the XML.
+ SmartPtrCAttachmentNameCollectionDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef AttachmentXml_h_
+#define AttachmentXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the Attachment class to/from XML
+ namespace AttachmentXml {
+
+ /// Adds the AttachmentDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCAttachmentDoc attachmentDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the AttachmentDoc from the XML.
+ SmartPtrCAttachmentDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef AuthnAuthzCollectionXml_h_
+#define AuthnAuthzCollectionXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CAuthnAuthzCollectionDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the AuthnAuthzCollection class to/from XML
+ namespace AuthnAuthzCollectionXml {
+
+ /// Adds the AuthnAuthzCollectionDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCAuthnAuthzCollectionDoc authnAuthzCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the AuthnAuthzCollectionDoc from the XML.
+ SmartPtrCAuthnAuthzCollectionDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef AuthnAuthzXml_h_
+#define AuthnAuthzXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CAuthnAuthzDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the AuthnAuthz class to/from XML
+ namespace AuthnAuthzXml {
+
+ /// Adds the AuthnAuthzDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCAuthnAuthzDoc authnAuthzDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the AuthnAuthzDoc from the XML.
+ SmartPtrCAuthnAuthzDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef CafCoreTypesXml_Link_h_
+#define CafCoreTypesXml_Link_h_
+
+#ifndef CAFCORETYPESXML_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define CAFCORETYPESXML_LINKAGE __declspec(dllexport)
+ #else
+ #define CAFCORETYPESXML_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define CAFCORETYPESXML_LINKAGE
+ #endif
+#endif
+
+
+#endif /* CafCoreTypesXml_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ClassFiltersXml_h_
+#define ClassFiltersXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CClassFiltersDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ClassFilters class to/from XML
+ namespace ClassFiltersXml {
+
+ /// Adds the ClassFiltersDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCClassFiltersDoc classFiltersDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ClassFiltersDoc from the XML.
+ SmartPtrCClassFiltersDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ClassSpecifierXml_h_
+#define ClassSpecifierXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CClassSpecifierDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ClassSpecifier class to/from XML
+ namespace ClassSpecifierXml {
+
+ /// Adds the ClassSpecifierDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCClassSpecifierDoc classSpecifierDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ClassSpecifierDoc from the XML.
+ SmartPtrCClassSpecifierDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef FullyQualifiedClassGroupXml_h_
+#define FullyQualifiedClassGroupXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CFullyQualifiedClassGroupDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the FullyQualifiedClassGroup class to/from XML
+ namespace FullyQualifiedClassGroupXml {
+
+ /// Adds the FullyQualifiedClassGroupDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCFullyQualifiedClassGroupDoc fullyQualifiedClassGroupDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the FullyQualifiedClassGroupDoc from the XML.
+ SmartPtrCFullyQualifiedClassGroupDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef LoggingLevelCollectionXml_h_
+#define LoggingLevelCollectionXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CLoggingLevelCollectionDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the LoggingLevelCollection class to/from XML
+ namespace LoggingLevelCollectionXml {
+
+ /// Adds the LoggingLevelCollectionDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCLoggingLevelCollectionDoc loggingLevelCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the LoggingLevelCollectionDoc from the XML.
+ SmartPtrCLoggingLevelCollectionDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef LoggingLevelElemXml_h_
+#define LoggingLevelElemXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CLoggingLevelElemDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the LoggingLevelElem class to/from XML
+ namespace LoggingLevelElemXml {
+
+ /// Adds the LoggingLevelElemDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCLoggingLevelElemDoc loggingLevelElemDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the LoggingLevelElemDoc from the XML.
+ SmartPtrCLoggingLevelElemDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef OperationXml_h_
+#define OperationXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/COperationDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the Operation class to/from XML
+ namespace OperationXml {
+
+ /// Adds the OperationDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCOperationDoc operationDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the OperationDoc from the XML.
+ SmartPtrCOperationDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ParameterCollectionXml_h_
+#define ParameterCollectionXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ParameterCollection class to/from XML
+ namespace ParameterCollectionXml {
+
+ /// Adds the ParameterCollectionDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCParameterCollectionDoc parameterCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ParameterCollectionDoc from the XML.
+ SmartPtrCParameterCollectionDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef PropertyCollectionXml_h_
+#define PropertyCollectionXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CPropertyCollectionDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the PropertyCollection class to/from XML
+ namespace PropertyCollectionXml {
+
+ /// Adds the PropertyCollectionDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCPropertyCollectionDoc propertyCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the PropertyCollectionDoc from the XML.
+ SmartPtrCPropertyCollectionDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef PropertyXml_h_
+#define PropertyXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CPropertyDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the Property class to/from XML
+ namespace PropertyXml {
+
+ /// Adds the PropertyDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCPropertyDoc propertyDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the PropertyDoc from the XML.
+ SmartPtrCPropertyDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProtocolCollectionXml_h_
+#define ProtocolCollectionXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CProtocolCollectionDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ProtocolCollection class to/from XML
+ namespace ProtocolCollectionXml {
+
+ /// Adds the ProtocolCollectionDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCProtocolCollectionDoc protocolCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ProtocolCollectionDoc from the XML.
+ SmartPtrCProtocolCollectionDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProtocolXml_h_
+#define ProtocolXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CProtocolDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the Protocol class to/from XML
+ namespace ProtocolXml {
+
+ /// Adds the ProtocolDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCProtocolDoc protocolDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ProtocolDoc from the XML.
+ SmartPtrCProtocolDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef RequestConfigXml_h_
+#define RequestConfigXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CRequestConfigDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the RequestConfig class to/from XML
+ namespace RequestConfigXml {
+
+ /// Adds the RequestConfigDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCRequestConfigDoc requestConfigDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the RequestConfigDoc from the XML.
+ SmartPtrCRequestConfigDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef RequestHeaderXml_h_
+#define RequestHeaderXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the RequestHeader class to/from XML
+ namespace RequestHeaderXml {
+
+ /// Adds the RequestHeaderDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCRequestHeaderDoc requestHeaderDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the RequestHeaderDoc from the XML.
+ SmartPtrCRequestHeaderDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef RequestInstanceParameterXml_h_
+#define RequestInstanceParameterXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CRequestInstanceParameterDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the RequestInstanceParameter class to/from XML
+ namespace RequestInstanceParameterXml {
+
+ /// Adds the RequestInstanceParameterDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCRequestInstanceParameterDoc requestInstanceParameterDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the RequestInstanceParameterDoc from the XML.
+ SmartPtrCRequestInstanceParameterDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef RequestParameterXml_h_
+#define RequestParameterXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CRequestParameterDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the RequestParameter class to/from XML
+ namespace RequestParameterXml {
+
+ /// Adds the RequestParameterDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCRequestParameterDoc requestParameterDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the RequestParameterDoc from the XML.
+ SmartPtrCRequestParameterDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Nov 21, 2014
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ */
+
+#ifndef RequestXml_h_
+#define RequestXml_h_
+
+
+#include "Xml/XmlUtils/CXmlElement.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+
+namespace Caf {
+
+ namespace RequestXml {
+
+ SmartPtrCXmlElement CAFCORETYPESXML_LINKAGE parseString(
+ const std::string& xml,
+ const std::string& rootName);
+
+ SmartPtrCXmlElement CAFCORETYPESXML_LINKAGE parseFile(
+ const std::string& xml,
+ const std::string& rootName);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef StatisticsXml_h_
+#define StatisticsXml_h_
+
+
+#include "Doc/CafCoreTypesDoc/CStatisticsDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the Statistics class to/from XML
+ namespace StatisticsXml {
+
+ /// Adds the StatisticsDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCStatisticsDoc statisticsDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the StatisticsDoc from the XML.
+ SmartPtrCStatisticsDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef CafInstallRequestXml_Link_h_
+#define CafInstallRequestXml_Link_h_
+
+#ifndef CAFINSTALLREQUESTXML_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define CAFINSTALLREQUESTXML_LINKAGE __declspec(dllexport)
+ #else
+ #define CAFINSTALLREQUESTXML_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define CAFINSTALLREQUESTXML_LINKAGE
+ #endif
+#endif
+
+
+#endif /* CafInstallRequestXml_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef CafInstallRequestXmlRoots_h_
+#define CafInstallRequestXmlRoots_h_
+
+
+#include "Doc/CafInstallRequestDoc/CInstallPackageSpecDoc.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlLink.h"
+#include "Doc/CafInstallRequestDoc/CInstallProviderSpecDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallRequestDoc.h"
+
+namespace Caf {
+
+ namespace XmlRoots {
+
+ /// Saves the InstallRequestDoc to a string.
+ std::string CAFINSTALLREQUESTXML_LINKAGE saveInstallRequestToString(
+ const SmartPtrCInstallRequestDoc installRequestDoc);
+
+ /// Parses the InstallPackageSpecDoc from the string.
+ SmartPtrCInstallRequestDoc CAFINSTALLREQUESTXML_LINKAGE parseInstallRequestFromString(
+ const std::string xml);
+
+ /// Saves the InstallRequestDoc to a file.
+ void CAFINSTALLREQUESTXML_LINKAGE saveInstallRequestToFile(
+ const SmartPtrCInstallRequestDoc installRequestDoc,
+ const std::string filePath);
+
+ /// Parses the InstallPackageSpecDoc from the file.
+ SmartPtrCInstallRequestDoc CAFINSTALLREQUESTXML_LINKAGE parseInstallRequestFromFile(
+ const std::string filePath);
+
+ /// Saves the InstallProviderSpecDoc to a string.
+ std::string CAFINSTALLREQUESTXML_LINKAGE saveInstallProviderSpecToString(
+ const SmartPtrCInstallProviderSpecDoc installProviderSpecDoc);
+
+ /// Parses the InstallPackageSpecDoc from the string.
+ SmartPtrCInstallProviderSpecDoc CAFINSTALLREQUESTXML_LINKAGE parseInstallProviderSpecFromString(
+ const std::string xml);
+
+ /// Saves the InstallProviderSpecDoc to a file.
+ void CAFINSTALLREQUESTXML_LINKAGE saveInstallProviderSpecToFile(
+ const SmartPtrCInstallProviderSpecDoc installProviderSpecDoc,
+ const std::string filePath);
+
+ /// Parses the InstallPackageSpecDoc from the file.
+ SmartPtrCInstallProviderSpecDoc CAFINSTALLREQUESTXML_LINKAGE parseInstallProviderSpecFromFile(
+ const std::string filePath);
+
+ /// Saves the InstallPackageSpecDoc to a string.
+ std::string CAFINSTALLREQUESTXML_LINKAGE saveInstallPackageSpecToString(
+ const SmartPtrCInstallPackageSpecDoc installPackageSpecDoc);
+
+ /// Parses the InstallPackageSpecDoc from the string.
+ SmartPtrCInstallPackageSpecDoc CAFINSTALLREQUESTXML_LINKAGE parseInstallPackageSpecFromString(
+ const std::string xml);
+
+ /// Saves the InstallPackageSpecDoc to a file.
+ void CAFINSTALLREQUESTXML_LINKAGE saveInstallPackageSpecToFile(
+ const SmartPtrCInstallPackageSpecDoc installPackageSpecDoc,
+ const std::string filePath);
+
+ /// Parses the InstallPackageSpecDoc from the file.
+ SmartPtrCInstallPackageSpecDoc CAFINSTALLREQUESTXML_LINKAGE parseInstallPackageSpecFromFile(
+ const std::string filePath);
+ }
+}
+
+#endif /* CafInstallRequestXmlRoots_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef FullPackageElemXml_h_
+#define FullPackageElemXml_h_
+
+
+#include "Doc/CafInstallRequestDoc/CFullPackageElemDoc.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the FullPackageElem class to/from XML
+ namespace FullPackageElemXml {
+
+ /// Adds the FullPackageElemDoc into the XML.
+ void CAFINSTALLREQUESTXML_LINKAGE add(
+ const SmartPtrCFullPackageElemDoc fullPackageElemDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the FullPackageElemDoc from the XML.
+ SmartPtrCFullPackageElemDoc CAFINSTALLREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef GetInventoryJobXml_h_
+#define GetInventoryJobXml_h_
+
+
+#include "Doc/CafInstallRequestDoc/CGetInventoryJobDoc.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the GetInventoryJob class to/from XML
+ namespace GetInventoryJobXml {
+
+ /// Adds the GetInventoryJobDoc into the XML.
+ void CAFINSTALLREQUESTXML_LINKAGE add(
+ const SmartPtrCGetInventoryJobDoc getInventoryJobDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the GetInventoryJobDoc from the XML.
+ SmartPtrCGetInventoryJobDoc CAFINSTALLREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef InstallBatchXml_h_
+#define InstallBatchXml_h_
+
+
+#include "Doc/CafInstallRequestDoc/CInstallBatchDoc.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the InstallBatch class to/from XML
+ namespace InstallBatchXml {
+
+ /// Adds the InstallBatchDoc into the XML.
+ void CAFINSTALLREQUESTXML_LINKAGE add(
+ const SmartPtrCInstallBatchDoc installBatchDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the InstallBatchDoc from the XML.
+ SmartPtrCInstallBatchDoc CAFINSTALLREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef InstallPackageSpecXml_h_
+#define InstallPackageSpecXml_h_
+
+
+#include "Doc/CafInstallRequestDoc/CInstallPackageSpecDoc.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the InstallPackageSpec class to/from XML
+ namespace InstallPackageSpecXml {
+
+ /// Adds the InstallPackageSpecDoc into the XML.
+ void CAFINSTALLREQUESTXML_LINKAGE add(
+ const SmartPtrCInstallPackageSpecDoc installPackageSpecDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the InstallPackageSpecDoc from the XML.
+ SmartPtrCInstallPackageSpecDoc CAFINSTALLREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef InstallProviderJobXml_h_
+#define InstallProviderJobXml_h_
+
+
+#include "Doc/CafInstallRequestDoc/CInstallProviderJobDoc.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the InstallProviderJob class to/from XML
+ namespace InstallProviderJobXml {
+
+ /// Adds the InstallProviderJobDoc into the XML.
+ void CAFINSTALLREQUESTXML_LINKAGE add(
+ const SmartPtrCInstallProviderJobDoc installProviderJobDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the InstallProviderJobDoc from the XML.
+ SmartPtrCInstallProviderJobDoc CAFINSTALLREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef InstallProviderSpecXml_h_
+#define InstallProviderSpecXml_h_
+
+
+#include "Doc/CafInstallRequestDoc/CInstallProviderSpecDoc.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the InstallProviderSpec class to/from XML
+ namespace InstallProviderSpecXml {
+
+ /// Adds the InstallProviderSpecDoc into the XML.
+ void CAFINSTALLREQUESTXML_LINKAGE add(
+ const SmartPtrCInstallProviderSpecDoc installProviderSpecDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the InstallProviderSpecDoc from the XML.
+ SmartPtrCInstallProviderSpecDoc CAFINSTALLREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef InstallRequestXml_h_
+#define InstallRequestXml_h_
+
+
+#include "Doc/CafInstallRequestDoc/CInstallRequestDoc.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the InstallRequest class to/from XML
+ namespace InstallRequestXml {
+
+ /// Adds the InstallRequestDoc into the XML.
+ void CAFINSTALLREQUESTXML_LINKAGE add(
+ const SmartPtrCInstallRequestDoc installRequestDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the InstallRequestDoc from the XML.
+ SmartPtrCInstallRequestDoc CAFINSTALLREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MinPackageElemXml_h_
+#define MinPackageElemXml_h_
+
+
+#include "Doc/CafInstallRequestDoc/CMinPackageElemDoc.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the MinPackageElem class to/from XML
+ namespace MinPackageElemXml {
+
+ /// Adds the MinPackageElemDoc into the XML.
+ void CAFINSTALLREQUESTXML_LINKAGE add(
+ const SmartPtrCMinPackageElemDoc minPackageElemDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the MinPackageElemDoc from the XML.
+ SmartPtrCMinPackageElemDoc CAFINSTALLREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef PackageDefnXml_h_
+#define PackageDefnXml_h_
+
+
+#include "Doc/CafInstallRequestDoc/CPackageDefnDoc.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the PackageDefn class to/from XML
+ namespace PackageDefnXml {
+
+ /// Adds the PackageDefnDoc into the XML.
+ void CAFINSTALLREQUESTXML_LINKAGE add(
+ const SmartPtrCPackageDefnDoc packageDefnDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the PackageDefnDoc from the XML.
+ SmartPtrCPackageDefnDoc CAFINSTALLREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef UninstallProviderJobXml_h_
+#define UninstallProviderJobXml_h_
+
+
+#include "Doc/CafInstallRequestDoc/CUninstallProviderJobDoc.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the UninstallProviderJob class to/from XML
+ namespace UninstallProviderJobXml {
+
+ /// Adds the UninstallProviderJobDoc into the XML.
+ void CAFINSTALLREQUESTXML_LINKAGE add(
+ const SmartPtrCUninstallProviderJobDoc uninstallProviderJobDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the UninstallProviderJobDoc from the XML.
+ SmartPtrCUninstallProviderJobDoc CAFINSTALLREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef DiagRequestXml_h_
+#define DiagRequestXml_h_
+
+
+#include "Doc/DiagRequestDoc/CDiagRequestDoc.h"
+
+#include "Doc/DocXml/DiagRequestXml/DiagRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the DiagRequest class to/from XML
+ namespace DiagRequestXml {
+
+ /// Adds the DiagRequestDoc into the XML.
+ void DIAGREQUESTXML_LINKAGE add(
+ const SmartPtrCDiagRequestDoc diagRequestDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the DiagRequestDoc from the XML.
+ SmartPtrCDiagRequestDoc DIAGREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef DiagRequestXml_Link_h_
+#define DiagRequestXml_Link_h_
+
+#ifndef DIAGREQUESTXML_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define DIAGREQUESTXML_LINKAGE __declspec(dllexport)
+ #else
+ #define DIAGREQUESTXML_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define DIAGREQUESTXML_LINKAGE
+ #endif
+#endif
+
+
+#endif /* DiagRequestXml_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef DiagRequestXmlRoots_h_
+#define DiagRequestXmlRoots_h_
+
+
+#include "Doc/DiagRequestDoc/CDiagRequestDoc.h"
+
+#include "Doc/DocXml/DiagRequestXml/DiagRequestXmlLink.h"
+
+namespace Caf {
+
+ namespace XmlRoots {
+
+ /// Saves the DiagRequestDoc to a string.
+ std::string DIAGREQUESTXML_LINKAGE saveDiagRequestToString(
+ const SmartPtrCDiagRequestDoc diagRequestDoc);
+
+ /// Parses the DiagRequestDoc from the string.
+ SmartPtrCDiagRequestDoc DIAGREQUESTXML_LINKAGE parseDiagRequestFromString(
+ const std::string xml);
+
+ /// Saves the DiagRequestDoc to a file.
+ void DIAGREQUESTXML_LINKAGE saveDiagRequestToFile(
+ const SmartPtrCDiagRequestDoc diagRequestDoc,
+ const std::string filePath);
+
+ /// Parses the DiagRequestDoc from the file.
+ SmartPtrCDiagRequestDoc DIAGREQUESTXML_LINKAGE parseDiagRequestFromFile(
+ const std::string filePath);
+ }
+}
+
+#endif /* DiagRequestXmlRoots_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef DiagBatchXml_h_
+#define DiagBatchXml_h_
+
+
+#include "Doc/DiagTypesDoc/CDiagBatchDoc.h"
+
+#include "Doc/DocXml/DiagTypesXml/DiagTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the DiagBatch class to/from XML
+ namespace DiagBatchXml {
+
+ /// Adds the DiagBatchDoc into the XML.
+ void DIAGTYPESXML_LINKAGE add(
+ const SmartPtrCDiagBatchDoc diagBatchDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the DiagBatchDoc from the XML.
+ SmartPtrCDiagBatchDoc DIAGTYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef DiagCollectInstancesXml_h_
+#define DiagCollectInstancesXml_h_
+
+
+#include "Doc/DiagTypesDoc/CDiagCollectInstancesDoc.h"
+
+#include "Doc/DocXml/DiagTypesXml/DiagTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the DiagCollectInstances class to/from XML
+ namespace DiagCollectInstancesXml {
+
+ /// Adds the DiagCollectInstancesDoc into the XML.
+ void DIAGTYPESXML_LINKAGE add(
+ const SmartPtrCDiagCollectInstancesDoc diagCollectInstancesDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the DiagCollectInstancesDoc from the XML.
+ SmartPtrCDiagCollectInstancesDoc DIAGTYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef DiagDeleteValueCollectionXml_h_
+#define DiagDeleteValueCollectionXml_h_
+
+
+#include "Doc/DiagTypesDoc/CDiagDeleteValueCollectionDoc.h"
+
+#include "Doc/DocXml/DiagTypesXml/DiagTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the DiagDeleteValueCollection class to/from XML
+ namespace DiagDeleteValueCollectionXml {
+
+ /// Adds the DiagDeleteValueCollectionDoc into the XML.
+ void DIAGTYPESXML_LINKAGE add(
+ const SmartPtrCDiagDeleteValueCollectionDoc diagDeleteValueCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the DiagDeleteValueCollectionDoc from the XML.
+ SmartPtrCDiagDeleteValueCollectionDoc DIAGTYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef DiagDeleteValueXml_h_
+#define DiagDeleteValueXml_h_
+
+
+#include "Doc/DiagTypesDoc/CDiagDeleteValueDoc.h"
+
+#include "Doc/DocXml/DiagTypesXml/DiagTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the DiagDeleteValue class to/from XML
+ namespace DiagDeleteValueXml {
+
+ /// Adds the DiagDeleteValueDoc into the XML.
+ void DIAGTYPESXML_LINKAGE add(
+ const SmartPtrCDiagDeleteValueDoc diagDeleteValueDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the DiagDeleteValueDoc from the XML.
+ SmartPtrCDiagDeleteValueDoc DIAGTYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef DiagSetValueCollectionXml_h_
+#define DiagSetValueCollectionXml_h_
+
+
+#include "Doc/DiagTypesDoc/CDiagSetValueCollectionDoc.h"
+
+#include "Doc/DocXml/DiagTypesXml/DiagTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the DiagSetValueCollection class to/from XML
+ namespace DiagSetValueCollectionXml {
+
+ /// Adds the DiagSetValueCollectionDoc into the XML.
+ void DIAGTYPESXML_LINKAGE add(
+ const SmartPtrCDiagSetValueCollectionDoc diagSetValueCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the DiagSetValueCollectionDoc from the XML.
+ SmartPtrCDiagSetValueCollectionDoc DIAGTYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef DiagSetValueXml_h_
+#define DiagSetValueXml_h_
+
+
+#include "Doc/DiagTypesDoc/CDiagSetValueDoc.h"
+
+#include "Doc/DocXml/DiagTypesXml/DiagTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the DiagSetValue class to/from XML
+ namespace DiagSetValueXml {
+
+ /// Adds the DiagSetValueDoc into the XML.
+ void DIAGTYPESXML_LINKAGE add(
+ const SmartPtrCDiagSetValueDoc diagSetValueDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the DiagSetValueDoc from the XML.
+ SmartPtrCDiagSetValueDoc DIAGTYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef DiagTypesXml_Link_h_
+#define DiagTypesXml_Link_h_
+
+#ifndef DIAGTYPESXML_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define DIAGTYPESXML_LINKAGE __declspec(dllexport)
+ #else
+ #define DIAGTYPESXML_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define DIAGTYPESXML_LINKAGE
+ #endif
+#endif
+
+
+#endif /* DiagTypesXml_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MgmtRequestXml_h_
+#define MgmtRequestXml_h_
+
+
+#include "Doc/MgmtRequestDoc/CMgmtRequestDoc.h"
+
+#include "Doc/DocXml/MgmtRequestXml/MgmtRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the MgmtRequest class to/from XML
+ namespace MgmtRequestXml {
+
+ /// Adds the MgmtRequestDoc into the XML.
+ void MGMTREQUESTXML_LINKAGE add(
+ const SmartPtrCMgmtRequestDoc mgmtRequestDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the MgmtRequestDoc from the XML.
+ SmartPtrCMgmtRequestDoc MGMTREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MgmtRequestXml_Link_h_
+#define MgmtRequestXml_Link_h_
+
+#ifndef MGMTREQUESTXML_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define MGMTREQUESTXML_LINKAGE __declspec(dllexport)
+ #else
+ #define MGMTREQUESTXML_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define MGMTREQUESTXML_LINKAGE
+ #endif
+#endif
+
+
+#endif /* MgmtRequestXml_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MgmtRequestXmlRoots_h_
+#define MgmtRequestXmlRoots_h_
+
+
+#include "Doc/MgmtRequestDoc/CMgmtRequestDoc.h"
+
+#include "Doc/DocXml/MgmtRequestXml/MgmtRequestXmlLink.h"
+
+namespace Caf {
+
+ namespace XmlRoots {
+
+ /// Saves the MgmtRequestDoc to a string.
+ std::string MGMTREQUESTXML_LINKAGE saveMgmtRequestToString(
+ const SmartPtrCMgmtRequestDoc mgmtRequestDoc);
+
+ /// Parses the MgmtRequestDoc from the string.
+ SmartPtrCMgmtRequestDoc MGMTREQUESTXML_LINKAGE parseMgmtRequestFromString(
+ const std::string xml);
+
+ /// Saves the MgmtRequestDoc to a file.
+ void MGMTREQUESTXML_LINKAGE saveMgmtRequestToFile(
+ const SmartPtrCMgmtRequestDoc mgmtRequestDoc,
+ const std::string filePath);
+
+ /// Parses the MgmtRequestDoc from the file.
+ SmartPtrCMgmtRequestDoc MGMTREQUESTXML_LINKAGE parseMgmtRequestFromFile(
+ const std::string filePath);
+ }
+}
+
+#endif /* MgmtRequestXmlRoots_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MgmtBatchXml_h_
+#define MgmtBatchXml_h_
+
+
+#include "Doc/MgmtTypesDoc/CMgmtBatchDoc.h"
+
+#include "Doc/DocXml/MgmtTypesXml/MgmtTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the MgmtBatch class to/from XML
+ namespace MgmtBatchXml {
+
+ /// Adds the MgmtBatchDoc into the XML.
+ void MGMTTYPESXML_LINKAGE add(
+ const SmartPtrCMgmtBatchDoc mgmtBatchDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the MgmtBatchDoc from the XML.
+ SmartPtrCMgmtBatchDoc MGMTTYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MgmtCollectInstancesCollectionXml_h_
+#define MgmtCollectInstancesCollectionXml_h_
+
+
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesCollectionDoc.h"
+
+#include "Doc/DocXml/MgmtTypesXml/MgmtTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the MgmtCollectInstancesCollection class to/from XML
+ namespace MgmtCollectInstancesCollectionXml {
+
+ /// Adds the MgmtCollectInstancesCollectionDoc into the XML.
+ void MGMTTYPESXML_LINKAGE add(
+ const SmartPtrCMgmtCollectInstancesCollectionDoc mgmtCollectInstancesCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the MgmtCollectInstancesCollectionDoc from the XML.
+ SmartPtrCMgmtCollectInstancesCollectionDoc MGMTTYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MgmtCollectInstancesXml_h_
+#define MgmtCollectInstancesXml_h_
+
+
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesDoc.h"
+
+#include "Doc/DocXml/MgmtTypesXml/MgmtTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the MgmtCollectInstances class to/from XML
+ namespace MgmtCollectInstancesXml {
+
+ /// Adds the MgmtCollectInstancesDoc into the XML.
+ void MGMTTYPESXML_LINKAGE add(
+ const SmartPtrCMgmtCollectInstancesDoc mgmtCollectInstancesDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the MgmtCollectInstancesDoc from the XML.
+ SmartPtrCMgmtCollectInstancesDoc MGMTTYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MgmtCollectSchemaXml_h_
+#define MgmtCollectSchemaXml_h_
+
+
+#include "Doc/MgmtTypesDoc/CMgmtCollectSchemaDoc.h"
+
+#include "Doc/DocXml/MgmtTypesXml/MgmtTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the MgmtCollectSchema class to/from XML
+ namespace MgmtCollectSchemaXml {
+
+ /// Adds the MgmtCollectSchemaDoc into the XML.
+ void MGMTTYPESXML_LINKAGE add(
+ const SmartPtrCMgmtCollectSchemaDoc mgmtCollectSchemaDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the MgmtCollectSchemaDoc from the XML.
+ SmartPtrCMgmtCollectSchemaDoc MGMTTYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MgmtInvokeOperationCollectionXml_h_
+#define MgmtInvokeOperationCollectionXml_h_
+
+
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationCollectionDoc.h"
+
+#include "Doc/DocXml/MgmtTypesXml/MgmtTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the MgmtInvokeOperationCollection class to/from XML
+ namespace MgmtInvokeOperationCollectionXml {
+
+ /// Adds the MgmtInvokeOperationCollectionDoc into the XML.
+ void MGMTTYPESXML_LINKAGE add(
+ const SmartPtrCMgmtInvokeOperationCollectionDoc mgmtInvokeOperationCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the MgmtInvokeOperationCollectionDoc from the XML.
+ SmartPtrCMgmtInvokeOperationCollectionDoc MGMTTYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MgmtInvokeOperationXml_h_
+#define MgmtInvokeOperationXml_h_
+
+
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationDoc.h"
+
+#include "Doc/DocXml/MgmtTypesXml/MgmtTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the MgmtInvokeOperation class to/from XML
+ namespace MgmtInvokeOperationXml {
+
+ /// Adds the MgmtInvokeOperationDoc into the XML.
+ void MGMTTYPESXML_LINKAGE add(
+ const SmartPtrCMgmtInvokeOperationDoc mgmtInvokeOperationDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the MgmtInvokeOperationDoc from the XML.
+ SmartPtrCMgmtInvokeOperationDoc MGMTTYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MgmtTypesXml_Link_h_
+#define MgmtTypesXml_Link_h_
+
+#ifndef MGMTTYPESXML_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define MGMTTYPESXML_LINKAGE __declspec(dllexport)
+ #else
+ #define MGMTTYPESXML_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define MGMTTYPESXML_LINKAGE
+ #endif
+#endif
+
+
+#endif /* MgmtTypesXml_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MultiPmeMgmtBatchCollectionXml_h_
+#define MultiPmeMgmtBatchCollectionXml_h_
+
+
+#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtBatchCollectionDoc.h"
+
+#include "Doc/DocXml/MultiPmeMgmtRequestXml/MultiPmeMgmtRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the MultiPmeMgmtBatchCollection class to/from XML
+ namespace MultiPmeMgmtBatchCollectionXml {
+
+ /// Adds the MultiPmeMgmtBatchCollectionDoc into the XML.
+ void MULTIPMEMGMTREQUESTXML_LINKAGE add(
+ const SmartPtrCMultiPmeMgmtBatchCollectionDoc multiPmeMgmtBatchCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the MultiPmeMgmtBatchCollectionDoc from the XML.
+ SmartPtrCMultiPmeMgmtBatchCollectionDoc MULTIPMEMGMTREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MultiPmeMgmtBatchXml_h_
+#define MultiPmeMgmtBatchXml_h_
+
+
+#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtBatchDoc.h"
+
+#include "Doc/DocXml/MultiPmeMgmtRequestXml/MultiPmeMgmtRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the MultiPmeMgmtBatch class to/from XML
+ namespace MultiPmeMgmtBatchXml {
+
+ /// Adds the MultiPmeMgmtBatchDoc into the XML.
+ void MULTIPMEMGMTREQUESTXML_LINKAGE add(
+ const SmartPtrCMultiPmeMgmtBatchDoc multiPmeMgmtBatchDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the MultiPmeMgmtBatchDoc from the XML.
+ SmartPtrCMultiPmeMgmtBatchDoc MULTIPMEMGMTREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MultiPmeMgmtRequestXml_h_
+#define MultiPmeMgmtRequestXml_h_
+
+
+#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtRequestDoc.h"
+
+#include "Doc/DocXml/MultiPmeMgmtRequestXml/MultiPmeMgmtRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the MultiPmeMgmtRequest class to/from XML
+ namespace MultiPmeMgmtRequestXml {
+
+ /// Adds the MultiPmeMgmtRequestDoc into the XML.
+ void MULTIPMEMGMTREQUESTXML_LINKAGE add(
+ const SmartPtrCMultiPmeMgmtRequestDoc multiPmeMgmtRequestDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the MultiPmeMgmtRequestDoc from the XML.
+ SmartPtrCMultiPmeMgmtRequestDoc MULTIPMEMGMTREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MultiPmeMgmtRequestXml_Link_h_
+#define MultiPmeMgmtRequestXml_Link_h_
+
+#ifndef MULTIPMEMGMTREQUESTXML_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define MULTIPMEMGMTREQUESTXML_LINKAGE __declspec(dllexport)
+ #else
+ #define MULTIPMEMGMTREQUESTXML_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define MULTIPMEMGMTREQUESTXML_LINKAGE
+ #endif
+#endif
+
+
+#endif /* MultiPmeMgmtRequestXml_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MultiPmeMgmtRequestXmlRoots_h_
+#define MultiPmeMgmtRequestXmlRoots_h_
+
+
+#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtRequestDoc.h"
+
+#include "Doc/DocXml/MultiPmeMgmtRequestXml/MultiPmeMgmtRequestXmlLink.h"
+
+namespace Caf {
+
+ namespace XmlRoots {
+
+ /// Saves the MultiPmeMgmtRequestDoc to a string.
+ std::string MULTIPMEMGMTREQUESTXML_LINKAGE saveMultiPmeMgmtRequestToString(
+ const SmartPtrCMultiPmeMgmtRequestDoc multiPmeMgmtRequestDoc);
+
+ /// Parses the MultiPmeMgmtRequestDoc from the string.
+ SmartPtrCMultiPmeMgmtRequestDoc MULTIPMEMGMTREQUESTXML_LINKAGE parseMultiPmeMgmtRequestFromString(
+ const std::string xml);
+
+ /// Saves the MultiPmeMgmtRequestDoc to a file.
+ void MULTIPMEMGMTREQUESTXML_LINKAGE saveMultiPmeMgmtRequestToFile(
+ const SmartPtrCMultiPmeMgmtRequestDoc multiPmeMgmtRequestDoc,
+ const std::string filePath);
+
+ /// Parses the MultiPmeMgmtRequestDoc from the file.
+ SmartPtrCMultiPmeMgmtRequestDoc MULTIPMEMGMTREQUESTXML_LINKAGE parseMultiPmeMgmtRequestFromFile(
+ const std::string filePath);
+ }
+}
+
+#endif /* MultiPmeMgmtRequestXmlRoots_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef PmeIdCollectionXml_h_
+#define PmeIdCollectionXml_h_
+
+
+#include "Doc/MultiPmeMgmtRequestDoc/CPmeIdCollectionDoc.h"
+
+#include "Doc/DocXml/MultiPmeMgmtRequestXml/MultiPmeMgmtRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the PmeIdCollection class to/from XML
+ namespace PmeIdCollectionXml {
+
+ /// Adds the PmeIdCollectionDoc into the XML.
+ void MULTIPMEMGMTREQUESTXML_LINKAGE add(
+ const SmartPtrCPmeIdCollectionDoc pmeIdCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the PmeIdCollectionDoc from the XML.
+ SmartPtrCPmeIdCollectionDoc MULTIPMEMGMTREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: July 3, 2015
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef PayloadEnvelopeXml_h_
+#define PayloadEnvelopeXml_h_
+
+
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+
+#include "Doc/DocXml/PayloadEnvelopeXml/PayloadEnvelopeXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the PayloadEnvelope class to/from XML
+ namespace PayloadEnvelopeXml {
+
+ /// Adds the PayloadEnvelopeDoc into the XML.
+ void PAYLOADENVELOPEXML_LINKAGE add(
+ const SmartPtrCPayloadEnvelopeDoc payloadEnvelopeDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the PayloadEnvelopeDoc from the XML.
+ SmartPtrCPayloadEnvelopeDoc PAYLOADENVELOPEXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef PayloadEnvelopeXml_Link_h_
+#define PayloadEnvelopeXml_Link_h_
+
+#ifndef PAYLOADENVELOPEXML_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define PAYLOADENVELOPEXML_LINKAGE __declspec(dllexport)
+ #else
+ #define PAYLOADENVELOPEXML_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define PAYLOADENVELOPEXML_LINKAGE
+ #endif
+#endif
+
+
+#endif /* PayloadEnvelopeXml_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef PayloadEnvelopeXmlRoots_h_
+#define PayloadEnvelopeXmlRoots_h_
+
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+
+#include "Doc/DocXml/PayloadEnvelopeXml/PayloadEnvelopeXmlLink.h"
+#include "Doc/DocXml/PayloadEnvelopeXml/PayloadEnvelopeXmlRoots.h"
+
+namespace Caf {
+
+ namespace XmlRoots {
+ /// Saves the PayloadEnvelopeDoc to a string.
+ std::string PAYLOADENVELOPEXML_LINKAGE savePayloadEnvelopeToString(
+ const SmartPtrCPayloadEnvelopeDoc payloadEnvelopeDoc);
+
+ /// Parses the PayloadEnvelopeDoc from the string.
+ SmartPtrCPayloadEnvelopeDoc PAYLOADENVELOPEXML_LINKAGE parsePayloadEnvelopeFromString(
+ const std::string xml);
+
+ /// Saves the PayloadEnvelopeDoc to a file.
+ void PAYLOADENVELOPEXML_LINKAGE savePayloadEnvelopeToFile(
+ const SmartPtrCPayloadEnvelopeDoc payloadEnvelopeDoc,
+ const std::string filePath);
+
+ /// Parses the PayloadEnvelopeDoc from the file.
+ SmartPtrCPayloadEnvelopeDoc PAYLOADENVELOPEXML_LINKAGE parsePayloadEnvelopeFromFile(
+ const std::string filePath);
+ }
+}
+
+#endif /* PayloadEnvelopeXmlRoots_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Nov 16, 2015
+ *
+ * Copyright (c) 2015 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ */
+
+#ifndef CertCollectionXml_h_
+#define CertCollectionXml_h_
+
+
+#include "Doc/PersistenceDoc/CCertCollectionDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the CertCollection class to/from XML
+ namespace CertCollectionXml {
+
+ /// Adds the CertCollectionDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCCertCollectionDoc certCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the CertCollectionDoc from the XML.
+ SmartPtrCCertCollectionDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Nov 16, 2015
+ *
+ * Copyright (c) 2015 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ */
+
+#ifndef CertPathCollectionXml_h_
+#define CertPathCollectionXml_h_
+
+
+#include "Doc/PersistenceDoc/CCertPathCollectionDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the CertPathCollection class to/from XML
+ namespace CertPathCollectionXml {
+
+ /// Adds the CertPathCollectionDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCCertPathCollectionDoc certPathCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the CertPathCollectionDoc from the XML.
+ SmartPtrCCertPathCollectionDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Nov 16, 2015
+ *
+ * Copyright (c) 2015 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ */
+
+#ifndef LocalSecurityXml_h_
+#define LocalSecurityXml_h_
+
+
+#include "Doc/PersistenceDoc/CLocalSecurityDoc.h"
+
+#include "Doc/DocXml/PersistenceXml/PersistenceXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the LocalSecurity class to/from XML
+ namespace LocalSecurityXml {
+
+ /// Adds the LocalSecurityDoc into the XML.
+ void PERSISTENCEXML_LINKAGE add(
+ const SmartPtrCLocalSecurityDoc localSecurityDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the LocalSecurityDoc from the XML.
+ SmartPtrCLocalSecurityDoc PERSISTENCEXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Nov 16, 2015
+ *
+ * Copyright (c) 2015 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ */
+
+#ifndef PersistenceProtocolCollectionXml_h_
+#define PersistenceProtocolCollectionXml_h_
+
+
+#include "Doc/PersistenceDoc/CPersistenceProtocolCollectionDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the PersistenceProtocolCollection class to/from XML
+ namespace PersistenceProtocolCollectionXml {
+
+ /// Adds the PersistenceProtocolCollectionDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCPersistenceProtocolCollectionDoc persistenceProtocolCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the PersistenceProtocolCollectionDoc from the XML.
+ SmartPtrCPersistenceProtocolCollectionDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Nov 16, 2015
+ *
+ * Copyright (c) 2015 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ */
+
+#ifndef PersistenceProtocolXml_h_
+#define PersistenceProtocolXml_h_
+
+
+#include "Doc/PersistenceDoc/CPersistenceProtocolDoc.h"
+
+#include "Doc/DocXml/PersistenceXml/PersistenceXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the PersistenceProtocol class to/from XML
+ namespace PersistenceProtocolXml {
+
+ /// Adds the PersistenceProtocolDoc into the XML.
+ void PERSISTENCEXML_LINKAGE add(
+ const SmartPtrCPersistenceProtocolDoc persistenceProtocolDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the PersistenceProtocolDoc from the XML.
+ SmartPtrCPersistenceProtocolDoc PERSISTENCEXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Nov 16, 2015
+ *
+ * Copyright (c) 2015 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ */
+
+#ifndef PersistenceXml_h_
+#define PersistenceXml_h_
+
+
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+
+#include "Doc/DocXml/PersistenceXml/PersistenceXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the Persistence class to/from XML
+ namespace PersistenceXml {
+
+ /// Adds the PersistenceDoc into the XML.
+ void PERSISTENCEXML_LINKAGE add(
+ const SmartPtrCPersistenceDoc persistenceDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the PersistenceDoc from the XML.
+ SmartPtrCPersistenceDoc PERSISTENCEXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Nov 16, 2015
+ *
+ * Copyright (c) 2015 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ */
+
+#ifndef PersistenceXml_Link_h_
+#define PersistenceXml_Link_h_
+
+#ifndef PERSISTENCEXML_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define PERSISTENCEXML_LINKAGE __declspec(dllexport)
+ #else
+ #define PERSISTENCEXML_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define PERSISTENCEXML_LINKAGE
+ #endif
+#endif
+
+
+#endif /* PersistenceXml_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Nov 16, 2015
+ *
+ * Copyright (c) 2015 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ */
+
+#ifndef PersistenceXmlRoots_h_
+#define PersistenceXmlRoots_h_
+
+
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+
+#include "Doc/DocXml/PersistenceXml/PersistenceXmlLink.h"
+
+namespace Caf {
+
+ namespace XmlRoots {
+ /// Saves the PersistenceDoc to a string.
+ std::string PERSISTENCEXML_LINKAGE savePersistenceToString(
+ const SmartPtrCPersistenceDoc persistenceDoc);
+
+ /// Parses the PersistenceDoc from the string.
+ SmartPtrCPersistenceDoc PERSISTENCEXML_LINKAGE parsePersistenceFromString(
+ const std::string xml);
+
+ /// Saves the PersistenceDoc to a file.
+ void PERSISTENCEXML_LINKAGE savePersistenceToFile(
+ const SmartPtrCPersistenceDoc persistenceDoc,
+ const std::string filePath);
+
+ /// Parses the PersistenceDoc from the file.
+ SmartPtrCPersistenceDoc PERSISTENCEXML_LINKAGE parsePersistenceFromFile(
+ const std::string filePath);
+ }
+}
+
+#endif /* PersistenceXmlRoots_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Nov 16, 2015
+ *
+ * Copyright (c) 2015 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ */
+
+#ifndef RemoteSecurityCollectionXml_h_
+#define RemoteSecurityCollectionXml_h_
+
+
+#include "Doc/PersistenceDoc/CRemoteSecurityCollectionDoc.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the RemoteSecurityCollection class to/from XML
+ namespace RemoteSecurityCollectionXml {
+
+ /// Adds the RemoteSecurityCollectionDoc into the XML.
+ void CAFCORETYPESXML_LINKAGE add(
+ const SmartPtrCRemoteSecurityCollectionDoc remoteSecurityCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the RemoteSecurityCollectionDoc from the XML.
+ SmartPtrCRemoteSecurityCollectionDoc CAFCORETYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Nov 16, 2015
+ *
+ * Copyright (c) 2015 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ */
+
+#ifndef RemoteSecurityXml_h_
+#define RemoteSecurityXml_h_
+
+
+#include "Doc/PersistenceDoc/CRemoteSecurityDoc.h"
+
+#include "Doc/DocXml/PersistenceXml/PersistenceXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the RemoteSecurity class to/from XML
+ namespace RemoteSecurityXml {
+
+ /// Adds the RemoteSecurityDoc into the XML.
+ void PERSISTENCEXML_LINKAGE add(
+ const SmartPtrCRemoteSecurityDoc remoteSecurityDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the RemoteSecurityDoc from the XML.
+ SmartPtrCRemoteSecurityDoc PERSISTENCEXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ClassCollectionXml_h_
+#define ClassCollectionXml_h_
+
+
+#include "Doc/ProviderInfraDoc/CClassCollectionDoc.h"
+
+#include "Doc/DocXml/ProviderInfraXml/ProviderInfraXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ClassCollection class to/from XML
+ namespace ClassCollectionXml {
+
+ /// Adds the ClassCollectionDoc into the XML.
+ void PROVIDERINFRAXML_LINKAGE add(
+ const SmartPtrCClassCollectionDoc classCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ClassCollectionDoc from the XML.
+ SmartPtrCClassCollectionDoc PROVIDERINFRAXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderInfraXml_Link_h_
+#define ProviderInfraXml_Link_h_
+
+#ifndef PROVIDERINFRAXML_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define PROVIDERINFRAXML_LINKAGE __declspec(dllexport)
+ #else
+ #define PROVIDERINFRAXML_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define PROVIDERINFRAXML_LINKAGE
+ #endif
+#endif
+
+
+#endif /* ProviderInfraXml_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderInfraXmlRoots_h_
+#define ProviderInfraXmlRoots_h_
+
+
+#include "Doc/ProviderInfraDoc/CProviderRegDoc.h"
+
+#include "Doc/DocXml/ProviderInfraXml/ProviderInfraXmlLink.h"
+#include "Doc/ProviderInfraDoc/CSchemaSummaryDoc.h"
+
+namespace Caf {
+
+ namespace XmlRoots {
+
+ /// Saves the ProviderRegDoc to a string.
+ std::string PROVIDERINFRAXML_LINKAGE saveProviderRegToString(
+ const SmartPtrCProviderRegDoc providerRegDoc);
+
+ /// Parses the SchemaSummaryDoc from the string.
+ SmartPtrCProviderRegDoc PROVIDERINFRAXML_LINKAGE parseProviderRegFromString(
+ const std::string xml);
+
+ /// Saves the ProviderRegDoc to a file.
+ void PROVIDERINFRAXML_LINKAGE saveProviderRegToFile(
+ const SmartPtrCProviderRegDoc providerRegDoc,
+ const std::string filePath);
+
+ /// Parses the SchemaSummaryDoc from the file.
+ SmartPtrCProviderRegDoc PROVIDERINFRAXML_LINKAGE parseProviderRegFromFile(
+ const std::string filePath);
+
+ /// Saves the SchemaSummaryDoc to a string.
+ std::string PROVIDERINFRAXML_LINKAGE saveSchemaSummaryToString(
+ const SmartPtrCSchemaSummaryDoc schemaSummaryDoc);
+
+ /// Parses the SchemaSummaryDoc from the string.
+ SmartPtrCSchemaSummaryDoc PROVIDERINFRAXML_LINKAGE parseSchemaSummaryFromString(
+ const std::string xml);
+
+ /// Saves the SchemaSummaryDoc to a file.
+ void PROVIDERINFRAXML_LINKAGE saveSchemaSummaryToFile(
+ const SmartPtrCSchemaSummaryDoc schemaSummaryDoc,
+ const std::string filePath);
+
+ /// Parses the SchemaSummaryDoc from the file.
+ SmartPtrCSchemaSummaryDoc PROVIDERINFRAXML_LINKAGE parseSchemaSummaryFromFile(
+ const std::string filePath);
+ }
+}
+
+#endif /* ProviderInfraXmlRoots_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderRegXml_h_
+#define ProviderRegXml_h_
+
+
+#include "Doc/ProviderInfraDoc/CProviderRegDoc.h"
+
+#include "Doc/DocXml/ProviderInfraXml/ProviderInfraXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ProviderReg class to/from XML
+ namespace ProviderRegXml {
+
+ /// Adds the ProviderRegDoc into the XML.
+ void PROVIDERINFRAXML_LINKAGE add(
+ const SmartPtrCProviderRegDoc providerRegDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ProviderRegDoc from the XML.
+ SmartPtrCProviderRegDoc PROVIDERINFRAXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef SchemaSummaryXml_h_
+#define SchemaSummaryXml_h_
+
+
+#include "Doc/ProviderInfraDoc/CSchemaSummaryDoc.h"
+
+#include "Doc/DocXml/ProviderInfraXml/ProviderInfraXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the SchemaSummary class to/from XML
+ namespace SchemaSummaryXml {
+
+ /// Adds the SchemaSummaryDoc into the XML.
+ void PROVIDERINFRAXML_LINKAGE add(
+ const SmartPtrCSchemaSummaryDoc schemaSummaryDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the SchemaSummaryDoc from the XML.
+ SmartPtrCSchemaSummaryDoc PROVIDERINFRAXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderBatchXml_h_
+#define ProviderBatchXml_h_
+
+
+#include "Doc/ProviderRequestDoc/CProviderBatchDoc.h"
+
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ProviderBatch class to/from XML
+ namespace ProviderBatchXml {
+
+ /// Adds the ProviderBatchDoc into the XML.
+ void PROVIDERREQUESTXML_LINKAGE add(
+ const SmartPtrCProviderBatchDoc providerBatchDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ProviderBatchDoc from the XML.
+ SmartPtrCProviderBatchDoc PROVIDERREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderCollectInstancesCollectionXml_h_
+#define ProviderCollectInstancesCollectionXml_h_
+
+
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesCollectionDoc.h"
+
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ProviderCollectInstancesCollection class to/from XML
+ namespace ProviderCollectInstancesCollectionXml {
+
+ /// Adds the ProviderCollectInstancesCollectionDoc into the XML.
+ void PROVIDERREQUESTXML_LINKAGE add(
+ const SmartPtrCProviderCollectInstancesCollectionDoc providerCollectInstancesCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ProviderCollectInstancesCollectionDoc from the XML.
+ SmartPtrCProviderCollectInstancesCollectionDoc PROVIDERREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderCollectInstancesXml_h_
+#define ProviderCollectInstancesXml_h_
+
+
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesDoc.h"
+
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ProviderCollectInstances class to/from XML
+ namespace ProviderCollectInstancesXml {
+
+ /// Adds the ProviderCollectInstancesDoc into the XML.
+ void PROVIDERREQUESTXML_LINKAGE add(
+ const SmartPtrCProviderCollectInstancesDoc providerCollectInstancesDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ProviderCollectInstancesDoc from the XML.
+ SmartPtrCProviderCollectInstancesDoc PROVIDERREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderCollectSchemaRequestXml_h_
+#define ProviderCollectSchemaRequestXml_h_
+
+
+#include "Doc/ProviderRequestDoc/CProviderCollectSchemaRequestDoc.h"
+
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ProviderCollectSchemaRequest class to/from XML
+ namespace ProviderCollectSchemaRequestXml {
+
+ /// Adds the ProviderCollectSchemaRequestDoc into the XML.
+ void PROVIDERREQUESTXML_LINKAGE add(
+ const SmartPtrCProviderCollectSchemaRequestDoc providerCollectSchemaRequestDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ProviderCollectSchemaRequestDoc from the XML.
+ SmartPtrCProviderCollectSchemaRequestDoc PROVIDERREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderInvokeOperationCollectionXml_h_
+#define ProviderInvokeOperationCollectionXml_h_
+
+
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationCollectionDoc.h"
+
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ProviderInvokeOperationCollection class to/from XML
+ namespace ProviderInvokeOperationCollectionXml {
+
+ /// Adds the ProviderInvokeOperationCollectionDoc into the XML.
+ void PROVIDERREQUESTXML_LINKAGE add(
+ const SmartPtrCProviderInvokeOperationCollectionDoc providerInvokeOperationCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ProviderInvokeOperationCollectionDoc from the XML.
+ SmartPtrCProviderInvokeOperationCollectionDoc PROVIDERREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderInvokeOperationXml_h_
+#define ProviderInvokeOperationXml_h_
+
+
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationDoc.h"
+
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ProviderInvokeOperation class to/from XML
+ namespace ProviderInvokeOperationXml {
+
+ /// Adds the ProviderInvokeOperationDoc into the XML.
+ void PROVIDERREQUESTXML_LINKAGE add(
+ const SmartPtrCProviderInvokeOperationDoc providerInvokeOperationDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ProviderInvokeOperationDoc from the XML.
+ SmartPtrCProviderInvokeOperationDoc PROVIDERREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderRequestConfigXml_h_
+#define ProviderRequestConfigXml_h_
+
+
+#include "Doc/ProviderRequestDoc/CProviderRequestConfigDoc.h"
+
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ProviderRequestConfig class to/from XML
+ namespace ProviderRequestConfigXml {
+
+ /// Adds the ProviderRequestConfigDoc into the XML.
+ void PROVIDERREQUESTXML_LINKAGE add(
+ const SmartPtrCProviderRequestConfigDoc providerRequestConfigDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ProviderRequestConfigDoc from the XML.
+ SmartPtrCProviderRequestConfigDoc PROVIDERREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderRequestHeaderXml_h_
+#define ProviderRequestHeaderXml_h_
+
+
+#include "Doc/ProviderRequestDoc/CProviderRequestHeaderDoc.h"
+
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ProviderRequestHeader class to/from XML
+ namespace ProviderRequestHeaderXml {
+
+ /// Adds the ProviderRequestHeaderDoc into the XML.
+ void PROVIDERREQUESTXML_LINKAGE add(
+ const SmartPtrCProviderRequestHeaderDoc providerRequestHeaderDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ProviderRequestHeaderDoc from the XML.
+ SmartPtrCProviderRequestHeaderDoc PROVIDERREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderRequestXml_h_
+#define ProviderRequestXml_h_
+
+
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ProviderRequest class to/from XML
+ namespace ProviderRequestXml {
+
+ /// Adds the ProviderRequestDoc into the XML.
+ void PROVIDERREQUESTXML_LINKAGE add(
+ const SmartPtrCProviderRequestDoc providerRequestDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ProviderRequestDoc from the XML.
+ SmartPtrCProviderRequestDoc PROVIDERREQUESTXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderRequestXml_Link_h_
+#define ProviderRequestXml_Link_h_
+
+#ifndef PROVIDERREQUESTXML_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define PROVIDERREQUESTXML_LINKAGE __declspec(dllexport)
+ #else
+ #define PROVIDERREQUESTXML_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define PROVIDERREQUESTXML_LINKAGE
+ #endif
+#endif
+
+
+#endif /* ProviderRequestXml_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderRequestXmlRoots_h_
+#define ProviderRequestXmlRoots_h_
+
+
+#include "Doc/ProviderRequestDoc/CProviderCollectSchemaRequestDoc.h"
+
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXmlLink.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+
+namespace Caf {
+
+ namespace XmlRoots {
+
+ /// Saves the ProviderCollectSchemaRequestDoc to a string.
+ std::string PROVIDERREQUESTXML_LINKAGE saveProviderCollectSchemaRequestToString(
+ const SmartPtrCProviderCollectSchemaRequestDoc providerCollectSchemaRequestDoc);
+
+ /// Parses the ProviderCollectSchemaRequestDoc from the string.
+ SmartPtrCProviderCollectSchemaRequestDoc PROVIDERREQUESTXML_LINKAGE parseProviderCollectSchemaRequestFromString(
+ const std::string xml);
+
+ /// Saves the ProviderCollectSchemaRequestDoc to a file.
+ void PROVIDERREQUESTXML_LINKAGE saveProviderCollectSchemaRequestToFile(
+ const SmartPtrCProviderCollectSchemaRequestDoc providerCollectSchemaRequestDoc,
+ const std::string filePath);
+
+ /// Parses the ProviderCollectSchemaRequestDoc from the file.
+ SmartPtrCProviderCollectSchemaRequestDoc PROVIDERREQUESTXML_LINKAGE parseProviderCollectSchemaRequestFromFile(
+ const std::string filePath);
+
+ /// Saves the ProviderRequestDoc to a string.
+ std::string PROVIDERREQUESTXML_LINKAGE saveProviderRequestToString(
+ const SmartPtrCProviderRequestDoc providerRequestDoc);
+
+ /// Parses the ProviderCollectSchemaRequestDoc from the string.
+ SmartPtrCProviderRequestDoc PROVIDERREQUESTXML_LINKAGE parseProviderRequestFromString(
+ const std::string xml);
+
+ /// Saves the ProviderRequestDoc to a file.
+ void PROVIDERREQUESTXML_LINKAGE saveProviderRequestToFile(
+ const SmartPtrCProviderRequestDoc providerRequestDoc,
+ const std::string filePath);
+
+ /// Parses the ProviderCollectSchemaRequestDoc from the file.
+ SmartPtrCProviderRequestDoc PROVIDERREQUESTXML_LINKAGE parseProviderRequestFromFile(
+ const std::string filePath);
+ }
+}
+
+#endif /* ProviderRequestXmlRoots_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef CdifXml_h_
+#define CdifXml_h_
+
+
+#include "Doc/ProviderResultsDoc/CCdifDoc.h"
+
+#include "Doc/DocXml/ProviderResultsXml/ProviderResultsXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the Cdif class to/from XML
+ namespace CdifXml {
+
+ /// Adds the CdifDoc into the XML.
+ void PROVIDERRESULTSXML_LINKAGE add(
+ const SmartPtrCCdifDoc cdifDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the CdifDoc from the XML.
+ SmartPtrCCdifDoc PROVIDERRESULTSXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef DefinitionObjectCollectionXml_h_
+#define DefinitionObjectCollectionXml_h_
+
+
+#include "Doc/ProviderResultsDoc/CDefinitionObjectCollectionDoc.h"
+
+#include "Doc/DocXml/ProviderResultsXml/ProviderResultsXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the DefinitionObjectCollection class to/from XML
+ namespace DefinitionObjectCollectionXml {
+
+ /// Adds the DefinitionObjectCollectionDoc into the XML.
+ void PROVIDERRESULTSXML_LINKAGE add(
+ const SmartPtrCDefinitionObjectCollectionDoc definitionObjectCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the DefinitionObjectCollectionDoc from the XML.
+ SmartPtrCDefinitionObjectCollectionDoc PROVIDERRESULTSXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderResultsXml_Link_h_
+#define ProviderResultsXml_Link_h_
+
+#ifndef PROVIDERRESULTSXML_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define PROVIDERRESULTSXML_LINKAGE __declspec(dllexport)
+ #else
+ #define PROVIDERRESULTSXML_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define PROVIDERRESULTSXML_LINKAGE
+ #endif
+#endif
+
+
+#endif /* ProviderResultsXml_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderResultsXmlRoots_h_
+#define ProviderResultsXmlRoots_h_
+
+
+#include "Doc/ProviderResultsDoc/CCdifDoc.h"
+
+#include "Doc/DocXml/ProviderResultsXml/ProviderResultsXmlLink.h"
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+
+namespace Caf {
+
+ namespace XmlRoots {
+
+ /// Saves the SchemaDoc to a string.
+ std::string PROVIDERRESULTSXML_LINKAGE saveSchemaToString(
+ const SmartPtrCSchemaDoc schemaDoc);
+
+ /// Parses the DefinitionObjectCollectionDoc from the string.
+ SmartPtrCSchemaDoc PROVIDERRESULTSXML_LINKAGE parseSchemaFromString(
+ const std::string xml);
+
+ /// Saves the SchemaDoc to a file.
+ void PROVIDERRESULTSXML_LINKAGE saveSchemaToFile(
+ const SmartPtrCSchemaDoc schemaDoc,
+ const std::string filePath);
+
+ /// Parses the DefinitionObjectCollectionDoc from the file.
+ SmartPtrCSchemaDoc PROVIDERRESULTSXML_LINKAGE parseSchemaFromFile(
+ const std::string filePath);
+
+ /// Saves the CdifDoc to a string.
+ std::string PROVIDERRESULTSXML_LINKAGE saveCdifToString(
+ const SmartPtrCCdifDoc cdifDoc);
+
+ /// Parses the DefinitionObjectCollectionDoc from the string.
+ SmartPtrCCdifDoc PROVIDERRESULTSXML_LINKAGE parseCdifFromString(
+ const std::string xml);
+
+ /// Saves the CdifDoc to a file.
+ void PROVIDERRESULTSXML_LINKAGE saveCdifToFile(
+ const SmartPtrCCdifDoc cdifDoc,
+ const std::string filePath);
+
+ /// Parses the DefinitionObjectCollectionDoc from the file.
+ SmartPtrCCdifDoc PROVIDERRESULTSXML_LINKAGE parseCdifFromFile(
+ const std::string filePath);
+ }
+}
+
+#endif /* ProviderResultsXmlRoots_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef RequestIdentifierXml_h_
+#define RequestIdentifierXml_h_
+
+
+#include "Doc/ProviderResultsDoc/CRequestIdentifierDoc.h"
+
+#include "Doc/DocXml/ProviderResultsXml/ProviderResultsXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the RequestIdentifier class to/from XML
+ namespace RequestIdentifierXml {
+
+ /// Adds the RequestIdentifierDoc into the XML.
+ void PROVIDERRESULTSXML_LINKAGE add(
+ const SmartPtrCRequestIdentifierDoc requestIdentifierDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the RequestIdentifierDoc from the XML.
+ SmartPtrCRequestIdentifierDoc PROVIDERRESULTSXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef SchemaXml_h_
+#define SchemaXml_h_
+
+
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+
+#include "Doc/DocXml/ProviderResultsXml/ProviderResultsXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the Schema class to/from XML
+ namespace SchemaXml {
+
+ /// Adds the SchemaDoc into the XML.
+ void PROVIDERRESULTSXML_LINKAGE add(
+ const SmartPtrCSchemaDoc schemaDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the SchemaDoc from the XML.
+ SmartPtrCSchemaDoc PROVIDERRESULTSXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ErrorResponseXml_h_
+#define ErrorResponseXml_h_
+
+
+#include "Doc/ResponseDoc/CErrorResponseDoc.h"
+
+#include "Doc/DocXml/ResponseXml/ResponseXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ErrorResponse class to/from XML
+ namespace ErrorResponseXml {
+
+ /// Adds the ErrorResponseDoc into the XML.
+ void RESPONSEXML_LINKAGE add(
+ const SmartPtrCErrorResponseDoc errorResponseDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ErrorResponseDoc from the XML.
+ SmartPtrCErrorResponseDoc RESPONSEXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef EventKeyCollectionXml_h_
+#define EventKeyCollectionXml_h_
+
+
+#include "Doc/ResponseDoc/CEventKeyCollectionDoc.h"
+
+#include "Doc/DocXml/ResponseXml/ResponseXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the EventKeyCollection class to/from XML
+ namespace EventKeyCollectionXml {
+
+ /// Adds the EventKeyCollectionDoc into the XML.
+ void RESPONSEXML_LINKAGE add(
+ const SmartPtrCEventKeyCollectionDoc eventKeyCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the EventKeyCollectionDoc from the XML.
+ SmartPtrCEventKeyCollectionDoc RESPONSEXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef EventKeyXml_h_
+#define EventKeyXml_h_
+
+
+#include "Doc/ResponseDoc/CEventKeyDoc.h"
+
+#include "Doc/DocXml/ResponseXml/ResponseXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the EventKey class to/from XML
+ namespace EventKeyXml {
+
+ /// Adds the EventKeyDoc into the XML.
+ void RESPONSEXML_LINKAGE add(
+ const SmartPtrCEventKeyDoc eventKeyDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the EventKeyDoc from the XML.
+ SmartPtrCEventKeyDoc RESPONSEXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef EventManifestXml_h_
+#define EventManifestXml_h_
+
+
+#include "Doc/ResponseDoc/CEventManifestDoc.h"
+
+#include "Doc/DocXml/ResponseXml/ResponseXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the EventManifest class to/from XML
+ namespace EventManifestXml {
+
+ /// Adds the EventManifestDoc into the XML.
+ void RESPONSEXML_LINKAGE add(
+ const SmartPtrCEventManifestDoc eventManifestDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the EventManifestDoc from the XML.
+ SmartPtrCEventManifestDoc RESPONSEXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ManifestCollectionXml_h_
+#define ManifestCollectionXml_h_
+
+
+#include "Doc/ResponseDoc/CManifestCollectionDoc.h"
+
+#include "Doc/DocXml/ResponseXml/ResponseXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ManifestCollection class to/from XML
+ namespace ManifestCollectionXml {
+
+ /// Adds the ManifestCollectionDoc into the XML.
+ void RESPONSEXML_LINKAGE add(
+ const SmartPtrCManifestCollectionDoc manifestCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ManifestCollectionDoc from the XML.
+ SmartPtrCManifestCollectionDoc RESPONSEXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ManifestXml_h_
+#define ManifestXml_h_
+
+
+#include "Doc/ResponseDoc/CManifestDoc.h"
+
+#include "Doc/DocXml/ResponseXml/ResponseXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the Manifest class to/from XML
+ namespace ManifestXml {
+
+ /// Adds the ManifestDoc into the XML.
+ void RESPONSEXML_LINKAGE add(
+ const SmartPtrCManifestDoc manifestDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ManifestDoc from the XML.
+ SmartPtrCManifestDoc RESPONSEXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderEventResponseXml_h_
+#define ProviderEventResponseXml_h_
+
+
+#include "Doc/ResponseDoc/CProviderEventResponseDoc.h"
+
+#include "Doc/DocXml/ResponseXml/ResponseXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ProviderEventResponse class to/from XML
+ namespace ProviderEventResponseXml {
+
+ /// Adds the ProviderEventResponseDoc into the XML.
+ void RESPONSEXML_LINKAGE add(
+ const SmartPtrCProviderEventResponseDoc providerEventResponseDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ProviderEventResponseDoc from the XML.
+ SmartPtrCProviderEventResponseDoc RESPONSEXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ProviderResponseXml_h_
+#define ProviderResponseXml_h_
+
+
+#include "Doc/ResponseDoc/CProviderResponseDoc.h"
+
+#include "Doc/DocXml/ResponseXml/ResponseXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ProviderResponse class to/from XML
+ namespace ProviderResponseXml {
+
+ /// Adds the ProviderResponseDoc into the XML.
+ void RESPONSEXML_LINKAGE add(
+ const SmartPtrCProviderResponseDoc providerResponseDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ProviderResponseDoc from the XML.
+ SmartPtrCProviderResponseDoc RESPONSEXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ResponseHeaderXml_h_
+#define ResponseHeaderXml_h_
+
+
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
+
+#include "Doc/DocXml/ResponseXml/ResponseXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ResponseHeader class to/from XML
+ namespace ResponseHeaderXml {
+
+ /// Adds the ResponseHeaderDoc into the XML.
+ void RESPONSEXML_LINKAGE add(
+ const SmartPtrCResponseHeaderDoc responseHeaderDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ResponseHeaderDoc from the XML.
+ SmartPtrCResponseHeaderDoc RESPONSEXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ResponseXml_h_
+#define ResponseXml_h_
+
+
+#include "Doc/ResponseDoc/CResponseDoc.h"
+
+#include "Doc/DocXml/ResponseXml/ResponseXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the Response class to/from XML
+ namespace ResponseXml {
+
+ /// Adds the ResponseDoc into the XML.
+ void RESPONSEXML_LINKAGE add(
+ const SmartPtrCResponseDoc responseDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ResponseDoc from the XML.
+ SmartPtrCResponseDoc RESPONSEXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ResponseXml_Link_h_
+#define ResponseXml_Link_h_
+
+#ifndef RESPONSEXML_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define RESPONSEXML_LINKAGE __declspec(dllexport)
+ #else
+ #define RESPONSEXML_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define RESPONSEXML_LINKAGE
+ #endif
+#endif
+
+
+#endif /* ResponseXml_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ResponseXmlRoots_h_
+#define ResponseXmlRoots_h_
+
+
+#include "Doc/ResponseDoc/CErrorResponseDoc.h"
+
+#include "Doc/DocXml/ResponseXml/ResponseXmlLink.h"
+#include "Doc/ResponseDoc/CProviderEventResponseDoc.h"
+#include "Doc/ResponseDoc/CProviderResponseDoc.h"
+#include "Doc/ResponseDoc/CResponseDoc.h"
+
+namespace Caf {
+
+ namespace XmlRoots {
+
+ /// Saves the ErrorResponseDoc to a string.
+ std::string RESPONSEXML_LINKAGE saveErrorResponseToString(
+ const SmartPtrCErrorResponseDoc errorResponseDoc);
+
+ /// Parses the ErrorResponseDoc from the string.
+ SmartPtrCErrorResponseDoc RESPONSEXML_LINKAGE parseErrorResponseFromString(
+ const std::string xml);
+
+ /// Saves the ErrorResponseDoc to a file.
+ void RESPONSEXML_LINKAGE saveErrorResponseToFile(
+ const SmartPtrCErrorResponseDoc errorResponseDoc,
+ const std::string filePath);
+
+ /// Parses the ErrorResponseDoc from the file.
+ SmartPtrCErrorResponseDoc RESPONSEXML_LINKAGE parseErrorResponseFromFile(
+ const std::string filePath);
+
+ /// Saves the ProviderResponseDoc to a string.
+ std::string RESPONSEXML_LINKAGE saveProviderResponseToString(
+ const SmartPtrCProviderResponseDoc providerResponseDoc);
+
+ /// Parses the ErrorResponseDoc from the string.
+ SmartPtrCProviderResponseDoc RESPONSEXML_LINKAGE parseProviderResponseFromString(
+ const std::string xml);
+
+ /// Saves the ProviderResponseDoc to a file.
+ void RESPONSEXML_LINKAGE saveProviderResponseToFile(
+ const SmartPtrCProviderResponseDoc providerResponseDoc,
+ const std::string filePath);
+
+ /// Parses the ErrorResponseDoc from the file.
+ SmartPtrCProviderResponseDoc RESPONSEXML_LINKAGE parseProviderResponseFromFile(
+ const std::string filePath);
+
+ /// Saves the ResponseDoc to a string.
+ std::string RESPONSEXML_LINKAGE saveResponseToString(
+ const SmartPtrCResponseDoc responseDoc);
+
+ /// Parses the ErrorResponseDoc from the string.
+ SmartPtrCResponseDoc RESPONSEXML_LINKAGE parseResponseFromString(
+ const std::string xml);
+
+ /// Saves the ResponseDoc to a file.
+ void RESPONSEXML_LINKAGE saveResponseToFile(
+ const SmartPtrCResponseDoc responseDoc,
+ const std::string filePath);
+
+ /// Parses the ErrorResponseDoc from the file.
+ SmartPtrCResponseDoc RESPONSEXML_LINKAGE parseResponseFromFile(
+ const std::string filePath);
+
+ /// Saves the ProviderEventResponseDoc to a string.
+ std::string RESPONSEXML_LINKAGE saveProviderEventResponseToString(
+ const SmartPtrCProviderEventResponseDoc providerEventResponseDoc);
+
+ /// Parses the ErrorResponseDoc from the string.
+ SmartPtrCProviderEventResponseDoc RESPONSEXML_LINKAGE parseProviderEventResponseFromString(
+ const std::string xml);
+
+ /// Saves the ProviderEventResponseDoc to a file.
+ void RESPONSEXML_LINKAGE saveProviderEventResponseToFile(
+ const SmartPtrCProviderEventResponseDoc providerEventResponseDoc,
+ const std::string filePath);
+
+ /// Parses the ErrorResponseDoc from the file.
+ SmartPtrCProviderEventResponseDoc RESPONSEXML_LINKAGE parseProviderEventResponseFromFile(
+ const std::string filePath);
+ }
+}
+
+#endif /* ResponseXmlRoots_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ActionClassInstanceCollectionXml_h_
+#define ActionClassInstanceCollectionXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CActionClassInstanceCollectionDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ActionClassInstanceCollection class to/from XML
+ namespace ActionClassInstanceCollectionXml {
+
+ /// Adds the ActionClassInstanceCollectionDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCActionClassInstanceCollectionDoc actionClassInstanceCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ActionClassInstanceCollectionDoc from the XML.
+ SmartPtrCActionClassInstanceCollectionDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ActionClassInstanceXml_h_
+#define ActionClassInstanceXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CActionClassInstanceDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ActionClassInstance class to/from XML
+ namespace ActionClassInstanceXml {
+
+ /// Adds the ActionClassInstanceDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCActionClassInstanceDoc actionClassInstanceDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ActionClassInstanceDoc from the XML.
+ SmartPtrCActionClassInstanceDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ActionClassXml_h_
+#define ActionClassXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ActionClass class to/from XML
+ namespace ActionClassXml {
+
+ /// Adds the ActionClassDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCActionClassDoc actionClassDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ActionClassDoc from the XML.
+ SmartPtrCActionClassDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ClassCardinalityXml_h_
+#define ClassCardinalityXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CClassCardinalityDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ClassCardinality class to/from XML
+ namespace ClassCardinalityXml {
+
+ /// Adds the ClassCardinalityDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCClassCardinalityDoc classCardinalityDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ClassCardinalityDoc from the XML.
+ SmartPtrCClassCardinalityDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ClassFieldXml_h_
+#define ClassFieldXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CClassFieldDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ClassField class to/from XML
+ namespace ClassFieldXml {
+
+ /// Adds the ClassFieldDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCClassFieldDoc classFieldDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ClassFieldDoc from the XML.
+ SmartPtrCClassFieldDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ClassIdentifierXml_h_
+#define ClassIdentifierXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CClassIdentifierDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ClassIdentifier class to/from XML
+ namespace ClassIdentifierXml {
+
+ /// Adds the ClassIdentifierDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCClassIdentifierDoc classIdentifierDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ClassIdentifierDoc from the XML.
+ SmartPtrCClassIdentifierDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ClassInstancePropertyXml_h_
+#define ClassInstancePropertyXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CClassInstancePropertyDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ClassInstanceProperty class to/from XML
+ namespace ClassInstancePropertyXml {
+
+ /// Adds the ClassInstancePropertyDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCClassInstancePropertyDoc classInstancePropertyDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ClassInstancePropertyDoc from the XML.
+ SmartPtrCClassInstancePropertyDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef ClassPropertyXml_h_
+#define ClassPropertyXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CClassPropertyDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the ClassProperty class to/from XML
+ namespace ClassPropertyXml {
+
+ /// Adds the ClassPropertyDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCClassPropertyDoc classPropertyDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the ClassPropertyDoc from the XML.
+ SmartPtrCClassPropertyDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef CmdlMetadataXml_h_
+#define CmdlMetadataXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CCmdlMetadataDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the CmdlMetadata class to/from XML
+ namespace CmdlMetadataXml {
+
+ /// Adds the CmdlMetadataDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCCmdlMetadataDoc cmdlMetadataDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the CmdlMetadataDoc from the XML.
+ SmartPtrCCmdlMetadataDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef CmdlUnionXml_h_
+#define CmdlUnionXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CCmdlUnionDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the CmdlUnion class to/from XML
+ namespace CmdlUnionXml {
+
+ /// Adds the CmdlUnionDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCCmdlUnionDoc cmdlUnionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the CmdlUnionDoc from the XML.
+ SmartPtrCCmdlUnionDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef CollectMethodXml_h_
+#define CollectMethodXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CCollectMethodDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the CollectMethod class to/from XML
+ namespace CollectMethodXml {
+
+ /// Adds the CollectMethodDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCCollectMethodDoc collectMethodDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the CollectMethodDoc from the XML.
+ SmartPtrCCollectMethodDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef DataClassInstanceCollectionXml_h_
+#define DataClassInstanceCollectionXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CDataClassInstanceCollectionDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the DataClassInstanceCollection class to/from XML
+ namespace DataClassInstanceCollectionXml {
+
+ /// Adds the DataClassInstanceCollectionDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCDataClassInstanceCollectionDoc dataClassInstanceCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the DataClassInstanceCollectionDoc from the XML.
+ SmartPtrCDataClassInstanceCollectionDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef DataClassInstanceXml_h_
+#define DataClassInstanceXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the DataClassInstance class to/from XML
+ namespace DataClassInstanceXml {
+
+ /// Adds the DataClassInstanceDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCDataClassInstanceDoc dataClassInstanceDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the DataClassInstanceDoc from the XML.
+ SmartPtrCDataClassInstanceDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef DataClassPropertyXml_h_
+#define DataClassPropertyXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CDataClassPropertyDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the DataClassProperty class to/from XML
+ namespace DataClassPropertyXml {
+
+ /// Adds the DataClassPropertyDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCDataClassPropertyDoc dataClassPropertyDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the DataClassPropertyDoc from the XML.
+ SmartPtrCDataClassPropertyDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef DataClassSubInstanceXml_h_
+#define DataClassSubInstanceXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CDataClassSubInstanceDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the DataClassSubInstance class to/from XML
+ namespace DataClassSubInstanceXml {
+
+ /// Adds the DataClassSubInstanceDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCDataClassSubInstanceDoc dataClassSubInstanceDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the DataClassSubInstanceDoc from the XML.
+ SmartPtrCDataClassSubInstanceDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef DataClassXml_h_
+#define DataClassXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CDataClassDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the DataClass class to/from XML
+ namespace DataClassXml {
+
+ /// Adds the DataClassDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCDataClassDoc dataClassDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the DataClassDoc from the XML.
+ SmartPtrCDataClassDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef InstanceOperationCollectionXml_h_
+#define InstanceOperationCollectionXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CInstanceOperationCollectionDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the InstanceOperationCollection class to/from XML
+ namespace InstanceOperationCollectionXml {
+
+ /// Adds the InstanceOperationCollectionDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCInstanceOperationCollectionDoc instanceOperationCollectionDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the InstanceOperationCollectionDoc from the XML.
+ SmartPtrCInstanceOperationCollectionDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef InstanceOperationXml_h_
+#define InstanceOperationXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CInstanceOperationDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the InstanceOperation class to/from XML
+ namespace InstanceOperationXml {
+
+ /// Adds the InstanceOperationDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCInstanceOperationDoc instanceOperationDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the InstanceOperationDoc from the XML.
+ SmartPtrCInstanceOperationDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef InstanceParameterXml_h_
+#define InstanceParameterXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CInstanceParameterDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the InstanceParameter class to/from XML
+ namespace InstanceParameterXml {
+
+ /// Adds the InstanceParameterDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCInstanceParameterDoc instanceParameterDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the InstanceParameterDoc from the XML.
+ SmartPtrCInstanceParameterDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef JoinTypeXml_h_
+#define JoinTypeXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CJoinTypeDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the JoinType class to/from XML
+ namespace JoinTypeXml {
+
+ /// Adds the JoinTypeDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCJoinTypeDoc joinTypeDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the JoinTypeDoc from the XML.
+ SmartPtrCJoinTypeDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef LogicalRelationshipXml_h_
+#define LogicalRelationshipXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CLogicalRelationshipDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the LogicalRelationship class to/from XML
+ namespace LogicalRelationshipXml {
+
+ /// Adds the LogicalRelationshipDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCLogicalRelationshipDoc logicalRelationshipDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the LogicalRelationshipDoc from the XML.
+ SmartPtrCLogicalRelationshipDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MethodParameterXml_h_
+#define MethodParameterXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CMethodParameterDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the MethodParameter class to/from XML
+ namespace MethodParameterXml {
+
+ /// Adds the MethodParameterDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCMethodParameterDoc methodParameterDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the MethodParameterDoc from the XML.
+ SmartPtrCMethodParameterDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef MethodXml_h_
+#define MethodXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CMethodDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the Method class to/from XML
+ namespace MethodXml {
+
+ /// Adds the MethodDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCMethodDoc methodDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the MethodDoc from the XML.
+ SmartPtrCMethodDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef PhysicalRelationshipXml_h_
+#define PhysicalRelationshipXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CPhysicalRelationshipDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the PhysicalRelationship class to/from XML
+ namespace PhysicalRelationshipXml {
+
+ /// Adds the PhysicalRelationshipDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCPhysicalRelationshipDoc physicalRelationshipDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the PhysicalRelationshipDoc from the XML.
+ SmartPtrCPhysicalRelationshipDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef RelationshipXml_h_
+#define RelationshipXml_h_
+
+
+#include "Doc/SchemaTypesDoc/CRelationshipDoc.h"
+
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+ /// Streams the Relationship class to/from XML
+ namespace RelationshipXml {
+
+ /// Adds the RelationshipDoc into the XML.
+ void SCHEMATYPESXML_LINKAGE add(
+ const SmartPtrCRelationshipDoc relationshipDoc,
+ const SmartPtrCXmlElement thisXml);
+
+ /// Parses the RelationshipDoc from the XML.
+ SmartPtrCRelationshipDoc SCHEMATYPESXML_LINKAGE parse(
+ const SmartPtrCXmlElement thisXml);
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ * This code was generated by the script "build/dev/codeGen/genCppXml". Please
+ * speak to Brian W. before modifying it by hand.
+ *
+ */
+
+#ifndef SchemaTypesXml_Link_h_
+#define SchemaTypesXml_Link_h_
+
+#ifndef SCHEMATYPESXML_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define SCHEMATYPESXML_LINKAGE __declspec(dllexport)
+ #else
+ #define SCHEMATYPESXML_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define SCHEMATYPESXML_LINKAGE
+ #endif
+#endif
+
+
+#endif /* SchemaTypesXml_Link_h_ */
#ifndef CMgmtRequestDoc_h_
#define CMgmtRequestDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtBatchDoc.h"
+
namespace Caf {
/// A simple container for objects of type MgmtRequest
#endif
#endif
-#include "Doc/MgmtRequestDoc/MgmtRequestDocInc.h"
#endif /* MgmtRequestDoc_Link_h_ */
#ifndef CMgmtBatchDoc_h_
#define CMgmtBatchDoc_h_
+
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectSchemaDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type MgmtBatch
#ifndef CMgmtCollectInstancesCollectionDoc_h_
#define CMgmtCollectInstancesCollectionDoc_h_
+
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesDoc.h"
+
namespace Caf {
/// A simple container for objects of type MgmtCollectInstancesCollection
#ifndef CMgmtCollectInstancesDoc_h_
#define CMgmtCollectInstancesDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CClassSpecifierDoc.h"
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type MgmtCollectInstances
#ifndef CMgmtInvokeOperationCollectionDoc_h_
#define CMgmtInvokeOperationCollectionDoc_h_
+
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationDoc.h"
+
namespace Caf {
/// A simple container for objects of type MgmtInvokeOperationCollection
#ifndef CMgmtInvokeOperationDoc_h_
#define CMgmtInvokeOperationDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CClassSpecifierDoc.h"
+#include "Doc/CafCoreTypesDoc/COperationDoc.h"
+
namespace Caf {
/// A simple container for objects of type MgmtInvokeOperation
#endif
#endif
-#include "Doc/MgmtTypesDoc/MgmtTypesDocInc.h"
#endif /* MgmtTypesDoc_Link_h_ */
#ifndef CMultiPmeMgmtBatchCollectionDoc_h_
#define CMultiPmeMgmtBatchCollectionDoc_h_
+
+#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtBatchDoc.h"
+
namespace Caf {
/// A simple container for objects of type MultiPmeMgmtBatchCollection
#ifndef CMultiPmeMgmtBatchDoc_h_
#define CMultiPmeMgmtBatchDoc_h_
+
+#include "Doc/MgmtTypesDoc/CMgmtBatchDoc.h"
+#include "Doc/MultiPmeMgmtRequestDoc/CPmeIdCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type MultiPmeMgmtBatch
#ifndef CMultiPmeMgmtRequestDoc_h_
#define CMultiPmeMgmtRequestDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtBatchCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type MultiPmeMgmtRequest
#endif
#endif
-#include "Doc/MultiPmeMgmtRequestDoc/MultiPmeMgmtRequestDocInc.h"
#endif /* MultiPmeMgmtRequestDoc_Link_h_ */
#ifndef CPayloadEnvelopeDoc_h_
#define CPayloadEnvelopeDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CPropertyCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CProtocolCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type PayloadEnvelope
#endif
#endif
-#include "Doc/PayloadEnvelopeDoc/PayloadEnvelopeDocInc.h"
#endif /* PayloadEnvelopeDoc_Link_h_ */
#ifndef CPersistenceDoc_h_
#define CPersistenceDoc_h_
+
+#include "Doc/PersistenceDoc/CLocalSecurityDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolCollectionDoc.h"
+#include "Doc/PersistenceDoc/CRemoteSecurityCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type PersistenceEnvelope
#ifndef CPersistenceProtocolCollectionDoc_h_
#define CPersistenceProtocolCollectionDoc_h_
+
+#include "Doc/PersistenceDoc/CPersistenceProtocolDoc.h"
+
namespace Caf {
/// A simple container for objects of type PersistenceProtocolCollection
#ifndef CPersistenceProtocolDoc_h_
#define CPersistenceProtocolDoc_h_
+
+#include "Doc/PersistenceDoc/CCertCollectionDoc.h"
+#include "Doc/PersistenceDoc/CCertPathCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type CPersistenceProtocolDoc
#ifndef CRemoteSecurityCollectionDoc_h_
#define CRemoteSecurityCollectionDoc_h_
+
+#include "Doc/PersistenceDoc/CRemoteSecurityDoc.h"
+
namespace Caf {
/// A simple container for objects of type RemoteSecurityCollection
#ifndef CRemoteSecurityDoc_h_
#define CRemoteSecurityDoc_h_
+
+#include "Doc/PersistenceDoc/CCertCollectionDoc.h"
+#include "Doc/PersistenceDoc/CCertPathCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type CRemoteSecurityDoc
#endif
#endif
-#include "Doc/PersistenceDoc/PersistenceDocInc.h"
#endif /* PersistenceDoc_Link_h_ */
#ifndef CClassCollectionDoc_h_
#define CClassCollectionDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CFullyQualifiedClassGroupDoc.h"
+
namespace Caf {
/// A simple container for objects of type ClassCollection
#ifndef CSchemaSummaryDoc_h_
#define CSchemaSummaryDoc_h_
+
+#include "Doc/ProviderInfraDoc/CClassCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type SchemaSummary
#endif
#endif
-#include "Doc/ProviderInfraDoc/ProviderInfraDocInc.h"
#endif /* ProviderInfraDoc_Link_h_ */
#ifndef CProviderBatchDoc_h_
#define CProviderBatchDoc_h_
+
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type ProviderBatch
#ifndef CProviderCollectInstancesCollectionDoc_h_
#define CProviderCollectInstancesCollectionDoc_h_
+
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesDoc.h"
+
namespace Caf {
/// A simple container for objects of type ProviderCollectInstancesCollection
#ifndef CProviderCollectInstancesDoc_h_
#define CProviderCollectInstancesDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type ProviderCollectInstances
#ifndef CProviderCollectSchemaRequestDoc_h_
#define CProviderCollectSchemaRequestDoc_h_
+
+#include "Doc/ProviderRequestDoc/CProviderRequestHeaderDoc.h"
+
namespace Caf {
/// A simple container for objects of type ProviderCollectSchemaRequest
#ifndef CProviderInvokeOperationCollectionDoc_h_
#define CProviderInvokeOperationCollectionDoc_h_
+
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationDoc.h"
+
namespace Caf {
/// A simple container for objects of type ProviderInvokeOperationCollection
#ifndef CProviderInvokeOperationDoc_h_
#define CProviderInvokeOperationDoc_h_
+
+#include "Doc/CafCoreTypesDoc/COperationDoc.h"
+
namespace Caf {
/// A simple container for objects of type ProviderInvokeOperation
#ifndef CProviderRequestConfigDoc_h_
#define CProviderRequestConfigDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CLoggingLevelCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type ProviderRequestConfig
#ifndef CProviderRequestDoc_h_
#define CProviderRequestDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderBatchDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestHeaderDoc.h"
+
namespace Caf {
/// A simple container for objects of type ProviderRequest
#ifndef CProviderRequestHeaderDoc_h_
#define CProviderRequestHeaderDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CPropertyCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestConfigDoc.h"
+
namespace Caf {
/// A simple container for objects of type ProviderRequestHeader
#endif
#endif
-#include "Doc/ProviderRequestDoc/ProviderRequestDocInc.h"
#endif /* ProviderRequestDoc_Link_h_ */
#ifndef CCdifDoc_h_
#define CCdifDoc_h_
+
+#include "Doc/ProviderResultsDoc/CDefinitionObjectCollectionDoc.h"
+#include "Doc/ProviderResultsDoc/CRequestIdentifierDoc.h"
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+
namespace Caf {
/// A simple container for objects of type Cdif
#ifndef CRequestIdentifierDoc_h_
#define CRequestIdentifierDoc_h_
+
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+
namespace Caf {
/// Fields that allow client to determine which request resulted in this response document
#ifndef CSchemaDoc_h_
#define CSchemaDoc_h_
+
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassDoc.h"
+#include "Doc/SchemaTypesDoc/CLogicalRelationshipDoc.h"
+#include "Doc/SchemaTypesDoc/CPhysicalRelationshipDoc.h"
+
namespace Caf {
/// Set of elements describing the objects that can be generated by the provider
#endif
#endif
-#include "Doc/ProviderResultsDoc/ProviderResultsDocInc.h"
#endif /* ProviderResultsDoc_Link_h_ */
#ifndef CErrorResponseDoc_h_
#define CErrorResponseDoc_h_
+
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
+
namespace Caf {
/// A simple container for objects of type ErrorResponse
#ifndef CEventKeyCollectionDoc_h_
#define CEventKeyCollectionDoc_h_
+
+#include "Doc/ResponseDoc/CEventKeyDoc.h"
+
namespace Caf {
/// A simple container for objects of type EventKeyCollection
#ifndef CEventManifestDoc_h_
#define CEventManifestDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type EventManifest
#ifndef CManifestCollectionDoc_h_
#define CManifestCollectionDoc_h_
+
+#include "Doc/ResponseDoc/CManifestDoc.h"
+
namespace Caf {
/// A simple container for objects of type ManifestCollection
#ifndef CManifestDoc_h_
#define CManifestDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CAttachmentNameCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type Manifest
#ifndef CProviderEventResponseDoc_h_
#define CProviderEventResponseDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CStatisticsDoc.h"
+#include "Doc/ResponseDoc/CEventKeyCollectionDoc.h"
+#include "Doc/ResponseDoc/CEventManifestDoc.h"
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
+
namespace Caf {
/// A simple container for objects of type ProviderEventResponse
#ifndef CProviderResponseDoc_h_
#define CProviderResponseDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CStatisticsDoc.h"
+#include "Doc/ResponseDoc/CManifestDoc.h"
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
+
namespace Caf {
/// A simple container for objects of type ProviderResponse
#ifndef CResponseDoc_h_
#define CResponseDoc_h_
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CStatisticsDoc.h"
+#include "Doc/ResponseDoc/CManifestCollectionDoc.h"
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
+
namespace Caf {
/// A simple container for objects of type Response
#endif
#endif
-#include "Doc/ResponseDoc/ResponseDocInc.h"
#endif /* ResponseDoc_Link_h_ */
#ifndef CActionClassDoc_h_
#define CActionClassDoc_h_
+
+#include "Doc/SchemaTypesDoc/CCollectMethodDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodDoc.h"
+
namespace Caf {
/// Definition of an action class that may be generated by the provider
#ifndef CActionClassInstanceCollectionDoc_h_
#define CActionClassInstanceCollectionDoc_h_
+
+#include "Doc/SchemaTypesDoc/CActionClassInstanceDoc.h"
+
namespace Caf {
/// A simple container for objects of type ActionClassInstanceCollection
#ifndef CActionClassInstanceDoc_h_
#define CActionClassInstanceDoc_h_
+
+#include "Doc/SchemaTypesDoc/CInstanceOperationCollectionDoc.h"
+
namespace Caf {
/// A simple container for objects of type ActionClassInstance
#ifndef CClassInstancePropertyDoc_h_
#define CClassInstancePropertyDoc_h_
+
+#include "Doc/SchemaTypesDoc/CClassIdentifierDoc.h"
+
namespace Caf {
/// Definition of an attribute (field) of a class
#ifndef CClassPropertyDoc_h_
#define CClassPropertyDoc_h_
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+
namespace Caf {
/// Definition of an attribute (field) of a class
#ifndef CCollectMethodDoc_h_
#define CCollectMethodDoc_h_
+
+#include "Doc/SchemaTypesDoc/CClassIdentifierDoc.h"
+#include "Doc/SchemaTypesDoc/CInstanceParameterDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodParameterDoc.h"
+
namespace Caf {
/// Definition of a collection method on a class
#ifndef CDataClassDoc_h_
#define CDataClassDoc_h_
+
+#include "Doc/SchemaTypesDoc/CClassInstancePropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CClassPropertyDoc.h"
+
namespace Caf {
/// Definition of a data class that may be generated by the provider
#ifndef CDataClassInstanceCollectionDoc_h_
#define CDataClassInstanceCollectionDoc_h_
+
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+
namespace Caf {
/// A simple container for objects of type DataClassInstanceCollection
#ifndef CDataClassInstanceDoc_h_
#define CDataClassInstanceDoc_h_
+
+#include "Doc/SchemaTypesDoc/CCmdlMetadataDoc.h"
+#include "Doc/SchemaTypesDoc/CCmdlUnionDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassPropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassSubInstanceDoc.h"
+
namespace Caf {
/// A simple container for objects of type DataClassInstance
#ifndef CDataClassPropertyDoc_h_
#define CDataClassPropertyDoc_h_
+
+#include "Doc/SchemaTypesDoc/CCmdlMetadataDoc.h"
+
namespace Caf {
/// A simple container for objects of type DataClassProperty
#ifndef CDataClassSubInstanceDoc_h_
#define CDataClassSubInstanceDoc_h_
+#include "Doc/SchemaTypesDoc/CCmdlMetadataDoc.h"
+#include "Doc/SchemaTypesDoc/CCmdlUnionDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassPropertyDoc.h"
+
namespace Caf {
+CAF_DECLARE_CLASS_AND_SMART_POINTER(CDataClassSubInstanceDoc);
+
/// A simple container for objects of type DataClassSubInstance
class SCHEMATYPESDOC_LINKAGE CDataClassSubInstanceDoc {
public:
#ifndef CInstanceOperationCollectionDoc_h_
#define CInstanceOperationCollectionDoc_h_
+
+#include "Doc/SchemaTypesDoc/CInstanceOperationDoc.h"
+
namespace Caf {
/// A simple container for objects of type InstanceOperationCollection
#ifndef CJoinTypeDoc_h_
#define CJoinTypeDoc_h_
+
+#include "Doc/SchemaTypesDoc/CClassFieldDoc.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+
namespace Caf {
/// A simple container for objects of type JoinType
#ifndef CLogicalRelationshipDoc_h_
#define CLogicalRelationshipDoc_h_
+
+#include "Doc/SchemaTypesDoc/CClassCardinalityDoc.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+#include "Doc/SchemaTypesDoc/CJoinTypeDoc.h"
+
namespace Caf {
/// Definition of a relationship between classes that can be described by identifying the fields on the classes that uniquely identify the relationship
#ifndef CMethodDoc_h_
#define CMethodDoc_h_
+
+#include "Doc/SchemaTypesDoc/CClassIdentifierDoc.h"
+#include "Doc/SchemaTypesDoc/CInstanceParameterDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodParameterDoc.h"
+
namespace Caf {
/// Definition of a method on a class
#ifndef CMethodParameterDoc_h_
#define CMethodParameterDoc_h_
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+
namespace Caf {
/// A parameter containing a simple type used by a method to control the outcome
#ifndef CPhysicalRelationshipDoc_h_
#define CPhysicalRelationshipDoc_h_
+
+#include "Doc/SchemaTypesDoc/CClassCardinalityDoc.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+
namespace Caf {
/// Describes a relationship between dataclass where the key information from data class instances comprising the relationship are listed in an instance of this class
#ifndef CRelationshipDoc_h_
#define CRelationshipDoc_h_
+
+#include "Doc/SchemaTypesDoc/CClassCardinalityDoc.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+
namespace Caf {
/// Definition of a relationship between data classes
#endif
#endif
-#include "Doc/SchemaTypesDoc/SchemaTypesDocInc.h"
#endif /* SchemaTypesDoc_Link_h_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: April 6, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef SCHEMATYPESDOCTYPES_H_
+#define SCHEMATYPESDOCTYPES_H_
+
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+
+namespace Caf {
+ typedef enum {
+ OPERATOR_NONE,
+ OPERATOR_EQUAL
+ } OPERATOR_TYPE;
+
+ typedef enum {
+ ARITY_NONE,
+ ARITY_UNSIGNED_BYTE = 2
+ } ARITY_TYPE;
+
+ typedef enum {
+ VALIDATOR_NONE,
+ VALIDATOR_ENUM,
+ VALIDATOR_RANGE,
+ VALIDATOR_REGEX,
+ VALIDATOR_CUSTOM
+ } VALIDATOR_TYPE;
+}
+
+#endif /* SCHEMATYPESDOCTYPES_H_ */
#include <CommonDefines.h>
#include <DocContracts.h>
-#include "../src/Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
-#include "../src/Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
-#include "../src/Doc/DocXml/DiagTypesXml/DiagTypesXmlLink.h"
-#include "../src/Doc/DocXml/DiagRequestXml/DiagRequestXmlLink.h"
-#include "../src/Doc/DocXml/MgmtTypesXml/MgmtTypesXmlLink.h"
-#include "../src/Doc/DocXml/MgmtRequestXml/MgmtRequestXmlLink.h"
-#include "../src/Doc/DocXml/PayloadEnvelopeXml/PayloadEnvelopeXmlLink.h"
-#include "../src/Doc/DocXml/PersistenceXml/PersistenceXmlLink.h"
-#include "../src/Doc/DocXml/ProviderInfraXml/ProviderInfraXmlLink.h"
-#include "../src/Doc/DocXml/ProviderRequestXml/ProviderRequestXmlLink.h"
-#include "../src/Doc/DocXml/ProviderResultsXml/ProviderResultsXmlLink.h"
-#include "../src/Doc/DocXml/ResponseXml/ResponseXmlLink.h"
-#include "../src/Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlLink.h"
-#include "../src/Doc/DocXml/MultiPmeMgmtRequestXml/MultiPmeMgmtRequestXmlLink.h"
+#include "Doc/DocXml/CafCoreTypesXml/CafCoreTypesXmlLink.h"
+#include "Doc/DocXml/SchemaTypesXml/SchemaTypesXmlLink.h"
+#include "Doc/DocXml/DiagTypesXml/DiagTypesXmlLink.h"
+#include "Doc/DocXml/DiagRequestXml/DiagRequestXmlLink.h"
+#include "Doc/DocXml/MgmtTypesXml/MgmtTypesXmlLink.h"
+#include "Doc/DocXml/MgmtRequestXml/MgmtRequestXmlLink.h"
+#include "Doc/DocXml/PayloadEnvelopeXml/PayloadEnvelopeXmlLink.h"
+#include "Doc/DocXml/PersistenceXml/PersistenceXmlLink.h"
+#include "Doc/DocXml/ProviderInfraXml/ProviderInfraXmlLink.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXmlLink.h"
+#include "Doc/DocXml/ProviderResultsXml/ProviderResultsXmlLink.h"
+#include "Doc/DocXml/ResponseXml/ResponseXmlLink.h"
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlLink.h"
+#include "Doc/DocXml/MgmtRequestXml/MgmtRequestXmlLink.h"
#endif /* COMMON_SYS_INC_DOCXML_H_ */
--- /dev/null
+/*
+ * Author: mdonahue
+ * Created: Jan 13, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CCAFEXCEPTION_H_
+#define CCAFEXCEPTION_H_
+
+
+#include "ICafObject.h"
+
+namespace Caf {
+
+class EXCEPTION_LINKAGE CCafException : public ICafObject {
+public:
+ CCafException();
+
+ CCafException(const std::string& exceptionClassName);
+
+ virtual ~CCafException();
+
+ virtual void throwSelf();
+
+ virtual void throwAddRefedSelf();
+
+ void AddRef();
+
+ void Release();
+
+ void QueryInterface(const IID&, void**);
+
+ void populate(
+ const std::string& message,
+ const HRESULT errorCode,
+ const std::string& className,
+ const std::string& funcName);
+
+ void populateVA(const HRESULT errorCode,
+ const std::string& className,
+ const std::string& funcName,
+ const char* format,
+ ...);
+
+ bool isPopulated() const;
+
+ std::string getExceptionClassName() const;
+
+ virtual std::string getMsg() const;
+
+ std::string getClassName() const;
+
+ std::string getFuncName() const;
+
+ HRESULT getError() const;
+
+ std::deque<std::string>* getBacktrace() const;
+
+ virtual std::string getFullMsg() const;
+
+private:
+ gint _refCnt;
+ bool _isPopulated;
+
+protected:
+ std::string _exceptionClassName;
+ HRESULT _errorCode;
+ std::string _message;
+ std::string _className;
+ std::string _funcName;
+ std::deque<std::string>* _backtrace;
+
+ CCafException(const CCafException&);
+ CCafException& operator=(const CCafException&);
+};
+CAF_DECLARE_SMART_POINTER(CCafException);
+
+}
+
+#endif /* CCAFEXCEPTION_H_ */
#ifndef _FxContracts_IBean_h_
#define _FxContracts_IBean_h_
+
+#include "ICafObject.h"
+
namespace Caf {
CAF_FORWARD_DECLARE_SMART_INTERFACE(IBean);
--- /dev/null
+/*
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef _ICafObject_H_
+#define _ICafObject_H_
+
+/**
+ * @brief
+ * The base interface all classes must support in order to support lifetime management
+ * and interface retrieval.
+ * <p>
+ * Object lifetime is managed through the AddRef() and Release() methods. Pointers
+ * to supported interfaces on the object - in the form of TCafSmartPtr - are
+ * retrieved using the QueryInterface() method.
+ * <p>
+ * Interfaces and classes are candidates for QueryInterface() if they declare
+ * a unique identifier for the interface or class. The identifier is a
+ * UUID and is declared using the CAF_DECL_UUID macro.
+ * <p>
+ * Example interface declaration:
+ * <pre>
+ * <code>
+ * struct __declspcec(novtable) IMyInterface {
+ *
+ * CAF_DECL_UUID("6AECA0A4-C6B1-4A43-9769-C5A8F56F0B52")
+ *
+ * virtual void Foo() = 0;
+ * };
+ * </code>
+ * </pre>
+ */
+struct __declspec(novtable) ICafObject {
+ CAF_DECL_UUID("d285ff70-2314-11e0-ac64-0800200c9a66")
+
+ /** @brief Increment the object's reference count */
+ virtual void AddRef() = 0;
+
+ /**
+ * @brief Decrement the object's reference count
+ * <p>
+ * The object will be destroyed when the count reaches zero.
+ */
+ virtual void Release() = 0;
+
+ /**
+ * @brief Retrieve an interface on the object
+ * @param IID the interface's UUID
+ * @param ppv the address into which the retrieve interface's pointer
+ * will be stored
+ */
+ virtual void QueryInterface(const IID&, void** ppv) = 0;
+};
+
+#endif
#ifndef _FxContracts_IVARIANT_H_
#define _FxContracts_IVARIANT_H_
+
+#include "ICafObject.h"
+
namespace Caf {
struct __declspec(novtable) IVariant : public ICafObject {
CAF_DECL_UUID("05AC7CB8-BBD4-4B3B-AB80-29002DD73747")
#include <CommonDefines.h>
// Dependencies
-#include "Integration/Dependencies/CPollerMetadata.h"
// Interfaces
-#include "Integration/IIntMessage.h"
#include "Integration/IThrowable.h"
-#include "Integration/IErrorHandler.h"
-#include "Integration/IErrorProcessor.h"
-#include "Integration/IRunnable.h"
-#include "Integration/ITaskExecutor.h"
-#include "Integration/IDocument.h"
-#include "Integration/IIntegrationObject.h"
-#include "Integration/ILifecycle.h"
-#include "Integration/IMessageChannel.h"
-#include "Integration/IMessageHandler.h"
-#include "Integration/IMessageProcessor.h"
-#include "Integration/IMessageSplitter.h"
-#include "Integration/IMessageDispatcher.h"
-#include "Integration/IMessageProducer.h"
-#include "Integration/IMessageRouter.h"
-#include "Integration/ITransformer.h"
-#include "Integration/IPollableChannel.h"
-#include "Integration/ISubscribableChannel.h"
-#include "Integration/IChannelResolver.h"
-#include "Integration/IChannelInterceptor.h"
-#include "Integration/IChannelInterceptorInstance.h"
-#include "Integration/IChannelInterceptorSupport.h"
-#include "Integration/IIntegrationComponentInstance.h"
-#include "Integration/IIntegrationComponent.h"
-#include "Integration/IIntegrationAppContext.h"
-#include "Integration/IIntegrationAppContextAware.h"
-#include "Integration/IExpressionInvoker.h"
-#include "Integration/IPhased.h"
-#include "Integration/ISmartLifecycle.h"
-#include "../src/Integration/Caf/IntegrationCafLink.h"
-#include "../src/Integration/Core/IntegrationCoreLink.h"
+#include "Integration/Caf/IntegrationCafLink.h"
+#include "Integration/Core/IntegrationCoreLink.h"
#endif /* COMMON_SYS_INC_INTEGRATION_H_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Jul 2009
+ *
+ * Copyright (c) 2009-2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CBeanPropertiesHelper_h_
+#define CBeanPropertiesHelper_h_
+
+namespace Caf {
+
+CAF_DECLARE_CLASS_AND_SMART_POINTER(CBeanPropertiesHelper);
+
+class INTEGRATIONCAF_LINKAGE CBeanPropertiesHelper {
+public:
+ static SmartPtrCBeanPropertiesHelper create(
+ const IBean::Cprops& properties);
+
+public:
+ CBeanPropertiesHelper();
+ virtual ~CBeanPropertiesHelper();
+
+public:
+ void initialize(
+ const IBean::Cprops& properties);
+
+public:
+ std::string getRequiredString(
+ const std::string& key) const;
+
+ std::string getOptionalString(
+ const std::string& key,
+ const std::string& defaultVal = std::string()) const;
+
+ bool getRequiredBool(
+ const std::string& key) const;
+
+ bool getOptionalBool(
+ const std::string& key,
+ const bool defaultVal = false) const;
+
+private:
+ bool m_isInitialized;
+ IBean::Cprops _properties;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CBeanPropertiesHelper);
+};
+
+}
+
+#endif // #ifndef CBeanPropertiesHelper_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Jul 2009
+ *
+ * Copyright (c) 2009-2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CCafMessageCreator_h_
+#define CCafMessageCreator_h_
+
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/CafCoreTypesDoc/CProtocolCollectionDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallRequestDoc.h"
+#include "Doc/DiagRequestDoc/CDiagRequestDoc.h"
+#include "Doc/MgmtRequestDoc/CMgmtRequestDoc.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Doc/ProviderInfraDoc/CProviderRegDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectSchemaRequestDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+#include "Doc/ResponseDoc/CErrorResponseDoc.h"
+#include "Doc/ResponseDoc/CResponseDoc.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+
+namespace Caf {
+
+CAF_DECLARE_CLASS_AND_SMART_POINTER(CCafMessageCreator);
+
+class INTEGRATIONCAF_LINKAGE CCafMessageCreator {
+public:
+ static SmartPtrIIntMessage createPayloadEnvelope(
+ const SmartPtrCResponseDoc& response,
+ const std::string& relFilename,
+ const IIntMessage::SmartPtrCHeaders& headers = IIntMessage::SmartPtrCHeaders());
+
+ static SmartPtrIIntMessage createPayloadEnvelope(
+ const SmartPtrCErrorResponseDoc& errorResponse,
+ const std::string& relFilename,
+ const IIntMessage::SmartPtrCHeaders& headers = IIntMessage::SmartPtrCHeaders());
+
+ static SmartPtrIIntMessage createPayloadEnvelope(
+ const SmartPtrCMgmtRequestDoc& mgmtRequest,
+ const IIntMessage::SmartPtrCHeaders& headers = IIntMessage::SmartPtrCHeaders());
+
+ static SmartPtrIIntMessage createPayloadEnvelope(
+ const SmartPtrCPayloadEnvelopeDoc& payloadEnvelope,
+ const std::deque<SmartPtrCAttachmentDoc>& attachmentCollection,
+ const IIntMessage::SmartPtrCHeaders& newHeaders = IIntMessage::SmartPtrCHeaders(),
+ const IIntMessage::SmartPtrCHeaders& origHeaders = IIntMessage::SmartPtrCHeaders());
+
+public:
+ static SmartPtrIIntMessage createFromProviderResponse(
+ const SmartPtrCDynamicByteArray& providerResponse,
+ const std::string& relFilename,
+ const IIntMessage::SmartPtrCHeaders& headers = IIntMessage::SmartPtrCHeaders());
+
+public:
+ static SmartPtrIIntMessage create(
+ const SmartPtrCDynamicByteArray payload,
+ const std::deque<SmartPtrCAttachmentDoc>& attachmentCollection,
+ const IIntMessage::SmartPtrCHeaders& headers = IIntMessage::SmartPtrCHeaders());
+
+public:
+ static SmartPtrIIntMessage create(
+ const SmartPtrCMgmtRequestDoc& mgmtRequest,
+ const IIntMessage::SmartPtrCHeaders& headers = IIntMessage::SmartPtrCHeaders());
+
+ static SmartPtrIIntMessage create(
+ const SmartPtrCDiagRequestDoc& diagRequest,
+ const IIntMessage::SmartPtrCHeaders& headers = IIntMessage::SmartPtrCHeaders());
+
+ static SmartPtrIIntMessage create(
+ const SmartPtrCInstallRequestDoc& installRequest,
+ const IIntMessage::SmartPtrCHeaders& headers = IIntMessage::SmartPtrCHeaders());
+
+ static SmartPtrIIntMessage create(
+ const SmartPtrCProviderRegDoc& providerReg,
+ const IIntMessage::SmartPtrCHeaders& headers = IIntMessage::SmartPtrCHeaders());
+
+ static SmartPtrIIntMessage create(
+ const SmartPtrCProviderCollectSchemaRequestDoc& providerCollectSchemaRequest,
+ const std::string& relFilename,
+ const std::string& relDirectory,
+ const IIntMessage::SmartPtrCHeaders& headers = IIntMessage::SmartPtrCHeaders());
+
+ static SmartPtrIIntMessage create(
+ const SmartPtrCProviderRequestDoc& providerRequest,
+ const std::string& relFilename,
+ const std::string& relDirectory,
+ const std::string& providerUri,
+ const IIntMessage::SmartPtrCHeaders& headers = IIntMessage::SmartPtrCHeaders());
+
+private:
+ static SmartPtrIIntMessage createPayloadEnvelope(
+ const std::string& payloadType,
+ const std::string& payloadStr,
+ const UUID& clientId,
+ const UUID& requestId,
+ const std::string& pmeId,
+ const std::string& payloadVersion,
+ const IIntMessage::SmartPtrCHeaders& newHeaders = IIntMessage::SmartPtrCHeaders(),
+ const IIntMessage::SmartPtrCHeaders& origHeaders = IIntMessage::SmartPtrCHeaders(),
+ const SmartPtrCAttachmentCollectionDoc& attachmentCollection = SmartPtrCAttachmentCollectionDoc(),
+ const SmartPtrCProtocolCollectionDoc& protocolCollection = SmartPtrCProtocolCollectionDoc());
+
+private:
+ CAF_CM_DECLARE_NOCREATE(CCafMessageCreator);
+};
+
+}
+
+#endif // #ifndef CCafMessageCreator_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Jul 2009
+ *
+ * Copyright (c) 2009-2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CCafMessageHeaders_h_
+#define CCafMessageHeaders_h_
+
+
+#include "IVariant.h"
+#include "Integration/IIntMessage.h"
+
+namespace Caf {
+
+CAF_DECLARE_CLASS_AND_SMART_POINTER(CCafMessageHeaders);
+
+class INTEGRATIONCAF_LINKAGE CCafMessageHeaders {
+public:
+ static SmartPtrCCafMessageHeaders create(
+ const IIntMessage::SmartPtrCHeaders& headers);
+
+public:
+ CCafMessageHeaders();
+ virtual ~CCafMessageHeaders();
+
+public:
+ IIntMessage::SmartPtrCHeaders getHeaders() const;
+
+public:
+ std::string getPayloadType() const;
+
+ std::string getPayloadTypeOpt(
+ const std::string& defaultVal = std::string()) const;
+
+public:
+ std::string getVersion() const;
+
+ std::string getVersionOpt(
+ const std::string& defaultVal = "1.0") const;
+
+public:
+ UUID getClientId() const;
+ std::string getClientIdStr() const;
+
+ UUID getClientIdOpt(
+ const UUID defaultVal = CAFCOMMON_GUID_NULL) const;
+ std::string getClientIdStrOpt(
+ const std::string& defaultVal = std::string()) const;
+
+public:
+ UUID getRequestId() const;
+ std::string getRequestIdStr() const;
+
+ UUID getRequestIdOpt(
+ const UUID defaultVal = CAFCOMMON_GUID_NULL) const;
+ std::string getRequestIdStrOpt(
+ const std::string& defaultVal = std::string()) const;
+
+public:
+ std::string getPmeId() const;
+
+ std::string getPmeIdOpt(
+ const std::string& defaultVal = std::string()) const;
+
+public:
+ UUID getSessionId() const;
+ std::string getSessionIdStr() const;
+
+ UUID getSessionIdOpt(
+ const UUID defaultVal = CAFCOMMON_GUID_NULL) const;
+ std::string getSessionIdStrOpt(
+ const std::string& defaultVal = std::string()) const;
+
+public:
+ std::string getRelDirectory() const;
+
+ std::string getRelDirectoryOpt(
+ const std::string& defaultVal = std::string()) const;
+
+public:
+ std::string getRelFilename() const;
+
+ std::string getRelFilenameOpt(
+ const std::string& defaultVal) const;
+
+public:
+ std::string getProviderUri() const;
+
+ std::string getProviderUriOpt(
+ const std::string& defaultVal) const;
+
+public:
+ std::string getFlowDirection() const;
+
+ std::string getFlowDirectionOpt(
+ const std::string& defaultVal) const;
+
+public:
+ std::string getRequiredStr(
+ const std::string& key) const;
+
+ std::string getOptionalStr(
+ const std::string& key,
+ const std::string& defaultVal = std::string()) const;
+
+ bool getRequiredBool(
+ const std::string& key) const;
+
+ bool getOptionalBool(
+ const std::string& key,
+ const bool defaultVal = false) const;
+
+private:
+ void initialize(
+ const IIntMessage::SmartPtrCHeaders& headers);
+
+private:
+ SmartPtrIVariant findOptionalHeader(
+ const std::string& key) const;
+
+ SmartPtrIVariant findRequiredHeader(
+ const std::string& key) const;
+
+private:
+ bool _isInitialized;
+ IIntMessage::SmartPtrCHeaders _headers;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CCafMessageHeaders);
+};
+
+}
+
+#endif // #ifndef CCafMessageHeaders_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Jul 2009
+ *
+ * Copyright (c) 2009-2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CCafMessageHeadersWriter_h_
+#define CCafMessageHeadersWriter_h_
+
+
+#include "Integration/IIntMessage.h"
+
+namespace Caf {
+
+CAF_DECLARE_CLASS_AND_SMART_POINTER(CCafMessageHeadersWriter);
+
+class INTEGRATIONCAF_LINKAGE CCafMessageHeadersWriter {
+public:
+ static SmartPtrCCafMessageHeadersWriter create();
+
+public:
+ CCafMessageHeadersWriter();
+ virtual ~CCafMessageHeadersWriter();
+
+public:
+ IIntMessage::SmartPtrCHeaders getHeaders() const;
+
+public:
+ void setPayloadType(const std::string& payloadType);
+
+ void setVersion(const std::string& version);
+
+ void setPayloadVersion(const std::string& payloadVersion);
+
+ void setClientId(const UUID& clientId);
+
+ void setClientId(const std::string& clientIdStr);
+
+ void setRequestId(const UUID& requestId);
+
+ void setRequestId(const std::string& requestIdStr);
+
+ void setPmeId(const std::string& pmeId);
+
+ void setSessionId(const UUID& sessionId);
+
+ void setSessionId(const std::string& sessionId);
+
+ void setRelDirectory(const std::string& relDirectory);
+
+ void setRelFilename(const std::string& relFilename);
+
+ void setProviderUri(const std::string& providerUri);
+
+ void setIsThrowable(const bool& isThrowable);
+
+ void setIsMultiPart(const bool& isMultiPart);
+
+ void setProtocol(const std::string& protocol);
+
+ void setProtocolAddress(const std::string& protocolAddress);
+
+ void setFlowDirection(const std::string& flowDirection);
+
+public:
+ void insertString(
+ const std::string& key,
+ const std::string& value);
+
+ void insertBool(
+ const std::string& key,
+ const bool& value);
+
+private:
+ void initialize();
+
+private:
+ bool _isInitialized;
+ IIntMessage::SmartPtrCHeaders _headers;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CCafMessageHeadersWriter);
+};
+
+}
+
+#endif // #ifndef CCafMessageHeadersWriter_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Jul 2009
+ *
+ * Copyright (c) 2009-2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CCafMessagePayload_h_
+#define CCafMessagePayload_h_
+
+#include <DocContracts.h>
+
+#include "Integration/Caf/CCafMessagePayload.h"
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Doc/ResponseDoc/CEventKeyDoc.h"
+#include "Doc/ResponseDoc/CManifestDoc.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+CAF_DECLARE_CLASS_AND_SMART_POINTER(CCafMessagePayload);
+
+class INTEGRATIONCAF_LINKAGE CCafMessagePayload {
+public:
+ static SmartPtrCCafMessagePayload create(
+ const SmartPtrCDynamicByteArray& payload,
+ const std::string& payloadType = std::string());
+
+ static SmartPtrCCafMessagePayload createFromFile(
+ const std::string& payloadFile,
+ const std::string& payloadType = std::string());
+
+ static SmartPtrCCafMessagePayload createFromStr(
+ const std::string& payloadStr,
+ const std::string& payloadType = std::string());
+
+public:
+ static SmartPtrCDynamicByteArray createBufferFromStr(
+ const std::string& payloadStr);
+
+ static SmartPtrCDynamicByteArray createBufferFromFile(
+ const std::string& payloadFile);
+
+public:
+ static void saveToFile(
+ const SmartPtrCDynamicByteArray& payload,
+ const std::string& payloadPath);
+
+ static std::string saveToStr(
+ const SmartPtrCDynamicByteArray& payload);
+
+public:
+ CCafMessagePayload();
+ virtual ~CCafMessagePayload();
+
+public:
+ std::string getPayloadStr() const;
+
+ SmartPtrCDynamicByteArray getPayload() const;
+
+public:
+ std::string getVersion() const;
+
+public:
+ SmartPtrCRequestHeaderDoc getRequestHeader() const;
+
+ SmartPtrCManifestDoc getManifest() const;
+
+ std::deque<SmartPtrCEventKeyDoc> getEventKeyCollection() const;
+
+private:
+ void initialize(
+ const SmartPtrCDynamicByteArray& payload,
+ const std::string& payloadType = std::string(),
+ const std::string& encoding = "xml");
+
+private:
+ bool _isInitialized;
+
+ std::string _encoding;
+ SmartPtrCDynamicByteArray _payload;
+ std::string _payloadStr;
+ SmartPtrCXmlElement _payloadXml;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CCafMessagePayload);
+};
+
+}
+
+#endif // #ifndef CCafMessagePayload_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Jul 2009
+ *
+ * Copyright (c) 2009-2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CCafMessagePayloadParser_h_
+#define CCafMessagePayloadParser_h_
+
+
+#include "Doc/CafInstallRequestDoc/CInstallProviderJobDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallRequestDoc.h"
+#include "Doc/CafInstallRequestDoc/CUninstallProviderJobDoc.h"
+#include "Doc/MgmtRequestDoc/CMgmtRequestDoc.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Doc/ProviderInfraDoc/CProviderRegDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+CAF_DECLARE_CLASS_AND_SMART_POINTER(CCafMessagePayloadParser);
+
+class INTEGRATIONCAF_LINKAGE CCafMessagePayloadParser {
+public:
+ static SmartPtrCPayloadEnvelopeDoc getPayloadEnvelope(
+ const SmartPtrCDynamicByteArray& payload);
+
+ static SmartPtrCInstallProviderJobDoc getInstallProviderJob(
+ const SmartPtrCDynamicByteArray& payload);
+
+ static SmartPtrCUninstallProviderJobDoc getUninstallProviderJob(
+ const SmartPtrCDynamicByteArray& payload);
+
+ static SmartPtrCProviderRequestDoc getProviderRequest(
+ const SmartPtrCDynamicByteArray& payload);
+
+ static SmartPtrCProviderRegDoc getProviderReg(
+ const SmartPtrCDynamicByteArray& payload);
+
+ static SmartPtrCInstallRequestDoc getInstallRequest(
+ const SmartPtrCDynamicByteArray& payload);
+
+ static SmartPtrCMgmtRequestDoc getMgmtRequest(
+ const SmartPtrCDynamicByteArray& payload);
+
+private:
+ static SmartPtrCXmlElement bufferToXml(
+ const SmartPtrCDynamicByteArray& payload,
+ const std::string& payloadType = std::string());
+
+ static std::string bufferToStr(
+ const SmartPtrCDynamicByteArray& payload);
+
+private:
+ CAF_CM_DECLARE_NOCREATE(CCafMessagePayloadParser);
+};
+
+}
+
+#endif // #ifndef CCafMessagePayloadParser_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 20, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef INTEGRATIONCAFLINK_H_
+#define INTEGRATIONCAFLINK_H_
+
+#ifndef INTEGRATIONCAF_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define INTEGRATIONCAF_LINKAGE __declspec(dllexport)
+ #else
+ #define INTEGRATIONCAF_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define INTEGRATIONCAF_LINKAGE
+ #endif
+#endif
+
+#endif /* INTEGRATIONCAFLINK_H_ */
--- /dev/null
+/*
+ * Created on: Jan 26, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CABSTRACTMESSAGECHANNEL_H_
+#define CABSTRACTMESSAGECHANNEL_H_
+
+#include "Integration/IChannelInterceptorSupport.h"
+#include "Integration/IChannelInterceptor.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/Core/IntegrationCoreLink.h"
+
+namespace Caf {
+/**
+ * Base class for {@link IMessageChannel} implementations providing common
+ * properties and method implementations including {@link IChannelInterceptor interceptors}.
+ */
+class INTEGRATIONCORE_LINKAGE CAbstractMessageChannel :
+ public IMessageChannel,
+ public IChannelInterceptorSupport {
+public:
+ CAbstractMessageChannel();
+ virtual ~CAbstractMessageChannel();
+
+public: // IMessageChannel
+ bool send(
+ const SmartPtrIIntMessage& message);
+
+ bool send(
+ const SmartPtrIIntMessage& message,
+ const int32 timeout);
+
+public: // IChannelInterceptorSupport
+ void setInterceptors(
+ const IChannelInterceptorSupport::InterceptorCollection& interceptors);
+
+protected:
+ /**
+ * Subclasses must implement this method. A non-negative timeout indicates
+ * how int32 to wait if the channel is at capacity. If the value is 0 it must
+ * return immediately with or without success. A negative timeout value
+ * indicates that the method should block until either the message is accepted
+ * or the blocking thread is interrupted.
+ */
+ virtual bool doSend(
+ const SmartPtrIIntMessage& message,
+ int32 timeout) = 0;
+
+protected:
+ std::list<SmartPtrIChannelInterceptor> getInterceptors() const;
+
+private:
+ std::list<SmartPtrIChannelInterceptor> _interceptors;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CAbstractMessageChannel);
+};
+}
+
+#endif /* CABSTRACTMESSAGECHANNEL_H_ */
--- /dev/null
+/*
+ * Created on: Aug 9, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CAbstractMessageRouter_h
+#define CAbstractMessageRouter_h
+
+
+#include "Integration/IMessageRouter.h"
+
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+
+namespace Caf {
+
+class INTEGRATIONCORE_LINKAGE CAbstractMessageRouter : public IMessageRouter {
+public:
+ CAbstractMessageRouter();
+ virtual ~CAbstractMessageRouter();
+
+ void init();
+
+ void init(
+ const SmartPtrIMessageChannel& defaultOutputChannel,
+ const bool ignoreSendFailures,
+ const int32 sendTimeout);
+
+ virtual void routeMessage(
+ const SmartPtrIIntMessage& message);
+
+protected:
+ typedef std::deque<SmartPtrIMessageChannel> ChannelCollection;
+ virtual ChannelCollection getTargetChannels(
+ const SmartPtrIIntMessage& message) = 0;
+
+private:
+ SmartPtrIMessageChannel _defaultOutputChannel;
+ bool _ignoreSendFailures;
+ int32 _sendTimeout;
+
+private:
+ bool _isInitialized;
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CAbstractMessageRouter);
+};
+
+}
+
+#endif /* CAbstractMessageRouter_h */
--- /dev/null
+/*
+ * Created on: Jan 26, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CABSTRACTPOLLABLECHANNEL_H_
+#define CABSTRACTPOLLABLECHANNEL_H_
+
+#include "Integration/Core/CAbstractMessageChannel.h"
+
+#include "Integration/Dependencies/CPollerMetadata.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+
+#include "Integration/IPollableChannel.h"
+
+namespace Caf {
+
+/**
+ * Base class for pollable channels
+ */
+class INTEGRATIONCORE_LINKAGE CAbstractPollableChannel :
+ public CAbstractMessageChannel,
+ public IPollableChannel {
+public:
+ CAbstractPollableChannel();
+ virtual ~CAbstractPollableChannel();
+
+public:
+ SmartPtrIIntMessage receive();
+ SmartPtrIIntMessage receive(const int32 timeout);
+ SmartPtrCPollerMetadata getPollerMetadata() const;
+
+protected:
+ /**
+ * Subclasses must implement this method. A non-negative timeout indicates
+ * how int32 to wait if the channel is empty (if the value is 0, it must
+ * return immediately with or without success). A negative timeout value
+ * indicates that the method should block until either a message is
+ * available or the blocking thread is interrupted.
+ */
+ virtual SmartPtrIIntMessage doReceive(const int32 timeout) = 0;
+
+ void setPollerMetadata(const SmartPtrCPollerMetadata& pollerMetadata);
+
+ void setPollerMetadata(const SmartPtrIDocument& pollerDoc);
+
+private:
+ SmartPtrCPollerMetadata _pollerMetadata;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CAbstractPollableChannel);
+};
+}
+
+#endif /* CABSTRACTPOLLABLECHANNEL_H_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CBroadcastingDispatcher_h_
+#define CBroadcastingDispatcher_h_
+
+
+#include "Integration/IMessageDispatcher.h"
+
+#include "Integration/IErrorHandler.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageHandler.h"
+
+namespace Caf {
+
+/// Sends responses/errors back to the client.
+class INTEGRATIONCORE_LINKAGE CBroadcastingDispatcher :
+ public IMessageDispatcher {
+public:
+ CBroadcastingDispatcher();
+ virtual ~CBroadcastingDispatcher();
+
+public:
+ void initialize(
+ const SmartPtrIErrorHandler& errorHandler);
+
+public: // IMessageDispatcher
+ void addHandler(
+ const SmartPtrIMessageHandler& messageHandler);
+
+ void removeHandler(
+ const SmartPtrIMessageHandler& messageHandler);
+
+ bool dispatch(
+ const SmartPtrIIntMessage& message);
+
+private:
+ typedef std::map<const void*, SmartPtrIMessageHandler> CIntMessageHandlerCollection;
+ CAF_DECLARE_SMART_POINTER(CIntMessageHandlerCollection);
+
+private:
+ bool _isInitialized;
+ SmartPtrIErrorHandler _errorHandler;
+ SmartPtrCIntMessageHandlerCollection _messageHandlerCollection;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CBroadcastingDispatcher);
+};
+
+CAF_DECLARE_SMART_POINTER(CBroadcastingDispatcher);
+
+}
+
+#endif // #ifndef CBroadcastingDispatcher_h_
--- /dev/null
+/*
+ * Created on: Jan 25, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CCHANNELINTERCEPTORADAPTER_H_
+#define CCHANNELINTERCEPTORADAPTER_H_
+
+
+#include "Integration/IChannelInterceptor.h"
+
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+
+namespace Caf {
+
+/**
+ * A {@link IChannelInterceptor} with no-op method implementations so that
+ * subclasses do not have to implement all of th einterface's methods.
+ */
+class INTEGRATIONCORE_LINKAGE CChannelInterceptorAdapter : public IChannelInterceptor {
+public:
+ CChannelInterceptorAdapter();
+ virtual ~CChannelInterceptorAdapter();
+
+public: // IChannelInterceptor
+ virtual SmartPtrIIntMessage& preSend(
+ SmartPtrIIntMessage& message,
+ SmartPtrIMessageChannel& channel);
+
+ virtual void postSend(
+ SmartPtrIIntMessage& message,
+ SmartPtrIMessageChannel& channel,
+ bool sent);
+
+ virtual bool preReceive(
+ SmartPtrIMessageChannel& channel);
+
+ virtual SmartPtrIIntMessage& postReceive(
+ SmartPtrIIntMessage& message,
+ SmartPtrIMessageChannel& channel);
+
+private:
+ CAF_CM_DECLARE_NOCOPY(CChannelInterceptorAdapter);
+};
+
+}
+
+#endif /* CCHANNELINTERCEPTORADAPTER_H_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 20, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CChannelResolver_h_
+#define CChannelResolver_h_
+
+
+#include "Integration/IChannelResolver.h"
+
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IMessageChannel.h"
+
+namespace Caf {
+
+class INTEGRATIONCORE_LINKAGE CChannelResolver :
+ public IChannelResolver {
+public:
+ CChannelResolver();
+ virtual ~CChannelResolver();
+
+public:
+ void initialize(
+ const SmartPtrCIntegrationObjectCollection& integrationObjectCollection);
+
+public: // IChannelResolver
+ SmartPtrIMessageChannel resolveChannelName(
+ const std::string& channelName) const;
+
+ SmartPtrIIntegrationObject resolveChannelNameToObject(
+ const std::string& channelName) const;
+
+private:
+ bool _isInitialized;
+ SmartPtrCIntegrationObjectCollection _integrationObjectCollection;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CChannelResolver);
+};
+
+CAF_DECLARE_SMART_POINTER(CChannelResolver);
+
+}
+
+#endif // #ifndef CChannelResolver_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 20, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CDocument_h_
+#define CDocument_h_
+
+
+#include "Integration/IDocument.h"
+
+#include "Xml/XmlUtils/CXmlElement.h"
+
+namespace Caf {
+
+class INTEGRATIONCORE_LINKAGE CDocument :
+ public IDocument {
+public:
+ CDocument();
+ virtual ~CDocument();
+
+public:
+ void initialize(const SmartPtrCXmlElement& xmlElement);
+ SmartPtrCXmlElement getXmlElement() const;
+
+public: // IDocument
+ std::string findRequiredAttribute(const std::string& name) const;
+ std::string findOptionalAttribute(const std::string& name) const;
+ SmartPtrIDocument findRequiredChild(const std::string& name) const;
+ SmartPtrIDocument findOptionalChild(const std::string& name) const;
+ SmartPtrCAttributeCollection getAllAttributes() const;
+ SmartPtrCChildCollection getAllChildren() const;
+ SmartPtrCOrderedChildCollection getAllChildrenInOrder() const;
+ std::string getName() const;
+ std::string getValue() const;
+ std::string getPath() const;
+
+public: // IDocument Save operations
+ void saveToFile(const std::string& filename) const;
+ std::string saveToString() const;
+ std::string saveToStringRaw() const;
+
+private:
+ bool _isInitialized;
+ SmartPtrCXmlElement _xmlElement;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CDocument);
+};
+
+CAF_DECLARE_SMART_POINTER(CDocument);
+}
+
+#endif // #ifndef CDocument_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 20, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CErrorHandler_h_
+#define CErrorHandler_h_
+
+
+#include "Integration/IErrorHandler.h"
+
+#include "Integration/IChannelResolver.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/IThrowable.h"
+
+namespace Caf {
+
+class INTEGRATIONCORE_LINKAGE CErrorHandler :
+ public IErrorHandler {
+public:
+ CErrorHandler();
+ virtual ~CErrorHandler();
+
+public:
+ void initialize(
+ const SmartPtrIChannelResolver& channelResolver,
+ const SmartPtrIMessageChannel& errorMessageChannel);
+
+public: // IErrorHandler
+ void handleError(
+ const SmartPtrIThrowable& throwable,
+ const SmartPtrIIntMessage& message) const;
+
+private:
+ bool _isInitialized;
+ SmartPtrIChannelResolver _channelResolver;
+ SmartPtrIMessageChannel _errorMessageChannel;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CErrorHandler);
+};
+
+CAF_DECLARE_SMART_POINTER(CErrorHandler);
+}
+
+#endif // #ifndef CErrorHandler_h_
--- /dev/null
+/*
+ * Created on: Jul 23, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CEXPRESSIONHANDLER_H_
+#define CEXPRESSIONHANDLER_H_
+
+
+#include "Common/IAppConfig.h"
+#include "Common/IAppContext.h"
+#include "IVariant.h"
+#include "Integration/IExpressionInvoker.h"
+
+namespace Caf {
+
+class INTEGRATIONCORE_LINKAGE CExpressionHandler {
+public:
+ CExpressionHandler();
+ virtual ~CExpressionHandler();
+
+ void init(
+ const SmartPtrIAppConfig& appConfig,
+ const SmartPtrIAppContext& appContext,
+ const std::string& expression);
+
+ SmartPtrIVariant evaluate(const SmartPtrIIntMessage& message);
+
+ std::string getBeanName() const;
+
+ std::string getMethodName() const;
+
+ Cdeqstr getMethodParameters() const;
+
+ std::string toString() const;
+
+private:
+ bool _isInitialized;
+ SmartPtrIExpressionInvoker _invoker;
+ std::string _beanName;
+ std::string _methodName;
+ Cdeqstr _methodParams;
+
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CExpressionHandler);
+};
+CAF_DECLARE_SMART_POINTER(CExpressionHandler);
+
+}
+
+#endif /* CEXPRESSIONHANDLER_H_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 20, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CIntException_h_
+#define CIntException_h_
+
+#include "Exception/CCafException.h"
+
+#include "Integration/IThrowable.h"
+#include "Integration/Core/CIntException.h"
+
+namespace Caf {
+
+class INTEGRATIONCORE_LINKAGE CIntException :
+ public IThrowable {
+public:
+ CIntException();
+ virtual ~CIntException();
+
+public:
+ void initialize(const CCafException* cafException);
+
+public: // IThrowable
+ std::string getExceptionClassName() const;
+ std::string getMsg() const;
+ std::string getClassName() const;
+ std::string getFuncName() const;
+ HRESULT getError() const;
+ std::deque<std::string>* getBacktrace() const;
+ std::string getFullMsg() const;
+
+private:
+ bool _isInitialized;
+ std::string _exceptionClassName;
+ HRESULT _errorCode;
+ std::string _message;
+ std::string _className;
+ std::string _funcName;
+ std::deque<std::string>* _backtrace;
+ std::string _fullMsg;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CIntException);
+};
+
+CAF_DECLARE_SMART_POINTER(CIntException);
+
+#define CAF_CM_DECLARE_INTEGRATION_EXCEPTION_CLASS(_exclass_) \
+class INTEGRATIONCORE_LINKAGE _exclass_ : public Caf::CCafException { \
+public: \
+ _exclass_(); \
+ virtual ~_exclass_(); \
+ void throwSelf(); \
+private: \
+ _exclass_(const _exclass_ &); \
+ _exclass_ & operator=(const _exclass_ &); \
+};
+
+// Exceptions specific to integration
+CAF_CM_DECLARE_INTEGRATION_EXCEPTION_CLASS(FatalListenerStartupException)
+
+CAF_CM_DECLARE_INTEGRATION_EXCEPTION_CLASS(ListenerExecutionFailedException)
+
+CAF_CM_DECLARE_INTEGRATION_EXCEPTION_CLASS(MessageDeliveryException)
+
+}
+
+#endif // #ifndef CIntException_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CIntMessage_h_
+#define CIntMessage_h_
+
+
+#include "Integration/IIntMessage.h"
+
+#include "ICafObject.h"
+#include "IVariant.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+
+namespace Caf {
+
+class INTEGRATIONCORE_LINKAGE CIntMessage :
+ public IIntMessage {
+public:
+ static SmartPtrCHeaders mergeHeaders(
+ const SmartPtrCHeaders& newHeaders,
+ const SmartPtrCHeaders& origHeaders);
+
+public:
+ CIntMessage();
+ virtual ~CIntMessage();
+
+public:
+ void initializeStr(
+ const std::string& payloadStr,
+ const SmartPtrCHeaders& newHeaders,
+ const SmartPtrCHeaders& origHeaders);
+
+ void initialize(
+ const SmartPtrCDynamicByteArray& payload,
+ const SmartPtrCHeaders& newHeaders,
+ const SmartPtrCHeaders& origHeaders);
+
+public: // IIntMessage
+ SmartPtrCDynamicByteArray getPayload() const;
+
+ std::string getPayloadStr() const;
+
+ UUID getMessageId() const;
+
+ std::string getMessageIdStr() const;
+
+ SmartPtrCHeaders getHeaders() const;
+
+ SmartPtrIVariant findOptionalHeader(
+ const std::string& key) const;
+
+ SmartPtrIVariant findRequiredHeader(
+ const std::string& key) const;
+
+ std::string findOptionalHeaderAsString(
+ const std::string& key) const;
+
+ std::string findRequiredHeaderAsString(
+ const std::string& key) const;
+
+ SmartPtrICafObject findOptionalObjectHeader(
+ const std::string& key) const;
+
+ SmartPtrICafObject findRequiredObjectHeader(
+ const std::string& key) const;
+
+private:
+ bool _isInitialized;
+ UUID _messageId;
+ SmartPtrCDynamicByteArray _payload;
+ SmartPtrCHeaders _headers;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CIntMessage);
+};
+
+CAF_DECLARE_SMART_POINTER(CIntMessage);
+
+}
+
+#endif // #ifndef _IntegrationContracts_CIntMessage_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CIntMessageHeaders_h_
+#define CIntMessageHeaders_h_
+
+#include "Integration/Core/CIntMessageHeaders.h"
+
+#include "ICafObject.h"
+#include "IVariant.h"
+#include "Integration/IIntMessage.h"
+
+namespace Caf {
+
+class INTEGRATIONCORE_LINKAGE CIntMessageHeaders {
+public:
+ CIntMessageHeaders();
+ virtual ~CIntMessageHeaders();
+
+public:
+ IIntMessage::SmartPtrCHeaders getHeaders() const;
+
+ void clear();
+
+ void insertString(
+ const std::string& key,
+ const std::string& value);
+
+ void insertStringOpt(
+ const std::string& key,
+ const std::string& value);
+
+ void insertInt64(
+ const std::string& key,
+ const int64& value);
+
+ void insertUint64(
+ const std::string& key,
+ const uint64& value);
+
+ void insertInt32(
+ const std::string& key,
+ const int32& value);
+
+ void insertUint32(
+ const std::string& key,
+ const uint32& value);
+
+ void insertInt16(
+ const std::string& key,
+ const int16& value);
+
+ void insertUint16(
+ const std::string& key,
+ const uint16& value);
+
+ void insertUint8(
+ const std::string& key,
+ const uint8& value);
+
+ void insertBool(
+ const std::string& key,
+ const bool& value);
+
+ void insertVariant(
+ const std::string& key,
+ const SmartPtrIVariant& variant);
+
+ void insertObject(
+ const std::string& key,
+ const SmartPtrICafObject& cafObject);
+
+private:
+ IIntMessage::SmartPtrCHeaders _headers;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CIntMessageHeaders);
+};
+
+CAF_DECLARE_SMART_POINTER(CIntMessageHeaders);
+
+}
+
+#endif // #ifndef _IntegrationContracts_CIntMessageHeaders_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 20, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CIntegrationAppContext_h_
+#define CIntegrationAppContext_h_
+
+
+
+#include "Common/IAppContext.h"
+
+#include "Common/CApplicationContext.h"
+#include "IBean.h"
+#include "Integration/Core/CChannelResolver.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ILifecycle.h"
+#include "Integration/IMessageChannel.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IIntegrationAppContext.h"
+
+namespace Caf {
+
+class INTEGRATIONCORE_LINKAGE CIntegrationAppContext :
+ public IIntegrationAppContext,
+ public IAppContext,
+ public IChannelResolver {
+public:
+ CIntegrationAppContext();
+ virtual ~CIntegrationAppContext();
+
+public:
+ void initialize(const uint32 timeoutMs);
+ void initialize(const uint32 timeoutMs, const std::string& beanConfigPath);
+ void initializeTwoPhase(const uint32 timeoutMs, const std::string& beanConfigPath);
+ void terminate(const uint32 timeoutMs);
+
+public: // IIntegrationAppContext
+ void startLifecycleBeans();
+ SmartPtrIIntegrationObject getIntegrationObject(const std::string& id) const;
+ void getIntegrationObject(const IID& iid, void **ppv) const;
+ SmartPtrCObjectCollection getIntegrationObjects(const IID& iid) const;
+
+public: // IAppContext
+ SmartPtrIBean getBean(const std::string& name) const;
+
+public: // IChannelResolver
+ SmartPtrIMessageChannel resolveChannelName(
+ const std::string& channelName) const;
+
+ SmartPtrIIntegrationObject resolveChannelNameToObject(
+ const std::string& channelName) const;
+
+private:
+ typedef std::multimap<int32, SmartPtrILifecycle> LifecycleBeans;
+
+private:
+ void initializeRaw(
+ const uint32 timeoutMs,
+ const std::string& beanConfigPath,
+ const bool startLifecycleBeans);
+
+ SmartPtrCIntegrationObjectCollection assign(
+ const IAppContext::SmartPtrCBeans& contextBeans,
+ const Cdeqstr& beanConfigPathCollection) const;
+
+ void injectChannelInterceptors(
+ const SmartPtrCIntegrationObjectCollection& integrationObjectCollection) const;
+
+ void wire(
+ const SmartPtrIAppContext& appContext,
+ const SmartPtrCIntegrationObjectCollection& integrationObjectCollection,
+ const SmartPtrCChannelResolver& channelResolver) const;
+
+ void startStop(
+ const LifecycleBeans& lifecycleBeans,
+ const uint32 timeoutMs,
+ const bool isStart) const;
+
+ SmartPtrCXmlElement getBeanConfigRoot() const;
+
+ void addBuiltIn(
+ const std::string& beanId,
+ const IAppContext::SmartPtrCBeans& beans,
+ SmartPtrCIntegrationObjectCollection& integrationObjectCollection) const;
+
+ std::string getDefaultBeanConfigPath() const;
+
+ Cdeqstr getBeanConfigFiles(
+ const std::string& beanConfigPath) const;
+
+private:
+ class CIntegrationAppContextWeakReference : public IIntegrationAppContext {
+ public:
+ CIntegrationAppContextWeakReference();
+
+ void set(CIntegrationAppContext *context);
+
+ SmartPtrIIntegrationObject getIntegrationObject(
+ const std::string& id) const;
+
+ void getIntegrationObject(
+ const IID& iid,
+ void **ppv) const;
+
+ IIntegrationAppContext::SmartPtrCObjectCollection getIntegrationObjects(
+ const IID& iid) const;
+
+ private:
+ CIntegrationAppContext *_context;
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_CM_DECLARE_NOCOPY(CIntegrationAppContextWeakReference);
+ };
+ CAF_DECLARE_SMART_POINTER(CIntegrationAppContextWeakReference);
+
+private:
+ bool _isInitialized;
+ bool _isIntegrationObjectCollectionReady;
+ bool _lifecycleBeansStarted;
+ uint32 _timeoutMs;
+ SmartPtrCApplicationContext _applicationContext;
+ SmartPtrCChannelResolver _channelResolver;
+ SmartPtrCIntegrationObjectCollection _integrationObjectCollection;
+ SmartPtrCIntegrationAppContextWeakReference _weakSelfReference;
+ LifecycleBeans _lifecycleBeans;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CIntegrationAppContext);
+};
+
+CAF_DECLARE_SMART_POINTER(CIntegrationAppContext);
+
+}
+
+#endif // #ifndef CIntegrationAppContext_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CMessageHandler_h_
+#define CMessageHandler_h_
+
+
+#include "Integration/IMessageHandler.h"
+
+#include "ICafObject.h"
+#include "Integration/IErrorProcessor.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/IMessageProcessor.h"
+#include "Integration/IMessageRouter.h"
+#include "Integration/IMessageSplitter.h"
+#include "Integration/ITransformer.h"
+
+namespace Caf {
+
+class INTEGRATIONCORE_LINKAGE CMessageHandler : public IMessageHandler {
+public:
+ CMessageHandler();
+ virtual ~CMessageHandler();
+
+public:
+ void initialize(
+ const std::string& inputId,
+ const SmartPtrIMessageChannel& outputMessageChannel,
+ const SmartPtrICafObject& messageHandlerObj);
+
+public:
+ std::string getInputId() const;
+
+public: // IMessageHandler
+ void handleMessage(
+ const SmartPtrIIntMessage& message);
+ SmartPtrIIntMessage getSavedMessage() const;
+ void clearSavedMessage();
+
+private:
+ bool _isInitialized;
+ std::string _inputId;
+ SmartPtrIIntMessage _savedMessage;
+
+ SmartPtrIMessageChannel _outputMessageChannel;
+ SmartPtrITransformer _transformer;
+ SmartPtrIMessageProcessor _messageProcessor;
+ SmartPtrIErrorProcessor _errorProcessor;
+ SmartPtrIMessageSplitter _messageSplitter;
+ SmartPtrIMessageRouter _messageRouter;
+ SmartPtrIMessageHandler _messageHandler;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CMessageHandler);
+};
+
+CAF_DECLARE_SMART_POINTER(CMessageHandler);
+
+}
+
+#endif // #ifndef CMessageHandler_h_
--- /dev/null
+/*
+ * Created on: Nov 19, 2014
+ * Author: bwilliams
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ *
+ */
+
+#ifndef CMessageHeaderUtils_h_
+#define CMessageHeaderUtils_h_
+
+
+#include "Integration/IIntMessage.h"
+
+namespace Caf {
+
+class INTEGRATIONCORE_LINKAGE CMessageHeaderUtils {
+public:
+ static std::string getStringReq(
+ const IIntMessage::SmartPtrCHeaders& headers,
+ const std::string& tag);
+
+ static std::string getStringOpt(
+ const IIntMessage::SmartPtrCHeaders& headers,
+ const std::string& tag);
+
+ static uint8 getUint8Req(
+ const IIntMessage::SmartPtrCHeaders& headers,
+ const std::string& tag);
+
+ static uint8 getUint8Opt(
+ const IIntMessage::SmartPtrCHeaders& headers,
+ const std::string& tag);
+
+ static uint16 getUint16Req(
+ const IIntMessage::SmartPtrCHeaders& headers,
+ const std::string& tag);
+
+ static uint16 getUint16Opt(
+ const IIntMessage::SmartPtrCHeaders& headers,
+ const std::string& tag);
+
+ static uint32 getUint32Req(
+ const IIntMessage::SmartPtrCHeaders& headers,
+ const std::string& tag);
+
+ static uint32 getUint32Opt(
+ const IIntMessage::SmartPtrCHeaders& headers,
+ const std::string& tag);
+
+ static uint64 getUint64Req(
+ const IIntMessage::SmartPtrCHeaders& headers,
+ const std::string& tag);
+
+ static uint64 getUint64Opt(
+ const IIntMessage::SmartPtrCHeaders& headers,
+ const std::string& tag);
+
+ static bool getBoolReq(
+ const IIntMessage::SmartPtrCHeaders& headers,
+ const std::string& tag);
+
+ static bool getBoolOpt(
+ const IIntMessage::SmartPtrCHeaders& headers,
+ const std::string& tag);
+
+ static void log(
+ const IIntMessage::SmartPtrCHeaders& headers,
+ const log4cpp::Priority::PriorityLevel priorityLevel = log4cpp::Priority::DEBUG);
+
+private:
+ CAF_CM_DECLARE_NOCREATE(CMessageHeaderUtils);
+};
+
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 20, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CMessagingTemplate_h_
+#define CMessagingTemplate_h_
+
+
+#include "Integration/ILifecycle.h"
+
+#include "ICafObject.h"
+#include "Integration/Core/CMessageHandler.h"
+#include "Integration/Core/CMessagingTemplateHandler.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/IPollableChannel.h"
+#include "Integration/ISubscribableChannel.h"
+#include "Integration/ITaskExecutor.h"
+
+namespace Caf {
+
+class INTEGRATIONCORE_LINKAGE CMessagingTemplate :
+ public ILifecycle {
+public:
+ CMessagingTemplate();
+ virtual ~CMessagingTemplate();
+
+public:
+ void initialize(
+ const SmartPtrIChannelResolver& channelResolver,
+ const SmartPtrIIntegrationObject& inputIntegrationObject,
+ const SmartPtrIMessageChannel& errorMessageChannel,
+ const SmartPtrIMessageChannel& outputMessageChannel,
+ const SmartPtrICafObject& messageHandlerObj);
+
+public: // ILifecycle
+ void start(const uint32 timeoutMs);
+ void stop(const uint32 timeoutMs);
+ bool isRunning() const;
+
+private:
+ bool _isInitialized;
+ bool _isRunning;
+ std::string _inputId;
+
+ SmartPtrISubscribableChannel _inputSubscribableChannel;
+ SmartPtrCMessagingTemplateHandler _messagingTemplateHandler;
+ SmartPtrITaskExecutor _taskExecutor;
+
+private:
+ SmartPtrITaskExecutor createTaskExecutor(
+ const SmartPtrIChannelResolver& channelResolver,
+ const SmartPtrCMessageHandler& messageHandler,
+ const SmartPtrIPollableChannel& inputPollableChannel,
+ const SmartPtrIMessageChannel& errorMessageChannel) const;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CMessagingTemplate);
+};
+
+CAF_DECLARE_SMART_POINTER(CMessagingTemplate);
+
+}
+
+#endif // #ifndef CMessagingTemplate_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CMessagingTemplateHandler_h_
+#define CMessagingTemplateHandler_h_
+
+
+#include "Integration/IMessageHandler.h"
+
+#include "Integration/IIntMessage.h"
+
+namespace Caf {
+
+class INTEGRATIONCORE_LINKAGE CMessagingTemplateHandler :
+ public IMessageHandler {
+public:
+ CMessagingTemplateHandler();
+ virtual ~CMessagingTemplateHandler();
+
+public:
+ void initialize(
+ const SmartPtrIMessageHandler& messageHandler);
+
+public: // IMessageHandler
+ void handleMessage(
+ const SmartPtrIIntMessage& message);
+ SmartPtrIIntMessage getSavedMessage() const;
+ void clearSavedMessage();
+
+private:
+ bool _isInitialized;
+
+ SmartPtrIMessageHandler _messageHandler;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CMessagingTemplateHandler);
+};
+
+CAF_DECLARE_SMART_POINTER(CMessagingTemplateHandler);
+
+}
+
+#endif // #ifndef CMessagingTemplateHandler_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 20, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CSimpleAsyncTaskExecutor_h_
+#define CSimpleAsyncTaskExecutor_h_
+
+#include "Common/CThreadSignal.h"
+
+#include "Integration/Core/CSimpleAsyncTaskExecutorState.h"
+#include "Integration/IErrorHandler.h"
+#include "Integration/IRunnable.h"
+
+#include "Integration/ITaskExecutor.h"
+
+namespace Caf {
+
+class INTEGRATIONCORE_LINKAGE CSimpleAsyncTaskExecutor :
+ public ITaskExecutor {
+public:
+ CSimpleAsyncTaskExecutor();
+ virtual ~CSimpleAsyncTaskExecutor();
+
+public:
+ void initialize(
+ const SmartPtrIRunnable& runnable,
+ const SmartPtrIErrorHandler& errorHandler);
+
+public: // ITaskExecutor
+ void execute(const uint32 timeoutMs);
+ void cancel(const uint32 timeoutMs);
+ ETaskState getState() const;
+
+private:
+ static void* threadFunc(void* data);
+
+private:
+ bool _isInitialized;
+ GThread* _thread;
+ SmartPtrCSimpleAsyncTaskExecutorState _state;
+ typedef std::pair<SmartPtrCAutoMutex, CSimpleAsyncTaskExecutorState*> CThreadData;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_THREADSIGNAL_CREATE;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_CM_DECLARE_NOCOPY(CSimpleAsyncTaskExecutor);
+};
+
+CAF_DECLARE_SMART_POINTER(CSimpleAsyncTaskExecutor);
+
+}
+
+#endif // #ifndef CSimpleAsyncTaskExecutor_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 20, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CSimpleAsyncTaskExecutorState_h_
+#define CSimpleAsyncTaskExecutorState_h_
+
+#include "Common/CThreadSignal.h"
+
+#include "Common/CAutoMutex.h"
+#include "Integration/IErrorHandler.h"
+#include "Integration/IRunnable.h"
+#include "Integration/ITaskExecutor.h"
+
+namespace Caf {
+
+class INTEGRATIONCORE_LINKAGE CSimpleAsyncTaskExecutorState {
+public:
+ CSimpleAsyncTaskExecutorState();
+ virtual ~CSimpleAsyncTaskExecutorState();
+
+public:
+ void initialize(
+ const SmartPtrIRunnable& runnable,
+ const SmartPtrIErrorHandler& errorHandler);
+
+ SmartPtrIRunnable getRunnable() const;
+ SmartPtrIErrorHandler getErrorHandler() const;
+
+ ITaskExecutor::ETaskState getState() const;
+ std::string getStateStr() const;
+ void setState(const ITaskExecutor::ETaskState runnableState);
+
+ bool getHasThreadExited();
+ void setThreadExited();
+
+ void signalStart();
+ void waitForStart(SmartPtrCAutoMutex& mutex, const uint32 timeoutMs);
+
+ void signalStop();
+ void waitForStop(SmartPtrCAutoMutex& mutex, const uint32 timeoutMs);
+
+private:
+ bool _isInitialized;
+ bool _hasThreadExited;
+ ITaskExecutor::ETaskState _runnableState;
+ SmartPtrIRunnable _runnable;
+ SmartPtrIErrorHandler _errorHandler;
+ std::string _exceptionMessage;
+
+ CThreadSignal _threadSignalStart;
+ CThreadSignal _threadSignalStop;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_CM_DECLARE_NOCOPY(CSimpleAsyncTaskExecutorState);
+};
+
+CAF_DECLARE_SMART_POINTER(CSimpleAsyncTaskExecutorState);
+
+}
+
+#endif // #ifndef CSimpleAsyncTaskExecutorState_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 20, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CSourcePollingChannelAdapter_h_
+#define CSourcePollingChannelAdapter_h_
+
+#include "Common/CThreadSignal.h"
+
+#include "Integration/Dependencies/CPollerMetadata.h"
+#include "Integration/IErrorHandler.h"
+#include "Integration/IMessageHandler.h"
+#include "Integration/IPollableChannel.h"
+
+#include "Integration/IRunnable.h"
+
+namespace Caf {
+
+class INTEGRATIONCORE_LINKAGE CSourcePollingChannelAdapter :
+ public IRunnable {
+public:
+ CSourcePollingChannelAdapter();
+ virtual ~CSourcePollingChannelAdapter();
+
+public:
+ void initialize(
+ const SmartPtrIMessageHandler& messageHandler,
+ const SmartPtrIPollableChannel& inputPollableChannel,
+ const SmartPtrIErrorHandler& errorHandler);
+
+ void initialize(
+ const SmartPtrIMessageHandler& messageHandler,
+ const SmartPtrIPollableChannel& inputPollableChannel,
+ const SmartPtrIErrorHandler& errorHandler,
+ const int32 timeout);
+
+public: // IRunnable
+ void run();
+ void cancel();
+
+private:
+ bool getIsCancelled() const;
+
+private:
+ bool _isInitialized;
+ bool _isCancelled;
+ bool _isTimeoutSet;
+ int32 _timeout;
+ SmartPtrIMessageHandler _messageHandler;
+ SmartPtrIPollableChannel _inputPollableChannel;
+ SmartPtrIErrorHandler _errorHandler;
+ SmartPtrCPollerMetadata _pollerMetadata;
+ CThreadSignal _threadSignalCancel;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_THREADSIGNAL_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CSourcePollingChannelAdapter);
+};
+
+CAF_DECLARE_SMART_POINTER(CSourcePollingChannelAdapter);
+
+}
+
+#endif // #ifndef CSourcePollingChannelAdapter_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CUnicastingDispatcher_h_
+#define CUnicastingDispatcher_h_
+
+
+#include "Integration/IMessageDispatcher.h"
+
+#include "Integration/Core/CBroadcastingDispatcher.h"
+#include "Integration/IErrorHandler.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageHandler.h"
+
+namespace Caf {
+
+/// Sends responses/errors back to the client.
+class INTEGRATIONCORE_LINKAGE CUnicastingDispatcher :
+ public IMessageDispatcher {
+public:
+ CUnicastingDispatcher();
+ virtual ~CUnicastingDispatcher();
+
+public:
+ void initialize(
+ const SmartPtrIErrorHandler& errorHandler);
+
+public: // IMessageDispatcher
+ void addHandler(
+ const SmartPtrIMessageHandler& messageHandler);
+
+ void removeHandler(
+ const SmartPtrIMessageHandler& messageHandler);
+
+ bool dispatch(
+ const SmartPtrIIntMessage& message);
+
+private:
+ typedef std::map<const void*, SmartPtrIMessageHandler> CIntMessageHandlerCollection;
+ CAF_DECLARE_SMART_POINTER(CIntMessageHandlerCollection);
+
+private:
+ bool _isInitialized;
+ SmartPtrIErrorHandler _errorHandler;
+ SmartPtrCIntMessageHandlerCollection _messageHandlerCollection;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CUnicastingDispatcher);
+};
+
+CAF_DECLARE_SMART_POINTER(CUnicastingDispatcher);
+
+}
+
+#endif // #ifndef CUnicastingDispatcher_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 20, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef FileHeadersInc_h_
+#define FileHeadersInc_h_
+
+namespace Caf {
+ namespace FileHeaders {
+ extern INTEGRATIONCORE_LINKAGE const char* _sFILENAME;
+ extern INTEGRATIONCORE_LINKAGE const char* _sORIGINAL_FILE;
+ }
+}
+
+#endif // #ifndef FileHeadersInc_h_
+
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 20, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef INTEGRATIONCORELINK_H_
+#define INTEGRATIONCORELINK_H_
+
+#ifndef INTEGRATIONCORE_LINKAGE
+ #ifdef WIN32
+ #ifdef FRAMEWORK_BUILD
+ #define INTEGRATIONCORE_LINKAGE __declspec(dllexport)
+ #else
+ #define INTEGRATIONCORE_LINKAGE __declspec(dllimport)
+ #endif
+ #else
+ #define INTEGRATIONCORE_LINKAGE
+ #endif
+#endif
+
+#endif /* INTEGRATIONCORELINK_H_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 20, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef MessageHeadersInc_h_
+#define MessageHeadersInc_h_
+
+namespace Caf {
+ namespace MessageHeaders {
+ // UUID stored as a string
+ extern INTEGRATIONCORE_LINKAGE const char* _sID;
+
+ // int64
+ extern INTEGRATIONCORE_LINKAGE const char* _sTIMESTAMP;
+
+ // string
+ extern INTEGRATIONCORE_LINKAGE const char* _sCORRELATION_ID;
+
+ // string
+ extern INTEGRATIONCORE_LINKAGE const char* _sREPLY_CHANNEL;
+
+ // string
+ extern INTEGRATIONCORE_LINKAGE const char* _sERROR_CHANNEL;
+
+ // int64
+ extern INTEGRATIONCORE_LINKAGE const char* _sEXPIRATION_DATE;
+
+ // int32
+ extern INTEGRATIONCORE_LINKAGE const char* _sPRIORITY;
+
+ // int32
+ extern INTEGRATIONCORE_LINKAGE const char* _sSEQUENCE_NUMBER;
+
+ // int32
+ extern INTEGRATIONCORE_LINKAGE const char* _sSEQUENCE_SIZE;
+
+ extern INTEGRATIONCORE_LINKAGE const char* _sIS_THROWABLE;
+
+ // string
+ extern INTEGRATIONCORE_LINKAGE const char* _sREQUEST_ID;
+
+ // boolean
+ extern INTEGRATIONCORE_LINKAGE const char* _sMULTIPART;
+
+ // string
+ extern INTEGRATIONCORE_LINKAGE const char* _sMULTIPART_WORKING_DIR;
+
+ // string
+ extern INTEGRATIONCORE_LINKAGE const char* _sMESSAGE_TYPE;
+
+ // string
+ extern INTEGRATIONCORE_LINKAGE const char* _sPROTOCOL_TYPE;
+
+ // string
+ extern INTEGRATIONCORE_LINKAGE const char* _sPROTOCOL_CONNSTR;
+ }
+};
+
+#endif // #ifndef MessageHeadersInc_h_
+
#ifndef _IntegrationContracts_ICHANNELINTERCEPTOR_H_
#define _IntegrationContracts_ICHANNELINTERCEPTOR_H_
+
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+
namespace Caf {
struct __declspec(novtable)
#ifndef _IntegrationContracts_ICHANNELINTERCEPTORSUPPORT_H_
#define _IntegrationContracts_ICHANNELINTERCEPTORSUPPORT_H_
+
+#include "ICafObject.h"
+
+#include "Integration/IChannelInterceptor.h"
+
namespace Caf {
struct __declspec(novtable)
#ifndef _IntegrationContracts_IChannelResolver_h_
#define _IntegrationContracts_IChannelResolver_h_
+
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IMessageChannel.h"
+
namespace Caf {
/// TODO - describe interface
#ifndef _IntegrationContracts_IErrorHandler_h_
#define _IntegrationContracts_IErrorHandler_h_
+
+#include "Integration/IIntMessage.h"
+#include "Integration/IThrowable.h"
+
namespace Caf {
/// TODO - describe interface
#ifndef _IntegrationContracts_IErrorProcessor_h_
#define _IntegrationContracts_IErrorProcessor_h_
+
+#include "Integration/IIntMessage.h"
+
namespace Caf {
/// TODO - describe interface
#ifndef _IntegrationContracts_IEXPRESSIONINVOKER_H_
#define _IntegrationContracts_IEXPRESSIONINVOKER_H_
+
+#include "IVariant.h"
+#include "Integration/IIntMessage.h"
+
namespace Caf {
struct __declspec(novtable) IExpressionInvoker : public ICafObject
#ifndef _IntegrationContracts_IIntMessage_h_
#define _IntegrationContracts_IIntMessage_h_
+
+#include "ICafObject.h"
+
+#include "IVariant.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+
namespace Caf {
/// TODO - describe interface
#ifndef _IntegrationContracts_IINTEGRATIONAPPCONTEXT_H_
#define _IntegrationContracts_IINTEGRATIONAPPCONTEXT_H_
+
+#include "ICafObject.h"
+
+#include "Integration/IIntegrationObject.h"
+
namespace Caf {
struct __declspec(novtable) IIntegrationAppContext : public ICafObject {
#ifndef _IntegrationContracts_IINTEGRATIONAPPCONTEXTAWARE_H_
#define _IntegrationContracts_IINTEGRATIONAPPCONTEXTAWARE_H_
+
+#include "ICafObject.h"
+
+#include "Integration/IIntegrationAppContext.h"
+
namespace Caf {
struct __declspec(novtable) IIntegrationAppContextAware : public ICafObject {
#ifndef _IntegrationContracts_IIntegrationComponent_h_
#define _IntegrationContracts_IIntegrationComponent_h_
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+
namespace Caf {
/// TODO - describe interface
#ifndef _IntegrationContracts_IIntegrationComponentInstance_h_
#define _IntegrationContracts_IIntegrationComponentInstance_h_
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+
namespace Caf {
/// TODO - describe interface
#ifndef _IntegrationContracts_IIntegrationObject_h_
#define _IntegrationContracts_IIntegrationObject_h_
+
+#include "Integration/IDocument.h"
+
namespace Caf {
/// TODO - describe interface
#ifndef _IntegrationContracts_IMessageChannel_h_
#define _IntegrationContracts_IMessageChannel_h_
+
+#include "Integration/IIntMessage.h"
+
namespace Caf {
/// TODO - describe interface
#ifndef _IntegrationContracts_IMessageDispatcher_h_
#define _IntegrationContracts_IMessageDispatcher_h_
+
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageHandler.h"
+
namespace Caf {
/// TODO - describe interface
#ifndef _IntegrationContracts_IMessageHandler_h_
#define _IntegrationContracts_IMessageHandler_h_
+
+#include "Integration/IIntMessage.h"
+
namespace Caf {
/// TODO - describe interface
#ifndef _IntegrationContracts_IMessageProcessor_h_
#define _IntegrationContracts_IMessageProcessor_h_
+
+#include "Integration/IIntMessage.h"
+
namespace Caf {
/// TODO - describe interface
#ifndef _IntegrationContracts_IMessageRouter_h_
#define _IntegrationContracts_IMessageRouter_h_
+
+#include "Integration/IIntMessage.h"
+
namespace Caf {
/// TODO - describe interface
#ifndef _IntegrationContracts_IMessageSplitter_h_
#define _IntegrationContracts_IMessageSplitter_h_
+
+#include "Integration/IIntMessage.h"
+
namespace Caf {
/// TODO - describe interface
#ifndef _IntegrationContracts_IPhased_h
#define _IntegrationContracts_IPhased_h
+
+#include "ICafObject.h"
+
namespace Caf {
struct __declspec(novtable) IPhased : public ICafObject {
#ifndef _IntegrationContracts_IPollableChannel_h_
#define _IntegrationContracts_IPollableChannel_h_
+
+#include "Integration/Dependencies/CPollerMetadata.h"
+#include "Integration/IIntMessage.h"
+
namespace Caf {
/// TODO - describe interface
#ifndef _IntegrationContracts_ISmartLifecycle_h
#define _IntegrationContracts_ISmartLifecycle_h
+
+#include "Integration/ILifecycle.h"
+
namespace Caf {
struct __declspec(novtable) ISmartLifecycle : public ILifecycle {
#ifndef _IntegrationContracts_ISubscribableChannel_h_
#define _IntegrationContracts_ISubscribableChannel_h_
+
+#include "Integration/IMessageHandler.h"
+
namespace Caf {
/// TODO - describe interface
#ifndef _FxContracts_IThrowable_h_
#define _FxContracts_IThrowable_h_
+
+#include "ICafObject.h"
+
namespace Caf {
CAF_FORWARD_DECLARE_SMART_INTERFACE(IThrowable);
#ifndef _IntegrationContracts_ITransformer_h_
#define _IntegrationContracts_ITransformer_h_
+
+#include "Integration/IIntMessage.h"
+
namespace Caf {
/// TODO - describe interface
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////////////////
+//
+// Author: Michael Donahue
+//
+// Created: 05/03/2004
+//
+// Copyright (c) 2011 Vmware, Inc. All rights reserved.
+// -- VMware Confidential
+//
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef DynamicArrayInc_h_
+#define DynamicArrayInc_h_
+
+#include "Memory/DynamicArray/SDynamicArrayMallocAllocator.h"
+
+namespace Caf {
+
+template<typename T, typename Allocator = SDynamicArrayMallocAllocator>
+class TDynamicArray;
+
+template<typename T>
+class TCharAdapter;
+
+template<typename T>
+class TWCharAdapter;
+
+template<typename T>
+class TByteAdapter;
+
+typedef TDynamicArray<byte> CDynamicByteArray;
+typedef TCharAdapter<TByteAdapter<TDynamicArray<char> > > CDynamicCharArray;
+typedef TWCharAdapter<TByteAdapter<TDynamicArray<wchar_t> > > CDynamicWCharArray;
+
+}
+
+#include "Memory/DynamicArray/TDynamicArray.h"
+#include "Memory/DynamicArray/TByteAdapter.h"
+#include "Memory/DynamicArray/TCharAdapter.h"
+#include "Memory/DynamicArray/TWCharAdapter.h"
+
+namespace Caf {
+
+CAF_DECLARE_SMART_POINTER(CDynamicByteArray);
+CAF_DECLARE_SMART_POINTER(CDynamicCharArray);
+CAF_DECLARE_SMART_POINTER(CDynamicWCharArray);
+
+}
+
+#endif // #ifdef DynamicArrayInc_h_
--- /dev/null
+/*
+ * Author: mdonahue
+ * Created: Feb 15, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef SDYNAMICARRAYMALLOCALLOCATOR_H_
+#define SDYNAMICARRAYMALLOCALLOCATOR_H_
+
+namespace Caf {
+
+struct SDynamicArrayMallocAllocator {
+ static void* allocMemory( const uint32 cdwAllocSize )
+ {
+ return ::malloc( cdwAllocSize );
+ }
+
+ static void freeMemory( void* pvFree )
+ {
+ if ( NULL != pvFree )
+ {
+ ::free( pvFree );
+ }
+ }
+};
+}
+
+#endif /* SDYNAMICARRAYMALLOCALLOCATOR_H_ */
--- /dev/null
+//////////////////////////////////////////////////////////////////////////////
+//
+// $Workfile: TByteAdapter.h $
+//
+// Author: Phil Smith
+//
+// Purpose: This template provides the ability to use a ${TDynamicArray}
+// or a TStaticArray where a byte pointer is required. It
+// provides a const byte* pointer conversion operator for use
+// when read only access is required and a function to get the
+// pointer for write access. Use the byte adapter as follows:
+// TByteAdapter<TDynamicArray<typename T> >
+//
+// Predefined character array objects CEcmCharArray and
+// CEcmWCharArray which use the byte adapter have been provided
+// in EcmCommonStaticMinDepInc.h.
+//
+// Created: Tuesday, August 20, 2002 10:00:00 AM
+//
+// Copyright (c) 2011 Vmware, Inc. All rights reserved.
+// -- VMware Confidential
+//
+// Modification History:
+//
+// $Log: //wpbuild01/PvcsData/ECM_40/archives/ECM_41/WinNT/Source/CommonAgtCol/Cpp/EcmCommonStaticMinDep/TByteAdapter.h-arc $
+//
+// Rev 1.4 17 Sep 2003 09:43:12 Michael.Donahue
+// Implemented hooks for new library model
+//
+// Rev 1.3 31 Oct 2002 13:58:02 Greg.Burk
+// Modified as per code review recomendations.
+//
+// Rev 1.2 15 Oct 2002 17:22:58 Phillip.Smith
+// Documentation updates.
+//
+// Rev 1.0 09 Oct 2002 13:42:12 brian.williams
+// Initial revision.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef _TByteAdapter_H_
+#define _TByteAdapter_H_
+
+namespace Caf {
+
+template<typename T>
+class TByteAdapter : public T
+{
+public:
+ //////////////////////////////////////////////////////////////////////////
+ // Default Constructor
+ //////////////////////////////////////////////////////////////////////////
+ TByteAdapter(const wchar_t * pwszDesc = NULL) {}
+
+ //////////////////////////////////////////////////////////////////////////
+ // Destructor
+ //////////////////////////////////////////////////////////////////////////
+ ~TByteAdapter() {}
+
+ //////////////////////////////////////////////////////////////////////////
+ // GetNonConstBytePtr
+ //
+ // Get non-const pointer to internal data converted to btye *.
+ // This function should be used only when you must get a pointer that is
+ // to be written to, and you should always call the ${TDynamicArray::Verify()}
+ // function after modifying the data pointed to by this pointer or passing
+ // the pointer to a function that modifies the data pointed to by this
+ // pointer.
+ //////////////////////////////////////////////////////////////////////////
+ byte * getNonConstBytePtr()
+ {
+ this->verify();
+ return reinterpret_cast<byte*>(this->getNonConstPtr());
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // GetBytePtr
+ //
+ // Get const pointer to internal data converted to btye *.
+ //////////////////////////////////////////////////////////////////////////
+ const byte * getBytePtr() const
+ {
+ this->verify();
+ return reinterpret_cast<const byte*>(this->getPtr());
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // const byte Conversion Operator
+ //
+ // Get const pointer to internal data converted to btye *.
+ //////////////////////////////////////////////////////////////////////////
+ operator const byte * () const
+ {
+ this->verify();
+ return reinterpret_cast<const byte*>(this->getPtr());
+ }
+
+private:
+ TByteAdapter(const TByteAdapter & crRhs);
+ TByteAdapter & operator=(const TByteAdapter & crRhs);
+};
+
+}
+
+#endif // _TByteAdapter_H_
--- /dev/null
+//////////////////////////////////////////////////////////////////////////////
+//
+// $Workfile: TCharAdapter.h $
+//
+// Author: Greg Burk
+//
+// Purpose: This template provides an adapter for TDynamicArray (or
+// other types of "safe" array classes) that exposes functions
+// that are useful when working with an array of type char.
+//
+// A typedef of this class is already defined and should be
+// used instead of explicitly using this class. The typedef
+// is CEcmCharArray.
+//
+// Created: Friday, October 18, 2002 1:50:32 PM
+//
+// Copyright (c) 2011 Vmware, Inc. All rights reserved.
+// -- VMware Confidential
+//
+// Modification History:
+//
+// $Log: //wpbuild01/PvcsData/ECM_40/archives/ECM_41/WinNT/Source/CommonAgtCol/Cpp/EcmCommonStaticMinDep/TCharAdapter.h-arc $
+//
+// Rev 1.3 10 Oct 2003 08:49:24 Michael.Donahue
+// Fixed bug in StrCpy
+//
+// Rev 1.2 17 Sep 2003 09:43:12 Michael.Donahue
+// Implemented hooks for new library model
+//
+// Rev 1.1 16 Jan 2003 11:17:52 Greg.Burk
+// Made changes necessary to accomodate new CEcmBasicString class and changes to CEcmString.
+//
+// Rev 1.0 31 Oct 2002 10:43:06 Greg.Burk
+// Initial Revision
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef _TCharAdapter_H_
+#define _TCharAdapter_H_
+
+#include <string.h>
+
+namespace Caf {
+
+template<typename T>
+class TCharAdapter : public T
+{
+public:
+ //////////////////////////////////////////////////////////////////////////
+ // Default Constructor
+ //////////////////////////////////////////////////////////////////////////
+ TCharAdapter() {}
+
+ //////////////////////////////////////////////////////////////////////////
+ // Conversion Constructor
+ //////////////////////////////////////////////////////////////////////////
+ TCharAdapter(const wchar_t * rhs)
+ {
+ wideToMultiByte(rhs);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // Conversion Constructor
+ //////////////////////////////////////////////////////////////////////////
+ TCharAdapter(const char * rhs)
+ {
+ (*this) = rhs;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // Destructor
+ //////////////////////////////////////////////////////////////////////////
+ ~TCharAdapter() {}
+
+ //////////////////////////////////////////////////////////////////////////
+ // Assignment operator
+ //////////////////////////////////////////////////////////////////////////
+ TCharAdapter& operator=(const wchar_t * rhs)
+ {
+ wideToMultiByte(rhs);
+ return *this;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // Assignment operator
+ //////////////////////////////////////////////////////////////////////////
+ TCharAdapter& operator=(const char * rhs)
+ {
+ const uint32 culLength = ::strlen(rhs);
+
+ if(culLength > 0)
+ {
+ this->allocateELements(culLength);
+ strnCpy(rhs, culLength);
+ }
+
+ return *this;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////
+ // MakeLower()
+ //
+ // Converts all of the upper-case characters in this string to lower-case.
+ //////////////////////////////////////////////////////////////////////////////
+ void makeLower()
+ {
+ // Pre-validation.
+ this->verifySentinal();
+
+ if(!this->IsNull())
+ {
+ strlwr(this->m_ptData);
+ }
+
+ // Post-validation.
+ this->verifySentinal();
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // MakeUpper
+ //
+ // Converts all of the lower-case characters in this array to upper-case.
+ //////////////////////////////////////////////////////////////////////////
+ void makeUpper()
+ {
+ // Pre-validation.
+ this->verifySentinal();
+
+ if(!this->isNull())
+ {
+ strupr(this->m_ptData);
+ }
+
+ // Post-validation.
+ this->verifySentinal();
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // Reverse
+ //
+ // Reverses the characters in the array.
+ //////////////////////////////////////////////////////////////////////////
+ void reverse()
+ {
+ // Pre-validation.
+ this->verifySentinal();
+
+ if(!this->isNull())
+ {
+ strrev( this->m_ptData );
+ }
+
+ // Post-validation.
+ this->verifySentinal();
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // StrLen
+ //
+ // Return the length of the string.
+ //////////////////////////////////////////////////////////////////////////
+ size_t strLen() const
+ {
+ size_t stRetVal = 0;
+
+ // Pre-validation.
+ this->verifySentinal();
+ this->verifyNotNull();
+
+ // Delegate to CEcmCtr.
+ stRetVal = ::strlen(this->m_ptData);
+
+ // Post-validation.
+ this->verifyLength(static_cast<uint32>(stRetVal));
+
+ return stRetVal;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // StrCpy
+ //
+ // Make a copy of the string into the buffer.
+ //////////////////////////////////////////////////////////////////////////
+ TCharAdapter & strCpy(const char * cpszSource)
+ {
+ // Pre-validation.
+ this->verifySentinal();
+ this->verifyNotNull();
+
+ // Get the length of the source string.
+ uint32 dwSourceLength = ::strlen(cpszSource);
+
+ // Make sure the string will fit if we copy it.
+ this->verifyLength(dwSourceLength);
+
+ // Copy the string into the buffer.
+ ::strcpy(this->m_ptData, cpszSource);
+
+ // Post-validation.
+ this->verifySentinal();
+
+ return (*this);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // StrnCpy
+ //
+ // Make a copy of the string into the buffer upto culCount characters.
+ //////////////////////////////////////////////////////////////////////////
+ TCharAdapter & strnCpy(const char * cpszSource, const uint32 culCount)
+ {
+ // Pre-validation.
+ this->verifySentinal();
+ this->verifyNotNull();
+
+ // Make sure the string will fit if we copy it.
+ this->verifyLength(culCount);
+
+ // Copy the string into the buffer.
+ ::strncpy(this->m_ptData, cpszSource, culCount);
+
+ // Post-validation.
+ this->verifySentinal();
+
+ return (*this);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // StrStr
+ //
+ // Find the substring cpszSubString in the array. Returns the pointer to
+ // the first occurance of the substring in the array or NULL if the
+ // substring is not found.
+ //////////////////////////////////////////////////////////////////////////
+ const char * strStr(const char * cpszSubString) const
+ {
+ const char * cpszRetVal = NULL;
+
+ // Pre-validation.
+ this->verifySentinal();
+ this->verifyNotNull();
+
+ // Find the substring.
+ cpszRetVal = ::strstr(this->m_ptData, cpszSubString);
+
+ // Post-validation.
+ this->verifySentinal();
+
+ return cpszRetVal;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // StrCmp
+ //
+ // Compare the cpszString to this array.
+ //////////////////////////////////////////////////////////////////////////
+ int32 strCmp(const char * cpszString) const
+ {
+ int32 iRetVal = 0;
+
+ // Pre-validation.
+ this->verifySentinal();
+ this->verifyNotNull();
+
+ // Compare the strings.
+ iRetVal = ::strcmp(this->m_ptData, cpszString);
+
+ return iRetVal;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // StriCmp
+ //
+ // Compare the cpszString to this array (case insensitive).
+ //////////////////////////////////////////////////////////////////////////
+ int32 striCmp(const char * cpszString) const
+ {
+ int32 iRetVal = 0;
+
+ // Pre-validation.
+ this->verifySentinal();
+ this->verifyNotNull();
+
+ // Compare the strings.
+ iRetVal = stricmp(this->m_ptData, cpszString);
+
+ return iRetVal;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // StrnCmp
+ //
+ // Compare the cpszString to this array up to culCount characters.
+ //////////////////////////////////////////////////////////////////////////
+ int32 strnCmp(const char * cpszString, const uint32 culCount) const
+ {
+ int32 iRetVal = 0;
+
+ // Pre-validation.
+ this->erifySentinal();
+ this->verifyNotNull();
+
+ // Make sure the comparison can take place with in our array bounds.
+ this->verifyLength(culCount);
+
+ // Compare the strings.
+ iRetVal = strncmp(this->m_ptData, cpszString, culCount);
+
+ return iRetVal;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // StrChr
+ //
+ // Find the first occurrence of the specified character in the string.
+ //////////////////////////////////////////////////////////////////////////
+ const char * strChr(char cCharacter) const
+ {
+ const char * cpszRetVal = 0;
+
+ // Pre-validation.
+ this->erifySentinal();
+ this->verifyNotNull();
+
+ // Compare the strings.
+ cpszRetVal = ::strchr(this->m_ptData, cCharacter);
+
+ return cpszRetVal;
+ }
+
+private:
+ void wideToMultiByte(const wchar_t* cpwszSource)
+ {
+ // Calculate the length of the source.
+ const uint32 cdwSourceLen = cpwszSource ? ::wcslen( cpwszSource ) : 0;
+
+ // Convert the wide strings to multibyte.
+ if( cdwSourceLen > 0 )
+ {
+ // This appears to be allocating twice as much memory as is needed, but
+ // this is the way W2A is implemented and W2A seems to convert some
+ // strings that will not convert where the destination is the same
+ // length (in characters) as the source.
+ this->allocateElements( cdwSourceLen * sizeof( wchar_t ) );
+
+ int32 iRet;
+#ifdef WIN32
+ iRet = ::WideCharToMultiByte(
+ CP_ACP,
+ 0,
+ cpwszSource,
+ -1,
+ GetNonConstPtr(),
+ GetLength(),
+ NULL,
+ NULL );
+#else
+ iRet = ::wcstombs( this->getNonConstPtr(),
+ cpwszSource,
+ this->getByteCount() );
+ // wcstombs returns -1 for error or the length
+ // not including the NULL, so we must increment
+ // to match the windows version
+ iRet++;
+#endif
+
+ if( 0 == iRet )
+ {
+ this->freeArray();
+ }
+ else
+ {
+ //
+ // Must ReAllocate in order to have the proper char length
+ // The char array was allocated based on wchar_t
+ //
+ // no need to include the NULL terminator
+ // returned by WideCharToMultiByte()
+ //
+ this->rellocateElements( iRet - 1 );
+ }
+ }
+ else if( cpwszSource != NULL )
+ {
+ // This chunk of code is important. If the source
+ // string is empty, return an empty string, not
+ // a NULL pointer!
+ this->allocateElements(0);
+ }
+
+ // Verify array.
+ this->verifySentinal();
+ }
+
+private:
+ TCharAdapter(const TCharAdapter & crRhs);
+ TCharAdapter & operator=(const TCharAdapter & crRhs);
+};
+
+}
+
+#endif // _TCharAdapter_H_
--- /dev/null
+//////////////////////////////////////////////////////////////////////////////
+//
+// Author: Greg Burk
+//
+// Purpose: This template provides a way to create an array that has
+// certain safety features that help solve some of the problems
+// often created by arrays in C++. You can create an array of
+// any type. The safety features of this class include array
+// bounds checking (indexes out of range), automatic
+// initialization, and automatic destruction. It also provides
+// some features to check the integrity of the array. This is
+// especially useful when you get and pass the raw pointer to
+// the array into a third party function (i.e. Windows API).
+//
+// The ${TDynamicArray::verify()} function is used for this
+// purpose. It does two primary things:
+//
+// 1) When the array is allocated, some extra space is allocated
+// for some sentinel bytes. These bytes are checked to make
+// sure they are still intact when verify() is called.
+//
+// 2) When the array is allocated, the address of the memory
+// that was allocated is stored and is XORed with a known
+// bit pattern and the result is also stored. When verify()
+// is called, this pattern is XORed again with the address
+// and the result should be the original pattern.
+//
+// If either of the above checks fails, an exception is thrown.
+// The primary weakness of this strategy is that the call to
+// verify() is left up to the user. If the raw pointer is passed
+// and something gets messed up, if verify() was not called, the
+// problem won't be discovered until the next time a function
+// that calls verify() (most do) is called. This will cause us
+// to loose the context in which the problem occurred.
+//
+// Created: Wednesday, August 07, 2002 2:27:39 PM
+//
+// Copyright (c) 2011 Vmware, Inc. All rights reserved.
+// -- VMware Confidential
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef _TDynamicArray_H_
+#define _TDynamicArray_H_
+
+#include <string.h>
+#include "Exception/CCafException.h"
+
+namespace Caf {
+
+//////////////////////////////////////////////////////////////////////////////
+// Define sentinel bit pattern.
+//////////////////////////////////////////////////////////////////////////////
+#ifdef __x86_64__
+static const uint64 gs_ulDynamicArraySentinelBitPattern = (0xAAAAAAAAAAAAAAAA);
+#else
+static const uint32 gs_ulDynamicArraySentinelBitPattern = (0xAAAAAAAA);
+#endif
+static const uint32 gs_ulDynamicArraySentinelElementCount = (3);
+
+template<typename T, typename Allocator>
+class TDynamicArray {
+public:
+ typedef T Type;
+
+ //////////////////////////////////////////////////////////////////////////
+ // Default Constructor
+ //////////////////////////////////////////////////////////////////////////
+ TDynamicArray() :
+ CAF_CM_INIT("TDynamicArray"),
+ _sentinelBits(gs_ulDynamicArraySentinelBitPattern),
+ _isSentinelSet(false),
+ _elementCount(0),
+ _elementIndex(0),
+ _byteCount(0),
+ _data(NULL) {
+ // Initialize the sentinel buffers.
+ ::memset(_sentinelBytes, 0, sizeof(_sentinelBytes));
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // Destructor
+ //////////////////////////////////////////////////////////////////////////
+ virtual ~TDynamicArray() {
+ CAF_CM_FUNCNAME("~TDynamicArray");
+ try {
+ freeArray();
+ }
+ CAF_CM_CATCH_ALL;
+ CAF_CM_CLEAREXCEPTION;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // PutDescription
+ //
+ // Assign description to object instance.
+ //////////////////////////////////////////////////////////////////////////
+ void putDescription(const char * pszDesc) {
+ CAF_CM_FUNCNAME_VALIDATE("putDescription");
+ CAF_CM_VALIDATE_STRINGPTRA(pszDesc);
+ _description = pszDesc;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // GetPtr
+ //
+ // Get const pointer to internal data
+ //////////////////////////////////////////////////////////////////////////
+ const T * getPtr() const {
+ // Pre-validation.
+ verifySentinel();
+
+ // Get pointer.
+ const T * rc = _data;
+
+ return rc;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // GetNonConstPtr
+ //
+ // Get non-const pointer to internal data. This function should be used
+ // only when you must get a pointer that is to be written to, and you
+ // should always call the ${TDynamicArray::verify()} function after modifying the data
+ // pointed to by this pointer or passing the pointer to a function that
+ // modifies the data pointed to by this pointer.
+ //////////////////////////////////////////////////////////////////////////
+ T * getNonConstPtr() {
+ // Pre-validation.
+ verifySentinel();
+
+ // Get pointer.
+ T * rc = _data;
+
+ return rc;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // const Conversion Operator
+ //////////////////////////////////////////////////////////////////////////
+ operator const T *() const {
+ // Pre-validation.
+ verifySentinel();
+
+ // Get pointer.
+ const T * rc = _data;
+
+ return rc;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // GetPtrAt
+ //
+ // Returns a const pointer to the internal array at a given index
+ //////////////////////////////////////////////////////////////////////////
+ const T * getPtrAt(const uint32 elementIndex) const {
+ // Pre-validation.
+ verifyNotNull();
+ verifySentinel();
+ verifyElementCount(elementIndex);
+
+ // Get the pointer at the index specified.
+ const T * rc = &_data[elementIndex];
+
+ return rc;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // GetNonConstPtrAt
+ //
+ // Returns a non-const pointer to the internal array at a given index.
+ // This function should be used only when you must get a pointer that is
+ // to be written to, and you should always call the ${TDynamicArray::verify()}
+ // function after modifying the data pointed to by this pointer or passing
+ // the pointer to a function that modifies the data pointed to by this
+ // pointer.
+ //////////////////////////////////////////////////////////////////////////
+ T * getNonConstPtrAt(const uint32 elementIndex) {
+ // Pre-validation.
+ verifyNotNull();
+ verifySentinel();
+ verifyElementCount(elementIndex);
+
+ // Get the pointer at the index specified.
+ T * rc = &_data[elementIndex];
+
+ return rc;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // GetAt
+ //
+ // Returns the array element at a given index
+ //////////////////////////////////////////////////////////////////////////
+ T getAt(const uint32 elementIndex) const {
+ // Pre-validation.
+ verifyNotNull();
+ verifySentinel();
+ verifyElementCount(elementIndex);
+
+ // Get the pointer at the index specified.
+ T tRetVal = _data[elementIndex];
+
+ return tRetVal;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // getPtrAtCurrentPos
+ //
+ // Returns a const pointer to the internal array at the current position.
+ //////////////////////////////////////////////////////////////////////////
+ const T * getPtrAtCurrentPos() const {
+ return getPtrAt(_elementIndex);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // getNonConstPtrAtCurrentPos
+ //
+ // Returns a non-const pointer to the internal array at the current position.
+ // This function should be used only when you must get a pointer that is
+ // to be written to, and you should always call the ${TDynamicArray::verify()}
+ // function after modifying the data pointed to by this pointer or passing
+ // the pointer to a function that modifies the data pointed to by this
+ // pointer.
+ //////////////////////////////////////////////////////////////////////////
+ T * getNonConstPtrAtCurrentPos() {
+ return getNonConstPtrAt(_elementIndex);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // GetAtCurrentPos
+ //
+ // Returns the array element at the current position
+ //////////////////////////////////////////////////////////////////////////
+ T getAtCurrentPos() const {
+ return getAt(_elementIndex);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // SetAt
+ //
+ // Sets the array element at a given index
+ //////////////////////////////////////////////////////////////////////////
+ void setAt(
+ const uint32 elementIndex,
+ const T value) {
+ // Pre-validation.
+ verifyNotNull();
+ verifySentinel();
+ verifyElementCount(elementIndex);
+
+ // Set the pointer at the index specified.
+ _data[elementIndex] = value;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // getElementCount
+ //
+ // Returns the number of array elements.
+ //////////////////////////////////////////////////////////////////////////
+ uint32 getElementCount() const {
+ return _elementCount;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // getByteCount
+ //
+ // Returns the size of the array in bytes.
+ //////////////////////////////////////////////////////////////////////////
+ uint32 getByteCount() const {
+ return _byteCount;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // getByteCountSize
+ //
+ // Returns the size of the array in bytes.
+ //////////////////////////////////////////////////////////////////////////
+ size_t getByteCountSize() const {
+ return static_cast<size_t>(_byteCount);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // IsNull
+ //
+ // Returns true if the pointer to the internal array is null or false if
+ // the array is not null
+ //////////////////////////////////////////////////////////////////////////
+ bool isNull() const {
+ return ((NULL == _data) ? true : false);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // verify
+ //
+ // Verifies that the array is still properly bound and in good shape.
+ //////////////////////////////////////////////////////////////////////////
+ void verify() const {
+ // verify.
+ verifySentinel();
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // Allocate
+ //
+ // Allocates a new array on the heap (elementCount = number of elements)
+ //////////////////////////////////////////////////////////////////////////
+ TDynamicArray & allocateElements(const uint32 elementCount) {
+ // Free the previous array if it exists.
+ freeArray();
+
+ // Call internal allocation function to actually allocate the
+ // array buffer.
+ internalAllocate(elementCount);
+
+ return (*this);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // AllocateBytes
+ //
+ // Allocates a new array on the heap.
+ //////////////////////////////////////////////////////////////////////////
+ TDynamicArray & allocateBytes(const size_t byteCount) {
+ return allocateBytes(static_cast<const uint32>(byteCount));
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // AllocateBytes
+ //
+ // Allocates a new array on the heap.
+ //////////////////////////////////////////////////////////////////////////
+ TDynamicArray & allocateBytes(const uint32 byteCount) {
+ // Calculate actual number of array elements to allocate based on
+ // the byte length.
+ const uint32 elementCount = byteCountToElementCount(byteCount);
+
+ // Delegate to Allocate().
+ allocateElements(elementCount);
+
+ return (*this);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // ReAllocate
+ //
+ // Reallocates a array on the heap, keeping original contents.
+ // culLength = number of elements
+ //////////////////////////////////////////////////////////////////////////
+ TDynamicArray & reallocateElements(const uint32 elementCount) {
+ CAF_CM_FUNCNAME("reallocateElements");
+
+ // Declare variables to hold copy of original information.
+ uint32 origElementIndex = 0;
+ uint32 origByteCount = 0;
+ T * origData = NULL;
+
+ try {
+ // Pre-validation.
+ verifySentinel();
+
+ // Create a temporary copy of the original buffer and length.
+ origElementIndex = _elementIndex;
+ origByteCount = _byteCount;
+ origData = _data;
+
+ // Reset the data pointer, length, and byte length.
+ _data = NULL;
+ _elementCount = 0;
+ _elementIndex = 0;
+ _byteCount = 0;
+
+ // Reset the sentinel set flag.
+ _isSentinelSet = false;
+
+ // Call internal allocation function to actually allocate the
+ // array buffer.
+ internalAllocate(elementCount);
+
+ // Copy the original into the new if it exists.
+ if((origData != NULL) && (origByteCount > 0)) {
+ // Calculate the number of bytes to copy.
+ const uint32 bytesToCopy =
+ (_byteCount < origByteCount) ? _byteCount : origByteCount;
+
+ // Copy the bytes.
+ ::memcpy(_data, origData, bytesToCopy);
+
+ const uint32 elementsToCopy = byteCountToElementCount(bytesToCopy);
+ _elementIndex =
+ (elementsToCopy < origElementIndex) ? elementsToCopy : origElementIndex;
+ }
+
+ // verify the sentinel bytes.
+ verifySentinel();
+ }
+ CAF_CM_CATCH_ALL;
+
+ // Delete the original buffer if non-null.
+ if (origData) {
+ Allocator::freeMemory(origData);
+ }
+
+ CAF_CM_THROWEXCEPTION;
+
+ return (*this);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // Grow
+ //
+ // Increases the size of the array by the length
+ // (number of elements) supplied
+ //////////////////////////////////////////////////////////////////////////
+ TDynamicArray & grow(const uint32 elementCount) {
+ reallocateElements(_elementCount + elementCount);
+
+ return (*this);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // ReAllocateBytes
+ //
+ // Reallocates a array on the heap, keeping original contents.
+ //////////////////////////////////////////////////////////////////////////
+ TDynamicArray & reallocateBytes(const size_t byteCount) {
+ return reallocateBytes(static_cast<const uint32>(byteCount));
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // ReAllocateBytes
+ //
+ // Reallocates a array on the heap, keeping original contents.
+ //////////////////////////////////////////////////////////////////////////
+ TDynamicArray & reallocateBytes(const uint32 byteCount) {
+ // Calculate actual number of array elements to allocate based
+ // on the byte length.
+ const uint32 elementCount = byteCountToElementCount(byteCount);
+
+ // Delegate to ReAllocate() function.
+ reallocateElements(elementCount);
+
+ return (*this);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // Free
+ //
+ // Frees the memory for the array.
+ //////////////////////////////////////////////////////////////////////////
+ void freeArray() {
+ // Free the buffer if it exists.
+ if (_data) {
+ verifySentinel();
+
+ // Zeroize the buffer for cryptographic purposes
+ ::memset(_data, 0, _byteCount);
+
+ Allocator::freeMemory(_data);
+ _data = NULL;
+
+ // Reset to initial value.
+ _sentinelBits = gs_ulDynamicArraySentinelBitPattern;
+ }
+
+ // Reset the length and byte length.
+ _elementCount = 0;
+ _elementIndex = 0;
+ _byteCount = 0;
+
+ // Reset the sentinel set flag.
+ _isSentinelSet = false;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // ArrayCpy
+ //
+ // Copies the array entries from crArray into this array.
+ //////////////////////////////////////////////////////////////////////////
+ void arrayCpy(const TDynamicArray & crArray) {
+ // Make sure reference is not to this.
+ if (this != &crArray) {
+ // Pre-validation.
+ verifyNotNull();
+ verifyByteCount(crArray.getByteCount());
+ verifySentinel();
+ crArray.verifySentinel();
+
+ // Reinitialize this array.
+ memSet();
+
+ // Copy the array.
+ memcpy(_data, crArray.getPtr(), crArray.getByteCount());
+
+ // Post-validation.
+ verifySentinel();
+ }
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // ArrayCmp
+ //
+ // Compare this array with crArray. Compares the entire array, so arrays
+ // must be equal size to evaluate to equal.
+ //////////////////////////////////////////////////////////////////////////
+ int32 arrayCmp(const TDynamicArray & crArray) const {
+ int32 iRetVal = 0;
+
+ // Make sure reference is not to this.
+ if (this != &crArray) {
+ // Pre-validation.
+ verifySentinel();
+ crArray.verifySentinel();
+
+ // Make sure the arrays are the same length.
+ if ((_data == NULL) && (crArray._data == NULL)) {
+ iRetVal = 0;
+ } else if (getByteCount() == crArray.getByteCount()) {
+ // Compare the array.
+ iRetVal = ::memcmp(_data, crArray.getPtr(), getByteCount());
+ } else {
+ iRetVal = (getByteCount() > crArray.getByteCount()) ? 1 : -1;
+ }
+
+ // Post-validation.
+ verifySentinel();
+ }
+
+ return iRetVal;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // ArrayPrepend
+ //
+ // Prepend this array with the provided array. This call will grow the
+ // array by the size of the provided array.
+ //////////////////////////////////////////////////////////////////////////
+ void arrayPrepend(const TDynamicArray & crArray) {
+ CAF_CM_FUNCNAME("arrayPrepend");
+
+ // Declare variables to hold copy of original information.
+ uint32 origByteCount = 0;
+ uint32 origElementCount = 0;
+ T * origData = NULL;
+
+ try {
+ // Pre-validation.
+ verifySentinel();
+
+ // Create a temporary copy of the original buffer and length.
+ origData = _data;
+ origByteCount = _byteCount;
+ origElementCount = _elementCount;
+
+ // Reset the data pointer, length, and byte length.
+ _data = NULL;
+ _elementCount = 0;
+ _elementIndex = 0;
+ _byteCount = 0;
+
+ // Reset the sentinel set flag.
+ _isSentinelSet = false;
+
+ // Call internal allocation function to actually allocate the
+ // array buffer.
+ internalAllocate(origElementCount + crArray.getElementCount());
+
+ // Get an intermediate pointer to the internal buffer.
+ T * tempData = _data;
+
+ // Copy the provided data into the new buffer if it exists.
+ if((crArray.getPtr() != NULL) && (crArray.getByteCount() > 0)) {
+ // Copy the bytes.
+ ::memcpy(tempData, crArray.getPtr(), crArray.getByteCount());
+
+ // Advance the pointer to the end of the data just copied.
+ tempData += crArray.getElementCount();
+ }
+
+ // Copy the original into the new if it exists.
+ if((origData != NULL) && (origByteCount > 0)) {
+ // Copy the bytes.
+ ::memcpy(tempData, origData, origByteCount);
+ }
+
+ // verify the sentinel bytes.
+ verifySentinel();
+ }
+ CAF_CM_CATCH_ALL;
+
+ // Delete the original buffer if non-null.
+ if (origData) {
+ Allocator::freeMemory(origData);
+ }
+
+ CAF_CM_THROWEXCEPTION;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // ArrayAppend
+ //
+ // Append this array with the provided array. This call will grow the
+ // array by the size of the provided array.
+ //////////////////////////////////////////////////////////////////////////
+ void arrayAppend(const TDynamicArray & crArray) {
+ CAF_CM_FUNCNAME("arrayAppend");
+
+ // Declare variables to hold copy of original information.
+ uint32 origByteCount = 0;
+ uint32 origElementCount = 0;
+ uint32 origElementIndex = 0;
+ T * origData = NULL;
+
+ try {
+ // Pre-validation.
+ verifySentinel();
+
+ // Create a temporary copy of the original buffer and length.
+ origData = _data;
+ origByteCount = _byteCount;
+ origElementCount = _elementCount;
+ origElementIndex = _elementIndex;
+
+ // Reset the data pointer, length, and byte length.
+ _data = NULL;
+ _elementCount = 0;
+ _elementIndex = 0;
+ _byteCount = 0;
+
+ // Reset the sentinel set flag.
+ _isSentinelSet = false;
+
+ // Call internal allocation function to actually allocate the
+ // array buffer.
+ internalAllocate(origElementCount + crArray.getElementCount());
+
+ // Get an intermediate pointer to the internal buffer.
+ T * tempData = _data;
+
+ // Copy the original into the new if it exists.
+ if((origData != NULL) && (origByteCount > 0))
+ {
+ // Copy the bytes.
+ ::memcpy(tempData, origData, origByteCount);
+
+ // Advance the pointer to the end of the data just copied.
+ tempData += origElementCount;
+ }
+
+ // Copy the provided data into the new buffer if it exists.
+ if((crArray.getPtr() != NULL) && (crArray.getByteCount() > 0)) {
+ // Copy the bytes.
+ ::memcpy(tempData, crArray.getPtr(), crArray.getByteCount());
+ }
+
+ _elementIndex = origElementIndex;
+
+ // verify the sentinel bytes.
+ verifySentinel();
+ }
+ CAF_CM_CATCH_ALL;
+
+ // Delete the original buffer if non-null.
+ if (origData) {
+ Allocator::freeMemory(origData);
+ }
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // MemSet
+ //
+ // Initializes the array by filling it with the fillValue.
+ //////////////////////////////////////////////////////////////////////////
+ void memSet(const byte fillValue = 0) {
+ // Pre-validation.
+ verifyNotNull();
+ verifySentinel();
+
+ // Initialize the buffer.
+ ::memset(_data, fillValue, _byteCount);
+ _elementIndex = 0;
+
+ // Post-validation.
+ verifySentinel();
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // MemCpy
+ //
+ // Copy the memory from sourceData into this array up to byteCount bytes.
+ //////////////////////////////////////////////////////////////////////////
+ void memCpy(
+ const void * sourceData,
+ const size_t byteCount) {
+ memCpy(sourceData, static_cast<const uint32>(byteCount));
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // MemCpy
+ //
+ // Copy the memory from sourceData into this array up to byteCount bytes.
+ //////////////////////////////////////////////////////////////////////////
+ void memCpy(
+ const void * sourceData,
+ const uint32 byteCount) {
+ // Pre-validation.
+ verifyNotNull();
+ verifySentinel();
+
+ // Make sure the data will fit if we copy it.
+ verifyByteCount(byteCount);
+
+ // Copy the data.
+ ::memcpy(_data, sourceData, byteCount);
+ _elementIndex = 0;
+
+ // Post-validation.
+ verifySentinel();
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // MemAppend
+ //
+ // Append the memory from sourceData into this array up to byteCount bytes.
+ //////////////////////////////////////////////////////////////////////////
+ void memAppend(
+ const void * sourceData,
+ const size_t byteCount) {
+ memAppend(sourceData, static_cast<const uint32>(byteCount));
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // MemAppend
+ //
+ // Append the memory from sourceData into this array up to byteCount bytes.
+ //////////////////////////////////////////////////////////////////////////
+ void memAppend(
+ const void * sourceData,
+ const uint32 byteCount) {
+ // Pre-validation.
+ verifyNotNull();
+ verifySentinel();
+
+ // Make sure the data will fit if we copy it.
+ const uint32 startingByteCount = elementCountToByteCount(_elementIndex);
+ verifyByteCount(startingByteCount + byteCount);
+
+ // Copy the data.
+ ::memcpy(_data + _elementIndex, sourceData, byteCount);
+ _elementIndex += byteCountToElementCount(byteCount);
+
+ // Post-validation.
+ verifySentinel();
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // MemCmp
+ //
+ // Compare the memory from sourceData with this array up to byteCount bytes.
+ //////////////////////////////////////////////////////////////////////////
+ int32 memCmp(
+ const void * sourceData,
+ const size_t byteCount) {
+ return memCmp(sourceData, static_cast<const uint32>(byteCount));
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // MemCmp
+ //
+ // Compare the memory from sourceData with this array up to byteCount bytes.
+ //////////////////////////////////////////////////////////////////////////
+ int32 memCmp(
+ const void * sourceData,
+ const uint32 byteCount) const {
+ CAF_CM_FUNCNAME_VALIDATE("memCmp");
+ CAF_CM_VALIDATE_PTR(sourceData);
+ CAF_CM_VALIDATE_POSITIVE(byteCount);
+
+ // Pre-validation.
+ verifySentinel();
+
+ // Make sure the comparison can take place within our array bounds.
+ verifyByteCount(byteCount);
+
+ // Do comparison.
+ int32 iRetVal = 0;
+ if ((_data == NULL) && (sourceData == NULL)) {
+ iRetVal = 0;
+ } else {
+ iRetVal = ::memcmp(_data, sourceData, byteCount);
+ }
+
+ // Post-validation.
+ verifySentinel();
+
+ return iRetVal;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // MemiCmp
+ //
+ // Compare the memory from sourceData with this array up to byteCount bytes
+ // (case insensitive).
+ //////////////////////////////////////////////////////////////////////////
+ int32 memiCmp(
+ const void * sourceData,
+ const size_t byteCount) {
+ return memiCmp(sourceData, static_cast<const uint32>(byteCount));
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // MemiCmp
+ //
+ // Compare the memory from sourceData with this array up to byteCount bytes
+ // (case insensitive).
+ //////////////////////////////////////////////////////////////////////////
+ int32 memiCmp(
+ const void * sourceData,
+ const uint32 byteCount) const {
+ CAF_CM_FUNCNAME_VALIDATE("memiCmp");
+ CAF_CM_VALIDATE_PTR(sourceData);
+ CAF_CM_VALIDATE_POSITIVE(byteCount);
+
+ // Pre-validation.
+ verifySentinel();
+
+ // Make sure the comparison can take place within our array bounds.
+ verifyByteCount(byteCount);
+
+ // Do comparison.
+ int32 iRetVal = 0;
+ if ((_data == NULL) && (sourceData == NULL)) {
+ iRetVal = 0;
+ } else {
+ iRetVal = memicmp(_data, sourceData, byteCount);
+ }
+
+ // Post-validation.
+ verifySentinel();
+
+ return iRetVal;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // incrementElementIndex
+ //
+ // Increments the current position of the index into the buffer.
+ //////////////////////////////////////////////////////////////////////////
+ void incrementCurrentPos(const uint32 elementCount) {
+ CAF_CM_FUNCNAME("incrementCurrentPos");
+
+ if ((_elementIndex + elementCount) > _elementCount) {
+ CAF_CM_EXCEPTION_VA3(ERROR_INSUFFICIENT_BUFFER,
+ "Current position is longer than the total size for '%s' - currentPos: %d, totalLen: %d",
+ _description.c_str(), _elementIndex + elementCount, _elementCount);
+ }
+
+ _elementIndex += elementCount;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // resetElementIndex
+ //
+ // Resets the current position of the index into the buffer.
+ //////////////////////////////////////////////////////////////////////////
+ void resetCurrentPos() {
+ _elementIndex = 0;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // getByteCountFromCurrentPos
+ //
+ // Returns the size of the array in bytes from the current position.
+ //////////////////////////////////////////////////////////////////////////
+ uint32 getByteCountFromCurrentPos() const {
+ const uint32 byteIndex = elementCountToByteCount(_elementIndex);
+ return (_byteCount - byteIndex);
+ }
+
+private:
+ //////////////////////////////////////////////////////////////////////////
+ // internalAllocate (Private)
+ //
+ // Set the sentinel bytes at the end of the array.
+ //////////////////////////////////////////////////////////////////////////
+ void internalAllocate(const uint32 elementCount) {
+ CAF_CM_FUNCNAME("internalAllocate");
+
+ // This function assumes the calling function has freed any pre-
+ // existing array.
+ CAF_CM_VALIDATE_NULLPTR(_data);
+ CAF_CM_VALIDATE_ZERO(_elementCount);
+ CAF_CM_VALIDATE_ZERO(_byteCount);
+
+ // Allocate the new buffer. This buffer is
+ _data = static_cast<T*>(Allocator::allocMemory(
+ sizeof(T) * (elementCount + gs_ulDynamicArraySentinelElementCount)));
+
+ // verify that the allocation succeeded.
+ if (!_data) {
+ CAF_CM_EXCEPTION_VA1(ERROR_OUTOFMEMORY, "Array allocation failed for '%s'",
+ _description.c_str());
+ }
+
+ // Set sentinel bits
+#ifdef __x86_64__
+ _sentinelBits = reinterpret_cast<const uint64>(_data)
+ ^ gs_ulDynamicArraySentinelBitPattern;
+#else
+ _sentinelBits = reinterpret_cast<const uint32>(_data) ^ gs_ulDynamicArraySentinelBitPattern;
+#endif
+
+ // Initialize the new buffer.
+ ::memset(_data, 0,
+ ((elementCount + gs_ulDynamicArraySentinelElementCount) * sizeof(T)));
+
+ // Set the length and byte length.
+ _elementCount = elementCount;
+ _elementIndex = 0;
+ _byteCount = elementCountToByteCount(elementCount);
+
+ // Set the sentinel bytes.
+ setSentinel();
+
+ // verify the sentinel bytes.
+ verifySentinel();
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // SetSentinel (Private)
+ //
+ // Set the sentinel bytes at the end of the array.
+ //////////////////////////////////////////////////////////////////////////
+ void setSentinel() {
+ // Set the sentinel characters.
+ for (uint32 ulIndex = 0; ulIndex < (2 * sizeof(T)); ++ulIndex) {
+ // Set the sentinel bytes at the end of the array.
+ reinterpret_cast<byte*>(_data)[(_byteCount + ulIndex + sizeof(T))] =
+ ((ulIndex % 2) == 0) ? 0xFF : 0xDD;
+
+ // Make a copy of the sentinel bytes for later comparison.
+ _sentinelBytes[ulIndex + sizeof(T)] = ((ulIndex % 2) == 0) ? 0xFF : 0xDD;
+ }
+
+ // Set the flag indicating the sentinel is set.
+ _isSentinelSet = true;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // verifyByteCount (Private)
+ //
+ // Verifies that the byte length supplied is not longer than the array
+ // byte length.
+ //////////////////////////////////////////////////////////////////////////
+ void verifyByteCount(const uint32 byteCount) const {
+ CAF_CM_FUNCNAME("verifyByteCount");
+
+ if (byteCount > _byteCount) {
+ CAF_CM_EXCEPTION_VA3(ERROR_INVALID_INDEX, "The byte length specified [%d] "
+ "exceeds the array length [%d] for '%s'", byteCount, _byteCount,
+ _description.c_str());
+ }
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // verifyElementCount (Private)
+ //
+ // Verifies that the index supplied does not go past end of the array.
+ //////////////////////////////////////////////////////////////////////////
+ void verifyElementCount(const uint32 elementCount) const {
+ CAF_CM_FUNCNAME("verifyElementCount");
+
+ if (elementCount >= _elementCount) {
+ CAF_CM_EXCEPTION_VA3(ERROR_INVALID_INDEX, "The index specified [%d] is "
+ "beyond the array bounds [%d] for '%s'", elementCount, (_elementCount - 1),
+ _description.c_str());
+ }
+ }
+
+ uint32 byteCountToElementCount(const uint32 byteCount) const {
+ uint32 rc = 0;
+ if (byteCount > 0) {
+ rc = (byteCount / sizeof(T)) + (byteCount % sizeof(T));
+ }
+
+ return rc;
+ }
+
+ uint32 elementCountToByteCount(const uint32 elementCount) const {
+ return (elementCount * sizeof(T));
+ }
+
+protected:
+ //////////////////////////////////////////////////////////////////////////
+ // verifySentinel (Private)
+ //
+ // Verifies that the sentinel bytes are still intact.
+ //////////////////////////////////////////////////////////////////////////
+ void verifySentinel() const {
+ CAF_CM_FUNCNAME("verifySentinel");
+
+ if (_isSentinelSet) {
+#ifdef __x86_64__
+ if ((_sentinelBits ^ reinterpret_cast<const uint64>(_data))
+ != gs_ulDynamicArraySentinelBitPattern)
+#else
+ if ((_sentinelBits ^ reinterpret_cast<const uint32>(_data)) !=
+ gs_ulDynamicArraySentinelBitPattern)
+#endif
+ {
+ CAF_CM_EXCEPTION_VA1(ERROR_INVALID_DATA,
+ "The sentinel BITS for array '%s' are no longer valid.",
+ _description.c_str());
+ } else if (::memcmp(_sentinelBytes,
+ (reinterpret_cast<const byte *>(_data) + _byteCount),
+ sizeof(_sentinelBytes)) != 0) {
+ CAF_CM_EXCEPTION_VA1(ERROR_INVALID_DATA,
+ "The sential BYTES for array '%s' are no longer valid.",
+ _description.c_str());
+ }
+ } else if (_sentinelBits != gs_ulDynamicArraySentinelBitPattern) {
+ CAF_CM_EXCEPTION_VA1(ERROR_INVALID_DATA,
+ "The sential BITS for array '%s' are no longer valid.", _description.c_str());
+ }
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // verifyNotNull (Private)
+ //
+ // Verifies that the data pointer is not null.
+ //////////////////////////////////////////////////////////////////////////
+ void verifyNotNull() const {
+ CAF_CM_FUNCNAME("verifyNotNull");
+
+ if (NULL == _data) {
+ CAF_CM_EXCEPTION_VA1(E_POINTER, "The pointer to the array is null for '%s'",
+ _description.c_str());
+ }
+ }
+
+private:
+ TDynamicArray(const TDynamicArray & crRhs);
+ TDynamicArray & operator=(const TDynamicArray & crRhs);
+
+#ifdef WIN32
+ //////////////////////////////////////////////////////////////////////////
+ // Operator[] (Private)
+ //
+ // We need to provide an implementation to satisfy the VC8 compiler
+ // even though we never intend this method to be called.
+ //////////////////////////////////////////////////////////////////////////
+ T operator[](size_t)
+ {
+ // Yes, this code looks very wrong, however, DO NOT REMOVE it!
+ // It is here to supply an implementation that doesn't generate
+ // compiler warnings. This method will never be called.
+ T* tpRetVal = NULL;
+ return *tpRetVal;
+ }
+#endif
+
+private:
+ CAF_CM_CREATE;
+ byte _sentinelBytes[gs_ulDynamicArraySentinelElementCount * sizeof(T)];
+#ifdef __x86_64__
+ uint64 _sentinelBits;
+#else
+ uint32 _sentinelBits;
+#endif
+ bool _isSentinelSet;
+
+ // NOTE: ...Count are not zero-relative, ...Index are zero-relative.
+
+ // An element is the template type (e.g. wchar_t), so the element count
+ // is the number of these template types in the array.
+ uint32 _elementCount;
+ uint32 _elementIndex;
+
+ // The number of bytes consumed by the array of template types.
+ uint32 _byteCount;
+
+protected:
+ std::string _description;
+ T * _data;
+};
+
+}
+
+#endif // _TDynamicArray_H_
--- /dev/null
+//////////////////////////////////////////////////////////////////////////////
+//
+// $Workfile: TWCharAdapter.h $
+//
+// Author: Greg Burk
+//
+// Purpose: This template provides an adapter for TDynamicArray (or
+// other types of "safe" array classes) that exposes functions
+// that are useful when working with an array of type wchar_t.
+//
+// A typedef of this class is already defined and should be
+// used instead of explicitly using this class. The typedef
+// is CEcmWCharArray.
+//
+// Created: Friday, October 18, 2002 1:59:49 PM
+//
+// Copyright (c) 2011 Vmware, Inc. All rights reserved.
+// -- VMware Confidential
+//
+// Modification History:
+//
+// $Log: //wpbuild01/PvcsData/ECM_40/archives/ECM_41/WinNT/Source/CommonAgtCol/Cpp/EcmCommonStaticMinDep/TWCharAdapter.h-arc $
+//
+// Rev 1.2 17 Sep 2003 09:43:16 Michael.Donahue
+// Implemented hooks for new library model
+//
+// Rev 1.1 16 Jan 2003 11:17:54 Greg.Burk
+// Made changes necessary to accomodate new CEcmBasicString class and changes to CEcmString.
+//
+// Rev 1.0 31 Oct 2002 10:43:08 Greg.Burk
+// Initial Revision
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef _TWCharAdapter_H_
+#define _TWCharAdapter_H_
+
+namespace Caf {
+
+template<typename T>
+class TWCharAdapter : public T
+{
+public:
+ //////////////////////////////////////////////////////////////////////////
+ // Default Constructor
+ //////////////////////////////////////////////////////////////////////////
+ TWCharAdapter() {}
+
+ //////////////////////////////////////////////////////////////////////////
+ // Conversion Constructor
+ //////////////////////////////////////////////////////////////////////////
+ TWCharAdapter(const char * rhs)
+ {
+ multiByteToWide(rhs);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // Conversion Constructor
+ //////////////////////////////////////////////////////////////////////////
+ TWCharAdapter(const wchar_t * rhs)
+ {
+ (*this) = rhs;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // Destructor
+ //////////////////////////////////////////////////////////////////////////
+ ~TWCharAdapter() {}
+
+ //////////////////////////////////////////////////////////////////////////
+ // Assignment operator
+ //////////////////////////////////////////////////////////////////////////
+ TWCharAdapter& operator=(const char * rhs)
+ {
+ multiByteToWide(rhs);
+ return *this;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // Assignment operator
+ //////////////////////////////////////////////////////////////////////////
+ TWCharAdapter& operator=(const wchar_t * rhs)
+ {
+ const uint32 culLength = ::wcslen(rhs);
+
+ if(culLength > 0)
+ {
+ this->allocateElements(culLength);
+ wcsnCpy(rhs, culLength);
+ }
+ return *this;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////
+ // MakeLower()
+ //
+ // Converts all of the upper-case characters in this string to lower-case.
+ //////////////////////////////////////////////////////////////////////////////
+ void makeLower()
+ {
+ // Pre-validation.
+ this->verifySentinal();
+
+ if(!this->isNull())
+ {
+ wcslwr(this->m_ptData);
+ }
+
+ // Post-validation.
+ this->verifySentinal();
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // MakeUpper
+ //
+ // Converts all of the lower-case characters in this array to upper-case.
+ //////////////////////////////////////////////////////////////////////////
+ void makeUpper()
+ {
+ // Pre-validation.
+ this->verifySentinal();
+
+ if(!this->isNull())
+ {
+ wcsupr(this->m_ptData);
+ }
+
+ // Post-validation.
+ this->verifySentinal();
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // Reverse
+ //
+ // Reverses the characters in the array.
+ //////////////////////////////////////////////////////////////////////////
+ void reverse()
+ {
+ // Pre-validation.
+ this->verifySentinal();
+
+ if(!this->isNull())
+ {
+ wcsrev(this->m_ptData);
+ }
+
+ // Post-validation.
+ this->verifySentinal();
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // WcsLen
+ //
+ // Return the length of the string.
+ //////////////////////////////////////////////////////////////////////////
+ size_t wcsLen() const
+ {
+ size_t stRetVal = 0;
+ this->verifySentinal();
+ this->verifyNotNull();
+ stRetVal = ::wcslen(this->m_ptData, this->m_strDesc);
+ this->verifyLength(static_cast<uint32>(stRetVal));
+ return stRetVal;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // WcsCpy
+ //
+ // Make a copy of the string into the buffer.
+ //////////////////////////////////////////////////////////////////////////
+ TWCharAdapter & wcsCpy(const wchar_t * cpwszSource)
+ {
+ // Pre-validation.
+ this->verifySentinal();
+ this->verifyNotNull();
+
+ // Get the length of the source string.
+ uint32 dwSourceLength = ::wcslen(cpwszSource);
+
+ // Make sure the string will fit if we copy it.
+ this->verifyLength(dwSourceLength);
+
+ // Copy the string into the buffer.
+ ::wcscpy(this->m_ptData, cpwszSource);
+
+ // Post-validation.
+ this->verifySentinal();
+
+ return (*this);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // WcsnCpy
+ //
+ // Make a copy of the string into the buffer upto culCount characters.
+ //////////////////////////////////////////////////////////////////////////
+ TWCharAdapter & wcsnCpy(const wchar_t * cpwszSource, const uint32 culCount)
+ {
+ // Pre-validation.
+ this->verifySentinal();
+ this->verifyNotNull();
+
+ // Make sure the string will fit if we copy it.
+ this->verifyLength(culCount);
+
+ // Copy the string into the buffer.
+ ::wcsncpy(this->m_ptData, cpwszSource, culCount);
+
+ // Post-validation.
+ this->verifySentinal();
+
+ return (*this);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // WcsStr
+ //
+ // Find the substring cpwszSubString in the array. Returns the pointer to
+ // the first occurance of the substring in the array or NULL if the
+ // substring is not found.
+ //////////////////////////////////////////////////////////////////////////
+ const wchar_t * wcsStr(const wchar_t * cpwszSubString) const
+ {
+ wchar_t * pwszRetVal = NULL;
+
+ // Pre-validation.
+ this->verifySentinal();
+ this->verifyNotNull();
+
+ // Find the substring.
+ pwszRetVal = ::wcsstr(this->m_ptData, cpwszSubString);
+
+ // Post-validation.
+ this->verifySentinal();
+
+ return pwszRetVal;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // WcsCmp
+ //
+ // Compare the cpwszString to this array.
+ //////////////////////////////////////////////////////////////////////////
+ int32 wcsCmp(const wchar_t * cpwszString) const
+ {
+ int32 iRetVal = 0;
+
+ // Pre-validation.
+ this->verifySentinal();
+ this->verifyNotNull();
+
+ // Compare the strings.
+ iRetVal = ::wcscmp(this->m_ptData, cpwszString);
+
+ return iRetVal;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // WcsiCmp
+ //
+ // Compare the cpwszString to this array (case insensitive).
+ //////////////////////////////////////////////////////////////////////////
+ int32 wcsiCmp(const wchar_t * cpwszString) const
+ {
+ int32 iRetVal = 0;
+
+ // Pre-validation.
+ this->verifySentinal();
+ this->verifyNotNull();
+
+ // Compare the strings.
+ iRetVal = wcsicmp(this->m_ptData, cpwszString);
+
+ return iRetVal;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // WcsnCmp
+ //
+ // Compare the cpwszString to this array up to culCount characters.
+ //////////////////////////////////////////////////////////////////////////
+ int32 wcsnCmp(const wchar_t * cpwszString, const uint32 culCount) const
+ {
+ int32 iRetVal = 0;
+
+ // Pre-validation.
+ this->verifySentinal();
+ this->verifyNotNull();
+
+ // Make sure the comparison can take place with in our array bounds.
+ this->verifyLength(culCount);
+
+ // Compare the strings.
+ iRetVal = wcsncmp(this->m_ptData, cpwszString, culCount);
+
+ return iRetVal;
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // WcsChr
+ //
+ // Find the first occurrence of the specified character in the string.
+ //////////////////////////////////////////////////////////////////////////
+ wchar_t * wcsChr(wchar_t wcCharacter) const
+ {
+ wchar_t * pwszRetVal = 0;
+
+ // Pre-validation.
+ this->verifySentinal();
+ this->verifyNotNull();
+
+ // Compare the strings.
+ pwszRetVal = ::wcschr(this->m_ptData, wcCharacter);
+
+ return pwszRetVal;
+ }
+
+private:
+ void multiByteToWide(const char* cpszSource)
+ {
+ // Calculate the length of the source.
+ const uint32 cdwSourceLen = cpszSource ? ::strlen( cpszSource ) : 0;
+
+ // Convert the multibyte strings to wide.
+ if( cdwSourceLen > 0 )
+ {
+ this->allocateElements(cdwSourceLen);
+ int32 iRet;
+#ifdef WIN32
+ iRet = ::MultiByteToWideChar(
+ CP_ACP,
+ 0,
+ cpszSource,
+ cdwSourceLen,
+ GetNonConstPtr(),
+ GetLength() );
+#else
+ iRet = ::mbstowcs( this->getNonConstPtr(), cpszSource, cdwSourceLen );
+ // mbstowcs returns -1 on error or the number of
+ // characters without the null terminator, so
+ // we can increase it by 1 for the null or to 0 for
+ // the error condition below
+ if ( 0 != iRet )
+ iRet++;
+#endif
+
+ if( 0 == iRet )
+ {
+ this->freeArray();
+ }
+ }
+ else if( cpszSource != NULL )
+ {
+ // This chunk of code is important. If the source
+ // string is empty, return an empty string, not
+ // a NULL pointer!
+ this->allocateElements(0);
+ }
+
+ // Verify array.
+ this->verifySentinal();
+ }
+
+private:
+ TWCharAdapter(const TWCharAdapter & crRhs);
+ TWCharAdapter & operator=(const TWCharAdapter & crRhs);
+};
+
+}
+
+#endif // _TWCharAdapter_H_
--- /dev/null
+/*
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef PLATFORM_DEFINES_H
+#define PLATFORM_DEFINES_H
+
+#ifdef WIN32
+ #ifdef _WIN64
+ typedef uint64 SUBSYS_INTPTR;
+ const SUBSYS_INTPTR SUBSYS_INTPTR_INVALID = 0xffffffffffffffff;
+ #else
+ typedef uint32 SUBSYS_INTPTR;
+ const SUBSYS_INTPTR SUBSYS_INTPTR_INVALID = 0xffffffff;
+ #endif
+#else
+
+#ifdef __x86_64__
+typedef uint64_t SUBSYS_INTPTR;
+const SUBSYS_INTPTR SUBSYS_INTPTR_INVALID = 0xffffffffffffffff;
+#else
+typedef uint32_t SUBSYS_INTPTR;
+const SUBSYS_INTPTR SUBSYS_INTPTR_INVALID = 0xffffffff;
+#endif
+const uint32 DLL_PROCESS_ATTACH = 1;
+const uint32 DLL_PROCESS_DETACH = 2;
+
+#ifndef TRUE
+#define TRUE true
+#endif
+
+#ifndef FALSE
+#define FALSE false
+#endif
+
+#endif
+
+#endif // #ifndef PLATFORM_DEFINES_H
--- /dev/null
+/*
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef PLATFORMERRORS_H_
+#define PLATFORMERRORS_H_
+
+#ifdef WIN32
+
+#include <winerror.h>
+
+#else
+
+const HRESULT S_OK = 0;
+const HRESULT S_FALSE = 1;
+const HRESULT E_FAIL = 0x80004005;
+const HRESULT E_NOTIMPL = 0x80004001;
+const HRESULT E_INVALIDARG = 0x80070057;
+const HRESULT E_OUTOFMEMORY = 0x8007000E;
+const HRESULT E_POINTER = 0x80004003;
+const HRESULT E_NOINTERFACE = 0x80004002;
+const HRESULT E_UNEXPECTED = 0x8000FFFF;
+
+const HRESULT OLE_E_BLANK = 0x80040007;
+
+const HRESULT ERROR_SUCCESS = 0;
+const HRESULT NO_ERROR = 0;
+const HRESULT ERROR_INVALID_FUNCTION= 1;
+const HRESULT ERROR_FILE_NOT_FOUND = 2;
+const HRESULT ERROR_PATH_NOT_FOUND = 3;
+const HRESULT ERROR_ACCESS_DENIED = 5;
+const HRESULT ERROR_INVALID_HANDLE = 6;
+const HRESULT ERROR_INVALID_DATA = 13;
+const HRESULT ERROR_OUTOFMEMORY = 14;
+const HRESULT ERROR_NOT_SAME_DEVICE= 17;
+const HRESULT ERROR_HANDLE_EOF = 38;
+const HRESULT ERROR_NOT_SUPPORTED = 50;
+const HRESULT ERROR_FILE_EXISTS= 80;
+const HRESULT ERROR_INVALID_PARAMETER = 87;
+const HRESULT ERROR_BUFFER_OVERFLOW = 111;
+const HRESULT ERROR_CALL_NOT_IMPLEMENTED = 120;
+const HRESULT ERROR_INSUFFICIENT_BUFFER = 122;
+const HRESULT ERROR_BAD_PATHNAME = 161;
+const HRESULT ERROR_BUSY = 170;
+const HRESULT ERROR_ALREADY_EXISTS= 183;
+const HRESULT ERROR_NOT_FOUND = 1168;
+const HRESULT ERROR_MORE_DATA = 234;
+const HRESULT ERROR_NO_MORE_ITEMS = 259;
+const HRESULT ERROR_SHUTDOWN_IN_PROGRESS = 1115;
+const HRESULT ERROR_INVALID_INDEX = 1413;
+const HRESULT ERROR_INTERNAL_ERROR = 1359;
+const HRESULT ERROR_DISCARDED = 157;
+const HRESULT ERROR_CLASS_ALREADY_EXISTS = 1410;
+const HRESULT ERROR_CLASS_DOES_NOT_EXIST = 1411;
+const HRESULT ERROR_TIMEOUT = 1460;
+const HRESULT ERROR_UNSUPPORTED_TYPE = 1630;
+const HRESULT ERROR_TAG_NOT_FOUND =2012;
+const HRESULT ERROR_TAG_NOT_PRESENT =2013;
+const HRESULT ERROR_DUPLICATE_TAG =2014;
+const HRESULT ERROR_INVALID_STATE = 5023;
+const HRESULT ERROR_FILE_READ_ONLY = 6009;
+const HRESULT ERROR_REVISION_MISMATCH = 1306;
+const HRESULT ERROR_ALREADY_INITIALIZED = 1247;
+
+const HRESULT DISP_E_BADVARTYPE = 0x80020008;
+const HRESULT DISP_E_OVERFLOW = 0x8002000A;
+const HRESULT DISP_E_TYPEMISMATCH = 0x80020005;
+const HRESULT DISP_E_EXCEPTION = 0x80020009;
+const HRESULT DISP_E_PARAMNOTOPTIONAL = 0x8002000F;
+const HRESULT DISP_E_UNKNOWNNAME = 0x80020006;
+const HRESULT DISP_E_BADPARAMCOUNT = 0x8002000E;
+const HRESULT NTE_BAD_LEN = 0x80090004;
+
+const HRESULT RPC_S_OK = 0;
+const HRESULT RPC_S_OUT_OF_MEMORY = ERROR_OUTOFMEMORY;
+const HRESULT RPC_S_INVALID_STRING_BINDING = 1700;
+const HRESULT RPC_S_WRONG_KIND_OF_BINDING = 1701;
+const HRESULT RPC_S_INVALID_BINDING = 1702;
+const HRESULT RPC_S_PROTSEQ_NOT_SUPPORTED = 1703;
+const HRESULT RPC_S_INVALID_RPC_PROTSEQ = 1704;
+const HRESULT RPC_S_INVALID_STRING_UUID = 1705;
+const HRESULT RPC_S_INVALID_ENDPOINT_FORMAT = 1706;
+const HRESULT RPC_S_INVALID_NET_ADDR = 1707;
+const HRESULT RPC_S_NO_ENDPOINT_FOUND = 1708;
+const HRESULT RPC_S_INVALID_TIMEOUT = 1709;
+const HRESULT RPC_S_OBJECT_NOT_FOUND = 1710;
+const HRESULT RPC_S_ALREADY_REGISTERED = 1711;
+const HRESULT RPC_S_TYPE_ALREADY_REGISTERED = 1712;
+const HRESULT RPC_S_ALREADY_LISTENING = 1713;
+const HRESULT RPC_S_NO_PROTSEQS_REGISTERED = 1714;
+const HRESULT RPC_S_NOT_LISTENING = 1715;
+const HRESULT RPC_S_UNKNOWN_MGR_TYPE = 1716;
+const HRESULT RPC_S_UNKNOWN_IF = 1717;
+const HRESULT RPC_S_NO_BINDINGS = 1718;
+const HRESULT RPC_S_NO_PROTSEQS = 1719;
+const HRESULT RPC_S_CANT_CREATE_ENDPOINT = 1720;
+const HRESULT RPC_S_OUT_OF_RESOURCES = 1721;
+const HRESULT RPC_S_SERVER_UNAVAILABLE = 1722;
+const HRESULT RPC_S_SERVER_TOO_BUSY = 1723;
+const HRESULT RPC_S_INVALID_NETWORK_OPTIONS = 1724;
+const HRESULT RPC_S_NO_CALL_ACTIVE = 1725;
+const HRESULT RPC_S_CALL_FAILED = 1726;
+const HRESULT RPC_S_CALL_FAILED_DNE = 1727;
+const HRESULT RPC_S_PROTOCOL_ERROR = 1728;
+const HRESULT RPC_S_UNSUPPORTED_TRANS_SYN = 1730;
+const HRESULT RPC_S_UNSUPPORTED_TYPE = 1732;
+const HRESULT RPC_S_INVALID_TAG = 1733;
+const HRESULT RPC_S_INVALID_BOUND = 1734;
+const HRESULT RPC_S_NO_ENTRY_NAME = 1735;
+const HRESULT RPC_S_INVALID_NAME_SYNTAX = 1736;
+const HRESULT RPC_S_UNSUPPORTED_NAME_SYNTAX = 1737;
+const HRESULT RPC_S_UUID_NO_ADDRESS = 1739;
+const HRESULT RPC_S_DUPLICATE_ENDPOINT = 1740;
+const HRESULT RPC_S_UNKNOWN_AUTHN_TYPE = 1741;
+const HRESULT RPC_S_MAX_CALLS_TOO_SMALL = 1742;
+const HRESULT RPC_S_STRING_TOO_LONG = 1743;
+const HRESULT RPC_S_PROTSEQ_NOT_FOUND = 1744;
+const HRESULT RPC_S_PROCNUM_OUT_OF_RANGE = 1745;
+const HRESULT RPC_S_BINDING_HAS_NO_AUTH = 1746;
+const HRESULT RPC_S_UNKNOWN_AUTHN_SERVICE = 1747;
+const HRESULT RPC_S_UNKNOWN_AUTHN_LEVEL = 1748;
+const HRESULT RPC_S_INVALID_AUTH_IDENTITY = 1749;
+const HRESULT RPC_S_UNKNOWN_AUTHZ_SERVICE = 1750;
+
+const HRESULT FACILITY_WINDOWS = 8;
+const HRESULT FACILITY_URT = 19;
+const HRESULT FACILITY_STORAGE = 3;
+const HRESULT FACILITY_SSPI = 9;
+const HRESULT FACILITY_SCARD = 16;
+const HRESULT FACILITY_SETUPAPI = 15;
+const HRESULT FACILITY_SECURITY = 9;
+const HRESULT FACILITY_RPC = 1;
+const HRESULT FACILITY_WIN32 = 7;
+const HRESULT FACILITY_CONTROL = 10;
+const HRESULT FACILITY_NULL = 0;
+const HRESULT FACILITY_MSMQ = 14;
+const HRESULT FACILITY_MEDIASERVER = 13;
+const HRESULT FACILITY_INTERNET = 12;
+const HRESULT FACILITY_ITF = 4;
+const HRESULT FACILITY_DISPATCH = 2;
+const HRESULT FACILITY_COMPLUS = 17;
+const HRESULT FACILITY_CERT = 11;
+const HRESULT FACILITY_ACS = 20;
+const HRESULT FACILITY_AAF = 18;
+
+const HRESULT SEVERITY_SUCCESS = 0;
+const HRESULT SEVERITY_ERROR = 1;
+
+#define HRESULT_FROM_WIN32(x) ((HRESULT)(x) <= 0 ? ((HRESULT)(x)) : ((HRESULT) (((x) & 0x0000FFFF) | (FACILITY_WIN32 << 16) | 0x80000000)))
+
+#define SUCCEEDED(status) ((HRESULT)(status) >= 0)
+#define FAILED(status) ((HRESULT)(status) < 0)
+#define IS_ERROR(status) ((uint32)(status) >> 31 == SEVERITY_ERROR)
+
+#define HRESULT_CODE(hr) ((hr) & 0xFFFF)
+#define SCODE_CODE(sc) ((sc) & 0xFFFF)
+
+#define HRESULT_FACILITY(hr) (((hr) >> 16) & 0x1FFF)
+#define SCODE_FACILITY(sc) (((sc) >> 16) & 0x1FFF)
+
+#define HRESULT_SEVERITY(hr) (((hr) >> 31) & 0x1
+#define SCODE_SEVERITY(sc) (((sc) >> 31) & 0x1)
+
+#define MAKE_HRESULT(sev,fac,code) \
+ ((HRESULT) (((uint32)(sev)<<31) | ((uint32)(fac)<<16) | ((uint32)(code))) )
+#define MAKE_SCODE(sev,fac,code) \
+ ((HRESULT) (((uint32)(sev)<<31) | ((uint32)(fac)<<16) | ((uint32)(code))) )
+
+#endif
+
+#endif /* PLATFORMERRORS_H_ */
--- /dev/null
+/*
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef PLATFORM_IID_H
+#define PLATFORM_IID_H
+
+#ifndef WIN32
+
+ #include <string>
+ #include <memory.h>
+
+ struct GUID
+ {
+ // this must match the Windows GUID structure
+ uint32 Data1; // 4 bytes
+ uint16 Data2; // 2 bytes
+ uint16 Data3; // 2 bytes
+ byte Data4[8]; // 8 bytes
+ };
+
+ typedef GUID IID, UUID;
+
+ inline bool IsEqualGUID(const GUID& rguid1, const GUID& rguid2)
+ {
+ return (!::memcmp(&rguid1,&rguid2,sizeof(GUID)));
+ }
+
+ #define IsEqualIID(rguid1,rguid2) IsEqualGUID(rguid1,rguid2)
+ #define IsEqualUUID(rguid1,rguid2) IsEqualGUID(rguid1,rguid2)
+
+ extern HRESULT UuidCreate(UUID* uuid);
+
+#endif
+
+namespace BasePlatform {
+BASEPLATFORM_LINKAGE std::string UuidToString(const UUID& uuid);
+BASEPLATFORM_LINKAGE HRESULT UuidFromString(const char* strGuid, UUID& uuid);
+
+// This mutex is used to guard the construction of the IIDs in the IIDOF macro
+extern BASEPLATFORM_LINKAGE GMutex gs_BaseIIDInitMutex;
+}
+
+#define CAF_DECL_UUID(iid) \
+public: \
+static const IID & IIDOF() \
+{ \
+ static IID ms_oIID; \
+ static bool m_bIsSet; \
+ g_mutex_lock(&BasePlatform::gs_BaseIIDInitMutex); \
+ if ( !m_bIsSet ) \
+ { \
+ BasePlatform::UuidFromString( iid , ms_oIID ); \
+ m_bIsSet = true; \
+ } \
+ g_mutex_unlock(&BasePlatform::gs_BaseIIDInitMutex); \
+ return ms_oIID; \
+}
+
+#define CAF_IIDOF(type_name) type_name::IIDOF()
+
+#endif
--- /dev/null
+/*
+ * Author: mdonahue
+ * Created: Jan 13, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef PLATFORMSTRINGFUNC_H_
+#define PLATFORMSTRINGFUNC_H_
+
+namespace BasePlatform {
+
+ //extern std::wstring A2W(const std::string& str);
+ //extern std::string W2A(const std::wstring& str);
+}
+
+#endif /* PLATFORMSTRINGFUNC_H_ */
--- /dev/null
+/*
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef PLATFORM_TYPES_H
+#define PLATFORM_TYPES_H
+
+#ifdef WIN32
+
+#include <wtypes.h>
+
+#else
+// #include <sys/timeb.h>
+#include <sys/types.h>
+#include <wchar.h>
+#if defined (__linux__) || defined (__APPLE__)
+ #include <stdint.h>
+#endif
+
+//typedef int32 RPC_STATUS;
+
+#define __declspec(value)
+#define __stdcall
+#define __cdecl
+#define APIENTRY
+
+#define FAR
+
+typedef void * HINSTANCE;
+typedef void * HMODULE;
+typedef void * HANDLE;
+typedef void * LPVOID;
+typedef bool BOOL;
+typedef uint8_t byte;
+typedef int32_t HRESULT;
+#endif
+
+#endif // PLATFORM_TYPES_H
--- /dev/null
+/*
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+#ifndef _TCafObject_h
+#define _TCafObject_h
+
+template <class Base>
+class TCafObject : public Base {
+public:
+ TCafObject() : _refCnt(0) {}
+
+public: // ICafObect Implementations
+ void AddRef() {
+ g_atomic_int_inc(&_refCnt);
+ }
+
+ void Release() {
+ if (g_atomic_int_dec_and_test(&_refCnt)) {
+ delete this;
+ }
+ }
+
+ void QueryInterface(const IID&, void**) {
+ throw std::runtime_error("QueryInterface not supported");
+ }
+
+private:
+ gint _refCnt;
+
+private:
+ TCafObject(const TCafObject&);
+ TCafObject& operator=(const TCafObject&);
+};
+
+#endif
--- /dev/null
+/*
+ * Created: May 25, 2004
+ *
+ * Copyright (c) 2004-2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef TCAFQIOBJECT_H_
+#define TCAFQIOBJECT_H_
+
+template <class Base>
+class TCafQIObject : public TCafObject<Base>
+{
+public:
+ TCafQIObject ()
+ {
+ }
+
+ virtual ~TCafQIObject ()
+ {
+ }
+
+public:
+ virtual void QueryInterface( const IID& criid, void** ppv )
+ {
+ Base::_InternalQueryInterface( criid, ppv );
+ }
+};
+
+////////////////////////////////////////////////////////////////////////
+//
+// QI map
+//
+////////////////////////////////////////////////////////////////////////
+#define CAF_BEGIN_QI() \
+protected: \
+ void _InternalQueryInterface (const IID &criid, void **ppv) \
+ { \
+ try \
+ { \
+ if (ppv) \
+ { \
+ *ppv = NULL; \
+ bool bUseFirstInterface = (::IsEqualGUID(criid, CAF_IIDOF(::ICafObject)) != 0); \
+ if (0);
+
+#define CAF_QI_ENTRY(Interface) \
+ else if (bUseFirstInterface || ::IsEqualGUID(criid, CAF_IIDOF(Interface))) \
+ *ppv = static_cast<Interface *>(this);
+
+#define CAF_QI_ENTRY2(Interface, IntermediateInterface) \
+ else if (bUseFirstInterface || ::IsEqualGUID(criid, CAF_IIDOF(Interface))) \
+ *ppv = static_cast<Interface *>(static_cast<IntermediateInterface *>(this));
+
+#define CAF_END_QI() \
+ if (*ppv) \
+ reinterpret_cast<ICafObject *>(this)->AddRef(); \
+ } \
+ } \
+ catch (...) \
+ { \
+ } \
+ }
+
+////////////////////////////////////////////////////////////////////////
+//
+// Object Id - required for ISerializableObject
+//
+////////////////////////////////////////////////////////////////////////
+#define CAF_MAKE_OBJECT_ID(Factory, Class) \
+ (std::string(Factory) + std::string(":") + std::string( #Class ))
+
+#define CAF_DECLARE_OBJECT_ID(Class, Factory) \
+ public: \
+ virtual std::string GetObjectId () const \
+ { \
+ return CAF_MAKE_OBJECT_ID(Factory, Class); \
+ }
+
+// Declare a smart pointer to a class that supports QI after the class has been declared
+#define CAF_DECLARE_SMART_QI_POINTER(ClassName) \
+ typedef TCafSmartPtr<ClassName, TCafQIObject<ClassName> > SmartPtr##ClassName; \
+ typedef TCafSmartPtr<const ClassName, TCafQIObject<ClassName> > ConstPtr##ClassName
+
+// Forward declare a smart pointer to a class that supports QI
+#define CAF_DECLARE_CLASS_AND_IMPQI_POINTER(ClassName) \
+ class ClassName; \
+ CAF_DECLARE_SMART_QI_POINTER(ClassName)
+
+#endif /* TCAFQIOBJECT_H_ */
--- /dev/null
+/*
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef _TCafSmartPtr_H
+#define _TCafSmartPtr_H
+
+#ifdef WIN32
+// Disable C4800 - performance warning forcing value to 'true' or 'false'
+#pragma warning(disable: 4800)
+#endif
+
+// Forward declarations for Subsystem calls
+#ifndef SUBSYSTEMBASE_LINKAGE
+#ifdef WIN32
+#ifdef FRAMEWORK_BUILD
+#define SUBSYSTEMBASE_LINKAGE __declspec(dllexport)
+#else
+#define SUBSYSTEMBASE_LINKAGE __declspec(dllimport)
+#endif
+#else
+#define SUBSYSTEMBASE_LINKAGE
+#endif
+#endif
+
+namespace Caf {
+extern "C" void SUBSYSTEMBASE_LINKAGE CreateObject(const char* cszObjectId, const IID& criid, void** ppv);
+//extern "C" void SUBSYSTEMBASE_LINKAGE CreateQIObject(const char* cszFactoryId, const char* cszClassName, const IID& criid, void** ppv);
+}
+
+/**
+ * @brief Template to wrap any interface or class and provide lifetime management.
+ * <p>
+ * Lifetime is managed through reference counting with counts stored in the object
+ * itself. The reference methods are AddRef() and Release(). When the reference
+ * count reaches zero the object will delete itself.
+ * <p>
+ * Template instantiation:<br>
+ * <i>Cl</i> is used for accessing the class. It may or may not be derived from
+ * #ICafObject.<br>
+ * <i>CreateCl</i> is used for creating the class and reference counting. It must
+ * support the #ICafObject interface.
+ */
+// CreateCl is used for creation and reference counting and must support the
+// ICafObject interface. Cl is used for accessing the class.
+template<class Cl, class CreateCl = Cl>
+class TCafSmartPtr {
+public:
+ typedef Cl class_type;
+ typedef CreateCl create_type;
+
+private:
+ typedef TCafSmartPtr<Cl, CreateCl> SameSmartType;
+
+public:
+ // constructors/destructors
+
+ // default constructor
+ TCafSmartPtr(void) :
+ m_pCl(0) {
+ }
+
+ // homogeneous raw constructor
+ TCafSmartPtr(Cl *rhs) {
+ m_pCl = rhs;
+ if (m_pCreateCl)
+ m_pCreateCl->AddRef();
+ }
+
+ // derived class smart constructor
+ template<class Derived, class CreateDerived>
+ TCafSmartPtr(const TCafSmartPtr<Derived, CreateDerived> &rhs) {
+ m_pCl = rhs.GetNonAddRefedInterface();
+ if (m_pCreateCl)
+ m_pCreateCl->AddRef();
+ }
+
+ // homogeneous smart constructor
+ TCafSmartPtr(const SameSmartType& rhs) {
+ m_pCl = rhs.m_pCl;
+ if (m_pCreateCl)
+ m_pCreateCl->AddRef();
+ }
+
+ // don't allow construction from bool
+ explicit TCafSmartPtr(const bool &rb) {
+ int32 CantConstructSmartPointerFromBool[0];
+ }
+
+ // destructor
+ ~TCafSmartPtr(void) {
+ if (m_pCreateCl)
+ m_pCreateCl->Release();
+ }
+
+public:
+ // assignment operators
+
+ // homogeneous raw assignment
+ SameSmartType &operator=(Cl *rhs) {
+ Attach(rhs);
+ return *this;
+ }
+
+ // derived class smart assignment
+ template<class Derived, class CreateDerived>
+ SameSmartType &operator=(const TCafSmartPtr<Derived, CreateDerived> &rhs) {
+ Attach(rhs.GetNonAddRefedInterface());
+ return *this;
+ }
+
+ // homogeneous smart assignment
+ SameSmartType &operator=(const SameSmartType &rhs) {
+ Attach(rhs.m_pCl);
+ return *this;
+ }
+
+ // don't allow assignment from bool
+ void operator=(bool &rb) {
+ int32 CantAssignSmartPointerFromBool[0];
+ }
+
+private:
+
+ // This helper class is used to ensure that the old smart object gets
+ // released in a safe manner. It is not safe to touch 'this' in any way
+ // whatsoever after releasing the old smart object because the release
+ // could set off a chain of destruction that results in this smart pointer
+ // being destroyed. Note that this includes the exception macros which
+ // reference the automatically-defined class name member variable.
+ class CSafeAutoRelease {
+ public:
+ CSafeAutoRelease(CreateCl *pOldCreateCl) :
+ m_pOldCreateCl(pOldCreateCl) {
+ }
+ ~CSafeAutoRelease() {
+ if (m_pOldCreateCl)
+ m_pOldCreateCl->Release();
+ }
+ CreateCl *m_pOldCreateCl;
+ };
+
+public:
+ /**
+ * @brief Retrieve an interface from a ICafObject pointer and assign the result to self
+ * @param piObj the object to be queried
+ * @param cbIsRequired if <b>true</b> then the operation must succeed else an
+ * exception will be thrown. If <b>false</b> then the self value will be NULL
+ * if the operation fails.
+ */
+ void QueryInterface(ICafObject *piObj, const bool cbIsRequired = true) {
+ CSafeAutoRelease oAutoRelease(m_pCreateCl);
+
+ m_pCreateCl = NULL;
+ if (piObj)
+ piObj->QueryInterface(GetIID(), reinterpret_cast<void **>(&m_pCreateCl));
+ if (cbIsRequired && !m_pCreateCl)
+ throw std::bad_cast();
+ }
+
+ /**
+ * @brief Retrieve an interface from another smart pointer and assign the result to self
+ * @param rhs the object to be queried
+ * @param cbIsRequired if <b>true</b> then the operation must succeed else an
+ * exception will be thrown. If <b>false</b> then the self value will be NULL
+ * if the operation fails.
+ */
+ template<class QI, class CreateQI>
+ void QueryInterface(const TCafSmartPtr<QI, CreateQI> &rhs, const bool cbIsRequired = true) {
+ CSafeAutoRelease oAutoRelease(m_pCreateCl);
+
+ m_pCreateCl = NULL;
+ if (rhs)
+ rhs.QueryInterface(GetIID(), reinterpret_cast<void **>(&m_pCreateCl));
+ if (cbIsRequired && !m_pCreateCl)
+ throw std::bad_cast();
+ }
+
+ // This function is provided so that the delegation can go through m_pCreateCl
+ // rather than m_pCl. This way, if this is a smart pointer to a class that
+ // derives from multiple interfaces the compiler will not get confused about
+ // which QueryInterface function to use.
+ void QueryInterface(const IID &criid, void **ppv) const {
+ *ppv = NULL;
+ m_pCreateCl->QueryInterface(criid, ppv);
+ }
+
+ /**
+ * @brief Return the UUID of the object
+ * @return the UUID
+ */
+ static const IID& GetIID() {
+ // Compiler bug workaround (see comments before COpaqueTemplate)
+ // return TEcmSmartPtr_GetIID(static_cast<COpaqueTemplate<Cl> *>(NULL));
+ return CAF_IIDOF(Cl);
+ }
+
+public:
+ // comparison operators
+
+ bool operator==(const Cl *rhs) const {
+ return m_pCl == rhs;
+ }
+
+ template<class Derived, class CreateDerived>
+ bool operator==(const TCafSmartPtr<Derived, CreateDerived> &rhs) const {
+ return m_pCl == rhs.GetNonAddRefedInterface();
+ }
+
+ bool operator!=(const Cl *rhs) const {
+ return m_pCl != rhs;
+ }
+
+ template<class Derived, class CreateDerived>
+ bool operator!=(const TCafSmartPtr<Derived, CreateDerived> &rhs) const {
+ return m_pCl != rhs.GetNonAddRefedInterface();
+ }
+
+ bool operator<(const SameSmartType &rhs) const {
+ return (m_pCl < rhs.m_pCl);
+ }
+
+public:
+ // conversion
+
+ // This takes the place of operator bool.
+ // It turns out that the presence of operator bool
+ // causes the compiler to "get lost" when compiling
+ // comparison operations such as if( spcPtr1 == spcPtr2)...
+ //
+ // This conversion operator will satisfy the compiler when
+ // compiling comparison operations.
+ class PseudoBool {
+ };
+ operator PseudoBool *() const {
+ return (PseudoBool *) m_pCl;
+ }
+
+public:
+ // instance creation
+ /**
+ * @brief Create an instance of the CreateCl object
+ * <p>
+ * The object will have an initial reference count of 1.
+ */
+ void CreateInstance() {
+ CSafeAutoRelease oAutoRelease(m_pCreateCl);
+
+ ////////////////////////////////////////////////////////////////////////
+ //
+ // This code is used to verify that it is safe to use a union of Cl
+ // and CreateCl. An error indicates that it is *not* safe in which
+ // case the smart pointer cannot be used as defined. To solve this
+ // problem, eliminate the second template parameter from the smart
+ // pointer definition which will force Cl and CreateCl to be the
+ // same, e.g.:
+ //
+ // typedef TCafSmartPtr<TCafObject<Class> > SmartPtrClass;
+ //
+ ////////////////////////////////////////////////////////////////////////
+ Cl *pCl = static_cast<Cl *>(reinterpret_cast<CreateCl *>(0x4));
+ if (pCl != reinterpret_cast<Cl *>(0x4))
+ throw std::logic_error("Illegal use of TCafSmartPtr<> (See comments in TCafSmartPtr.h)");
+ m_pCreateCl = new CreateCl;
+ if (!m_pCreateCl)
+ throw std::bad_alloc();
+ m_pCreateCl->AddRef();
+ }
+
+ /**
+ * @brief Create an instance of a subsystem object
+ * <p>
+ * Objects exposed as subsystems (#Caf::TCafSubSystemSmartCl) are identified
+ * by a string. The Cl and CreateCl template arguments would both be
+ * set to an interface on the subsystem object of interest.
+ * <p>
+ * The object will have an initial reference count of 1.
+ */
+ void CreateInstance(const char* cszObjectId) {
+ CSafeAutoRelease oAutoRelease(m_pCreateCl);
+ Caf::CreateObject(cszObjectId, GetIID(), reinterpret_cast<void **>(&m_pCreateCl));
+ }
+
+// void CreateInstance (const char *cszFactoryId, const char *cszClassName)
+// {
+// CSafeAutoRelease oAutoRelease(m_pCreateCl);
+// Caf::CreateQIObject(cszFactoryId, cszClassName, GetIID(), reinterpret_cast<void **>(&m_pCreateCl));
+// }
+
+public:
+ // operations
+ Cl *GetAddRefedInterface() const {
+ if (!m_pCl)
+ throw std::runtime_error("TCafSmartPtr: m_pCl is NULL");
+ if (m_pCreateCl)
+ m_pCreateCl->AddRef();
+ return m_pCl;
+ }
+
+ Cl *GetNonAddRefedInterface() const {
+ return m_pCl;
+ }
+
+ Cl **GetReleasedInterfaceReference(void) {
+ CSafeAutoRelease oAutoRelease(m_pCreateCl);
+ m_pCreateCl = NULL;
+ return &m_pCreateCl;
+ }
+
+ Cl **GetNonReleasedInterfaceReference(void) {
+ return &m_pCreateCl;
+ }
+
+ void **GetAsPPVArg(void) {
+ return (void**) GetReleasedInterfaceReference();
+ }
+
+ bool IsNull() const {
+ return m_pCl == 0;
+ }
+
+ // the arrow operator simply returns the pointer
+ Cl *operator->() const {
+ if (!m_pCl)
+ throw std::runtime_error("TCafSmartPtr: m_pCl is NULL");
+ return m_pCl;
+ }
+
+ Cl &operator*() const {
+ if (!m_pCl)
+ throw std::runtime_error("TCafSmartPtr: m_pCl is NULL");
+ return *m_pCl;
+ }
+
+private:
+ // m_pCreateCl is used for reference counting; m_pCl is used for object access.
+ union {
+ Cl *m_pCl;
+ CreateCl *m_pCreateCl;
+ };
+
+private:
+ // homogeneous raw attachment
+ void Attach(Cl* rhs) {
+ CSafeAutoRelease oAutoRelease(m_pCreateCl);
+ m_pCl = rhs;
+ if (m_pCreateCl)
+ m_pCreateCl->AddRef();
+ }
+};
+
+// These template functions will give you a reference to the
+// underlying object wraped in a smart class
+template<class Cl, class CreateCl>
+const Cl& ToObj(const TCafSmartPtr<Cl, CreateCl>& spcT) {
+ return *(spcT.GetNonAddRefedInterface());
+}
+
+template<class Cl, class CreateCl>
+Cl& ToNonConstObj(const TCafSmartPtr<Cl, CreateCl>& spcT) {
+ return *(spcT.GetNonAddRefedInterface());
+}
+
+////////////////////////////////////////////////////////////////////////
+//
+// Declaration Macros
+//
+////////////////////////////////////////////////////////////////////////
+
+// Declare a smart pointer after the class has been declared
+#define CAF_DECLARE_SMART_POINTER(ClassName) \
+ typedef TCafSmartPtr<ClassName, TCafObject<ClassName> > SmartPtr##ClassName; \
+// typedef TCafSmartPtr<const ClassName, TCafObject<ClassName> > ConstPtr##ClassName
+
+// Forward declare a class smart pointer
+#define CAF_DECLARE_CLASS_AND_SMART_POINTER(ClassName) \
+ class ClassName; \
+ CAF_DECLARE_SMART_POINTER(ClassName)
+
+// Forward declare a struct smart pointer
+#define CAF_DECLARE_STRUCT_AND_SMART_POINTER(StructName) \
+ struct StructName; \
+ CAF_DECLARE_SMART_POINTER(StructName)
+
+// Helper macro - do not use directly
+#define CAF_DECLARE_SMART_INTERFACE_HELPER(InterfaceName) \
+ typedef TCafSmartPtr<InterfaceName> SmartPtr##InterfaceName; \
+// typedef TCafSmartPtr<const InterfaceName, InterfaceName> ConstPtr##InterfaceName
+
+// Declare a smart pointer to an interface in the interface header file
+#define CAF_DECLARE_SMART_INTERFACE_POINTER(InterfaceName) \
+ CAF_DECLARE_SMART_INTERFACE_HELPER(InterfaceName)
+
+// Forward declare a smart interface pointer
+#define CAF_FORWARD_DECLARE_SMART_INTERFACE(InterfaceName) \
+ struct InterfaceName; \
+ CAF_DECLARE_SMART_INTERFACE_HELPER(InterfaceName)
+
+#endif // #ifndef _TCafSmartPtr_H
--- /dev/null
+/*
+ * Created on: Jul 23, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef TCAFSTACKOBJECT_H_
+#define TCAFSTACKOBJECT_H_
+
+namespace Caf {
+
+template <class Base>
+class TCafStackObject : public Base {
+public:
+ TCafStackObject() {}
+ virtual ~TCafStackObject() {}
+
+private:
+ virtual void AddRef() {
+ throw std::runtime_error("TCafStackObj::AddRef not supported");
+ }
+
+ virtual void Release() {
+ throw std::runtime_error("TCafStackObj::Release not supported");
+ }
+
+ virtual void QueryInterface(const IID&, void** ppv) {
+ throw std::runtime_error("TCafStackObj::QueryInterface not supported");
+ }
+};
+
+}
+#endif /* TCAFSTACKOBJECT_H_ */
--- /dev/null
+/*
+ * Author: mdonahue
+ * Created: Jan 20, 2011
+ *
+ * Copyright (c) 2011 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CMARKUPPARSER_H_
+#define CMARKUPPARSER_H_
+
+#include <list>
+#include <map>
+
+namespace Caf {
+
+/*
+ * Wrapper around glib GMarkupParser to store results in std containers
+ */
+namespace MarkupParser {
+
+// attribute name, value
+typedef std::pair<std::string, std::string> Attribute;
+typedef std::list<Attribute> Attributes;
+
+struct AttributeName : public std::binary_function<Attribute, std::string, bool> {
+ bool operator()(const Attribute& attr, const std::string& name) const {
+ return (attr.first.compare(name) == 0);
+ }
+};
+
+struct Element;
+CAF_DECLARE_SMART_POINTER(Element);
+struct Element {
+ Element() {}
+ std::string name;
+ std::string value;
+ Attributes attributes;
+ typedef std::list<SmartPtrElement> Children;
+ Children children;
+
+ CAF_CM_DECLARE_NOCOPY(Element);
+};
+
+struct ElementName : public std::binary_function<SmartPtrElement, std::string, bool> {
+ bool operator()(const SmartPtrElement& element, const std::string& name) const {
+ return (element->name.compare(name) == 0);
+ }
+};
+
+SmartPtrElement MARKUPPARSER_LINKAGE parseString(const std::string& xml);
+
+SmartPtrElement MARKUPPARSER_LINKAGE parseFile(const std::string& file);
+
+typedef Element::Children::iterator ChildIterator;
+typedef Attributes::iterator AttributeIterator;
+
+ChildIterator MARKUPPARSER_LINKAGE findChild(SmartPtrElement& element, const std::string& name);
+
+AttributeIterator MARKUPPARSER_LINKAGE findAttribute(Attributes& attributes, const std::string& name);
+
+std::string MARKUPPARSER_LINKAGE getAttributeValue(SmartPtrElement& element, const std::string& name);
+
+}}
+
+#endif /* CMARKUPPARSER_H_ */
--- /dev/null
+/*
+ * Author: mdonahue
+ * Created: Dec 3, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef _CXmlElement_h
+#define _CXmlElement_h
+
+
+#include "Integration/IDocument.h"
+#include "Xml/MarkupParser/CMarkupParser.h"
+
+namespace Caf {
+
+CAF_DECLARE_CLASS_AND_SMART_POINTER(CXmlElement);
+
+class XMLUTILS_LINKAGE CXmlElement {
+public:
+ typedef std::map<std::string, std::string> CAttributeCollection;
+ typedef std::multimap<std::string, SmartPtrCXmlElement> CElementCollection;
+ typedef std::deque<SmartPtrCXmlElement> COrderedElementCollection;
+ CAF_DECLARE_SMART_POINTER(CAttributeCollection);
+ CAF_DECLARE_SMART_POINTER(CElementCollection);
+ CAF_DECLARE_SMART_POINTER(COrderedElementCollection);
+
+public:
+ CXmlElement();
+ virtual ~CXmlElement();
+
+public:
+ void initialize(const MarkupParser::SmartPtrElement& element, const std::string& path);
+ MarkupParser::SmartPtrElement getInternalElement();
+
+public: // Read operations
+
+ std::string findRequiredAttribute(const std::string& name) const;
+ std::string findOptionalAttribute(const std::string& name) const;
+ SmartPtrCXmlElement findRequiredChild(const std::string& name) const;
+ SmartPtrCXmlElement findOptionalChild(const std::string& name) const;
+ SmartPtrCElementCollection findRequiredChildren(const std::string& name) const;
+ SmartPtrCElementCollection findOptionalChildren(const std::string& name) const;
+ SmartPtrCAttributeCollection getAllAttributes() const;
+ SmartPtrCElementCollection getAllChildren() const;
+ SmartPtrCOrderedElementCollection getAllChildrenInOrder() const;
+ std::string getName() const;
+ std::string getValue() const;
+ std::string getCDataValue() const;
+ std::string getPath() const;
+
+public: // Write operations
+ void addAttribute(const std::string& name, const std::string& value);
+ void removeAttribute(const std::string& name);
+ void setAttribute(const std::string& name, const std::string& value);
+ SmartPtrCXmlElement createAndAddElement(const std::string& name);
+ void addChild(const SmartPtrCXmlElement& xmlElement);
+ void removeChild(const std::string& name);
+ void setValue(const std::string& value);
+ void setCDataValue(const std::string& value);
+ void appendValue(const std::string& value);
+ void saveToFile(const std::string& filename) const;
+ std::string saveToString() const;
+ std::string saveToStringRaw() const;
+
+private:
+ static const std::string CDATA_BEG;
+ static const std::string CDATA_END;
+
+private:
+ bool _isInitialized;
+ mutable MarkupParser::SmartPtrElement _element;
+ std::string _path;
+
+private:
+ static void saveToString(const MarkupParser::SmartPtrElement& element, std::string& xml);
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CXmlElement);
+};
+
+CAF_DECLARE_SMART_POINTER(CXmlElement);
+
+}
+
+#endif /* _CXmlElement_h */
#define TEDGELISTGRAPH_H_
#include <set>
+#include "Exception/CCafException.h"
#include <map>
#include <list>
#include <algorithm>
*/
#include "stdafx.h"
+#include "Common/IAppConfig.h"
#include "AppConfigUtils.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Common/CConfigParams.h"
+#include "Common/CLoggingUtils.h"
+#include "Exception/CCafException.h"
+#include "Common/IAppConfigWrite.h"
+#include "Common/IAppConfig.h"
+#include "Common/IConfigParams.h"
#include "CAppConfig.h"
using namespace Caf;
#ifndef CAPPCONFIG_H_
#define CAPPCONFIG_H_
+#include "Common/IConfigParams.h"
+
+#include "Common/CConfigParams.h"
+
+#include "Common/IAppConfig.h"
+#include "Common/IAppConfigWrite.h"
+
namespace Caf {
CAF_DECLARE_CLASS_AND_SMART_POINTER(CAppConfig);
*/
#include "stdafx.h"
-#include "CApplicationContext.h"
+
+#include "Common/IAppContext.h"
+#include "IBean.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Common/CApplicationContext.h"
+#include "Exception/CCafException.h"
+#include "Common/IAppConfig.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CAutoCondition.h"
+
+#include "Common/CAutoMutex.h"
+#include "Common/CAutoCondition.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Common/CFileLock.h"
+#include "Exception/CCafException.h"
#include "CAutoFileUnlock.h"
using namespace Caf;
#ifndef CAutoFileUnlock_h_
#define CAutoFileUnlock_h_
+
+#include "Common/CFileLock.h"
+
namespace Caf {
class COMMONAGGREGATOR_LINKAGE CAutoFileUnlock
*/
#include "stdafx.h"
-#include "CAutoMutex.h"
+#include "Common/CAutoMutex.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Common/CAutoMutex.h"
+#include "Common/CAutoRecMutex.h"
#include "CAutoMutexLockUnlock.h"
using namespace Caf;
#ifndef CAUTOMUTEXLOCKUNLOCK_H_
#define CAUTOMUTEXLOCKUNLOCK_H_
+
+#include "Common/CAutoMutex.h"
+#include "Common/CAutoRecMutex.h"
+
namespace Caf {
class COMMONAGGREGATOR_LINKAGE CAutoMutexLockUnlock {
*/
#include "stdafx.h"
+
+#include "Common/CAutoMutex.h"
+#include "Common/CAutoRecMutex.h"
#include "CAutoMutexUnlockLock.h"
using namespace Caf;
#ifndef CAUTOMUTEXUNLOCKLOCK_H_
#define CAUTOMUTEXUNLOCKLOCK_H_
+
+#include "Common/CAutoMutex.h"
+#include "Common/CAutoRecMutex.h"
+
namespace Caf {
class COMMONAGGREGATOR_LINKAGE CAutoMutexUnlockLock {
*/
#include "stdafx.h"
-#include "CAutoRecMutex.h"
+#include "Common/CAutoRecMutex.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CCafRegex.h"
+#include "Common/CCafRegex.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CCmdLineOptions.h"
+#include "Common/CCmdLineOptions.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CConfigParams.h"
+#include "Common/CConfigParams.h"
+#include "Exception/CCafException.h"
+#include "Common/IConfigParams.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CConfigParamsChain.h"
+#include "Common/CConfigParamsChain.h"
+#include "Exception/CCafException.h"
+#include "Common/IConfigParams.h"
using namespace Caf;
*/
#include "stdafx.h"
+#include "Common/CLoggingUtils.h"
#include "CDaemonUtils.h"
#include <syslog.h>
*/
#include "stdafx.h"
+#include "Exception/CCafException.h"
#ifndef WIN32
#include <sys/time.h>
#endif
*/
#include "stdafx.h"
-#include "CFileLock.h"
+#include "Common/CFileLock.h"
+#include "Exception/CCafException.h"
#include <fcntl.h>
#include <sys/file.h>
#include <errno.h>
*/
#include "stdafx.h"
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Exception/CCafException.h"
#include "CFileSystemUtils.h"
#include "../Collections/Iterators/IteratorsInc.h"
#ifdef WIN32
#ifndef CFILESYSTEMUTILS_H_
#define CFILESYSTEMUTILS_H_
-#include "../Memory/DynamicArray/DynamicArrayInc.h"
+
+
+#include "Memory/DynamicArray/DynamicArrayInc.h"
namespace Caf {
*/
#include "stdafx.h"
-#include "CIniFile.h"
+
+#include "Common/CCafRegex.h"
+#include "Common/CIniFile.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CLoggingSetter.h"
+#include "Common/CLoggingSetter.h"
+#include "Common/CLoggingUtils.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CLoggingUtils.h"
+#include "Common/CLoggingUtils.h"
+#include "Exception/CCafException.h"
#include <iostream>
#include <fstream>
*/
#include "stdafx.h"
-#include "CManagedThreadPool.h"
+#include "Common/CManagedThreadPool.h"
+#include "Exception/CCafException.h"
namespace Caf {
*/
#include "stdafx.h"
+
+#include "Doc/PersistenceDoc/CCertCollectionDoc.h"
+#include "Doc/PersistenceDoc/CCertPathCollectionDoc.h"
+#include "Doc/PersistenceDoc/CLocalSecurityDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolCollectionDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolDoc.h"
+#include "Doc/PersistenceDoc/CRemoteSecurityCollectionDoc.h"
+#include "Doc/PersistenceDoc/CRemoteSecurityDoc.h"
#include "CPersistenceUtils.h"
using namespace Caf;
#include <DocContracts.h>
+#include "Doc/PersistenceDoc/CLocalSecurityDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolCollectionDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolDoc.h"
+#include "Doc/PersistenceDoc/CRemoteSecurityCollectionDoc.h"
+
namespace Caf {
class COMMONAGGREGATOR_LINKAGE CPersistenceUtils {
*/
#include "stdafx.h"
+#include "Exception/CCafException.h"
#include "CProcessUtils.h"
#ifndef WIN32
#include <sys/time.h>
*/
#include "stdafx.h"
+#include "Exception/CCafException.h"
+#include "Common/IAppConfig.h"
#include "CStringUtils.h"
#include <algorithm>
*/
#include "stdafx.h"
-#include "CThreadPool.h"
+
+#include "Common/CManagedThreadPool.h"
+#include "Common/CThreadPool.h"
+#include "Exception/CCafException.h"
bool _isInitialized;
GThreadPool *_threadPool;
*/
#include "stdafx.h"
-#include "CThreadSignal.h"
+
+#include "Common/CAutoMutex.h"
+#include "Exception/CCafException.h"
+#include "Common/CThreadSignal.h"
using namespace Caf;
*/
#include "stdafx.h"
+#include "Exception/CCafException.h"
#include "CThreadUtils.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CVariant.h"
+#include "Exception/CCafException.h"
+#include "Common/CVariant.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#ifdef WIN32
+#include "Common/CWinScm.h"
+#endif
+
#include "CafInitialize.h"
using namespace Caf;
#include <glib/gstdio.h>
#include <IBean.h>
-#include <IVariant.h>
#include <CommonGlobals.h>
#include "../Logging/LoggingLink.h"
#include "../Collections/Graphs/GraphsInc.h"
#include "CTimeUnit.h"
-#include "CFileLock.h"
#include "CAutoFileUnlock.h"
-#include "CCafRegex.h"
#include "CStringUtils.h"
#include "CFileSystemUtils.h"
#include "CProcessUtils.h"
#include "CDateTimeUtils.h"
#include "CThreadUtils.h"
-#include "IConfigParams.h"
-#include "CConfigParams.h"
-#include "CConfigParamsChain.h"
-#include "IAppConfig.h"
-#include "IAppConfigWrite.h"
-#include "IAppContext.h"
#include "AppConfigUtils.h"
-#include "CAutoMutex.h"
-#include "CAutoRecMutex.h"
-#include "CAutoCondition.h"
#include "CAutoMutexLockUnlock.h"
#include "CAutoMutexLockUnlockRaw.h"
#include "CAutoMutexUnlockLock.h"
-#include "CThreadSignal.h"
-#include "CCmdLineOptions.h"
#include "CafInitialize.h"
#include "CHexCodec.h"
#include "UriUtils.h"
-#include "CLoggingUtils.h"
-#include "CLoggingSetter.h"
-#include "CThreadPool.h"
-#include "CManagedThreadPool.h"
#include "TBlockingCell.h"
-#include "CIniFile.h"
-#include "CVariant.h"
+#include "Common/CVariant.h"
#include "CEnvironmentUtils.h"
#include "CPersistenceUtils.h"
-#include "IWork.h"
#if defined(__linux__) || defined(__APPLE__)
#include "CDaemonUtils.h"
#elif WIN32
-#include "CWinScm.h"
-#include "CWinServiceState.h"
-#include "CWinServiceInstance.h"
#endif
#include "../SubSystemBase/SubSystemBaseLink.h"
#include "../Xml/MarkupParser/MarkupParserLink.h"
#include "../Xml/XmlUtils/XmlUtilsLink.h"
-#include "../Memory/DynamicArray/DynamicArrayInc.h"
#endif /* COMMONAGGREGATORLINK_H_ */
#ifndef TBLOCKINGCELL_H_
#define TBLOCKINGCELL_H_
+#include "Common/CThreadSignal.h"
+#include "Exception/CCafException.h"
+
namespace Caf {
/**
*/
#include "stdafx.h"
+#include "Exception/CCafException.h"
#include "UriUtils.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAddInCollectionDoc.h"
#include "Doc/CafCoreTypesDoc/CAddInsDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/CafCoreTypesDoc/CInlineAttachmentDoc.h"
#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAuthnAuthzDoc.h"
#include "Doc/CafCoreTypesDoc/CAuthnAuthzCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CClassFiltersDoc.h"
+#include "Doc/CafCoreTypesDoc/CFullyQualifiedClassGroupDoc.h"
#include "Doc/CafCoreTypesDoc/CClassSpecifierDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CInlineAttachmentDoc.h"
#include "Doc/CafCoreTypesDoc/CInlineAttachmentCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CLoggingLevelElemDoc.h"
#include "Doc/CafCoreTypesDoc/CLoggingLevelCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
#include "Doc/CafCoreTypesDoc/CLoggingLevelElemDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
#include "Doc/CafCoreTypesDoc/COperationDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CRequestInstanceParameterDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestParameterDoc.h"
#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CPropertyDoc.h"
#include "Doc/CafCoreTypesDoc/CPropertyCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
#include "Doc/CafCoreTypesDoc/CPropertyDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CProtocolDoc.h"
#include "Doc/CafCoreTypesDoc/CProtocolCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAddInsDoc.h"
+#include "Doc/CafCoreTypesDoc/CLoggingLevelCollectionDoc.h"
#include "Doc/CafCoreTypesDoc/CRequestConfigDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAuthnAuthzCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CPropertyCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CProtocolCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestConfigDoc.h"
#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
#include "Doc/CafCoreTypesDoc/CRequestParameterDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CPropertyCollectionDoc.h"
#include "Doc/CafCoreTypesDoc/CStatisticsDoc.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
-#include "Doc/CafCoreTypesDoc/CafCoreTypesDocInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
+
+#include "Doc/CafInstallRequestDoc/CPackageDefnDoc.h"
#include "Doc/CafInstallRequestDoc/CFullPackageElemDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafInstallRequestDoc/CGetInventoryJobDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallProviderJobDoc.h"
+#include "Doc/CafInstallRequestDoc/CUninstallProviderJobDoc.h"
#include "Doc/CafInstallRequestDoc/CInstallBatchDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentNameCollectionDoc.h"
#include "Doc/CafInstallRequestDoc/CInstallPackageSpecDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+#include "Doc/CafInstallRequestDoc/CafInstallRequestDocTypes.h"
+
+#include "Doc/CafInstallRequestDoc/CFullPackageElemDoc.h"
#include "Doc/CafInstallRequestDoc/CInstallProviderJobDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafInstallRequestDoc/CMinPackageElemDoc.h"
#include "Doc/CafInstallRequestDoc/CInstallProviderSpecDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallBatchDoc.h"
#include "Doc/CafInstallRequestDoc/CInstallRequestDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentNameCollectionDoc.h"
#include "Doc/CafInstallRequestDoc/CPackageDefnDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+#include "Doc/CafInstallRequestDoc/CafInstallRequestDocTypes.h"
#include "Doc/CafInstallRequestDoc/CUninstallProviderJobDoc.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
-#include "Doc/CafInstallRequestDoc/CafInstallRequestDocInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Doc/DiagTypesDoc/CDiagBatchDoc.h"
#include "Doc/DiagRequestDoc/CDiagRequestDoc.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
-#include "Doc/DiagRequestDoc/DiagRequestDocInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
+
+#include "Doc/DiagTypesDoc/CDiagCollectInstancesDoc.h"
+#include "Doc/DiagTypesDoc/CDiagDeleteValueCollectionDoc.h"
+#include "Doc/DiagTypesDoc/CDiagSetValueCollectionDoc.h"
#include "Doc/DiagTypesDoc/CDiagBatchDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/DiagTypesDoc/CDiagDeleteValueDoc.h"
#include "Doc/DiagTypesDoc/CDiagDeleteValueCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/DiagTypesDoc/CDiagSetValueDoc.h"
#include "Doc/DiagTypesDoc/CDiagSetValueCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CPropertyDoc.h"
#include "Doc/DiagTypesDoc/CDiagSetValueDoc.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
-#include "Doc/DiagTypesDoc/DiagTypesDocInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtBatchDoc.h"
#include "Doc/MgmtRequestDoc/CMgmtRequestDoc.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
-#include "Doc/MgmtRequestDoc/MgmtRequestDocInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
+
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectSchemaDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationCollectionDoc.h"
#include "Doc/MgmtTypesDoc/CMgmtBatchDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesDoc.h"
#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CClassSpecifierDoc.h"
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationDoc.h"
#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CClassSpecifierDoc.h"
+#include "Doc/CafCoreTypesDoc/COperationDoc.h"
#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationDoc.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
-#include "Doc/MgmtTypesDoc/MgmtTypesDocInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
+
+#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtBatchDoc.h"
#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtBatchCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/MgmtTypesDoc/CMgmtBatchDoc.h"
+#include "Doc/MultiPmeMgmtRequestDoc/CPmeIdCollectionDoc.h"
#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtBatchDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtBatchCollectionDoc.h"
#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtRequestDoc.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
-#include "Doc/MultiPmeMgmtRequestDoc/MultiPmeMgmtRequestDocInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CPropertyCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CProtocolCollectionDoc.h"
#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
-#include "Doc/PayloadEnvelopeDoc/PayloadEnvelopeDocInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
+
+#include "Doc/PersistenceDoc/CLocalSecurityDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolCollectionDoc.h"
+#include "Doc/PersistenceDoc/CRemoteSecurityCollectionDoc.h"
#include "Doc/PersistenceDoc/CPersistenceDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/PersistenceDoc/CPersistenceProtocolDoc.h"
#include "Doc/PersistenceDoc/CPersistenceProtocolCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/PersistenceDoc/CCertCollectionDoc.h"
+#include "Doc/PersistenceDoc/CCertPathCollectionDoc.h"
#include "Doc/PersistenceDoc/CPersistenceProtocolDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/PersistenceDoc/CRemoteSecurityDoc.h"
#include "Doc/PersistenceDoc/CRemoteSecurityCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/PersistenceDoc/CCertCollectionDoc.h"
+#include "Doc/PersistenceDoc/CCertPathCollectionDoc.h"
#include "Doc/PersistenceDoc/CRemoteSecurityDoc.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
-#include "Doc/PersistenceDoc/PersistenceDocInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CFullyQualifiedClassGroupDoc.h"
#include "Doc/ProviderInfraDoc/CClassCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/ProviderInfraDoc/CClassCollectionDoc.h"
#include "Doc/ProviderInfraDoc/CSchemaSummaryDoc.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
-#include "Doc/ProviderInfraDoc/ProviderInfraDocInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
+
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationCollectionDoc.h"
#include "Doc/ProviderRequestDoc/CProviderBatchDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesDoc.h"
#include "Doc/ProviderRequestDoc/CProviderCollectInstancesCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
#include "Doc/ProviderRequestDoc/CProviderCollectInstancesDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/ProviderRequestDoc/CProviderRequestHeaderDoc.h"
#include "Doc/ProviderRequestDoc/CProviderCollectSchemaRequestDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationDoc.h"
#include "Doc/ProviderRequestDoc/CProviderInvokeOperationCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/COperationDoc.h"
#include "Doc/ProviderRequestDoc/CProviderInvokeOperationDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CLoggingLevelCollectionDoc.h"
#include "Doc/ProviderRequestDoc/CProviderRequestConfigDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderBatchDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestHeaderDoc.h"
#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CPropertyCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestConfigDoc.h"
#include "Doc/ProviderRequestDoc/CProviderRequestHeaderDoc.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
-#include "Doc/ProviderRequestDoc/ProviderRequestDocInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
+
+#include "Doc/ProviderResultsDoc/CDefinitionObjectCollectionDoc.h"
+#include "Doc/ProviderResultsDoc/CRequestIdentifierDoc.h"
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
#include "Doc/ProviderResultsDoc/CCdifDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
#include "Doc/ProviderResultsDoc/CRequestIdentifierDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassDoc.h"
+#include "Doc/SchemaTypesDoc/CLogicalRelationshipDoc.h"
+#include "Doc/SchemaTypesDoc/CPhysicalRelationshipDoc.h"
#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
-#include "Doc/ProviderResultsDoc/ProviderResultsDocInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
+
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
#include "Doc/ResponseDoc/CErrorResponseDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/ResponseDoc/CEventKeyDoc.h"
#include "Doc/ResponseDoc/CEventKeyCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
#include "Doc/ResponseDoc/CEventManifestDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/ResponseDoc/CManifestDoc.h"
#include "Doc/ResponseDoc/CManifestCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentNameCollectionDoc.h"
#include "Doc/ResponseDoc/CManifestDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CStatisticsDoc.h"
+#include "Doc/ResponseDoc/CEventKeyCollectionDoc.h"
+#include "Doc/ResponseDoc/CEventManifestDoc.h"
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
#include "Doc/ResponseDoc/CProviderEventResponseDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CStatisticsDoc.h"
+#include "Doc/ResponseDoc/CManifestDoc.h"
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
#include "Doc/ResponseDoc/CProviderResponseDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CStatisticsDoc.h"
+#include "Doc/ResponseDoc/CManifestCollectionDoc.h"
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
#include "Doc/ResponseDoc/CResponseDoc.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
-#include "Doc/ResponseDoc/ResponseDocInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
+
+#include "Doc/SchemaTypesDoc/CCollectMethodDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodDoc.h"
#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/SchemaTypesDoc/CActionClassInstanceDoc.h"
#include "Doc/SchemaTypesDoc/CActionClassInstanceCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/SchemaTypesDoc/CInstanceOperationCollectionDoc.h"
#include "Doc/SchemaTypesDoc/CActionClassInstanceDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/SchemaTypesDoc/CClassIdentifierDoc.h"
#include "Doc/SchemaTypesDoc/CClassInstancePropertyDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
#include "Doc/SchemaTypesDoc/CClassPropertyDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/SchemaTypesDoc/CClassIdentifierDoc.h"
+#include "Doc/SchemaTypesDoc/CInstanceParameterDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodParameterDoc.h"
#include "Doc/SchemaTypesDoc/CCollectMethodDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/SchemaTypesDoc/CClassInstancePropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CClassPropertyDoc.h"
#include "Doc/SchemaTypesDoc/CDataClassDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
#include "Doc/SchemaTypesDoc/CDataClassInstanceCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/SchemaTypesDoc/CCmdlMetadataDoc.h"
+#include "Doc/SchemaTypesDoc/CCmdlUnionDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassPropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassSubInstanceDoc.h"
#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/SchemaTypesDoc/CCmdlMetadataDoc.h"
#include "Doc/SchemaTypesDoc/CDataClassPropertyDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/SchemaTypesDoc/CCmdlMetadataDoc.h"
+#include "Doc/SchemaTypesDoc/CCmdlUnionDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassPropertyDoc.h"
#include "Doc/SchemaTypesDoc/CDataClassSubInstanceDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/SchemaTypesDoc/CInstanceOperationDoc.h"
#include "Doc/SchemaTypesDoc/CInstanceOperationCollectionDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+
+#include "Doc/SchemaTypesDoc/CClassFieldDoc.h"
#include "Doc/SchemaTypesDoc/CJoinTypeDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+
+#include "Doc/SchemaTypesDoc/CClassCardinalityDoc.h"
+#include "Doc/SchemaTypesDoc/CJoinTypeDoc.h"
#include "Doc/SchemaTypesDoc/CLogicalRelationshipDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/SchemaTypesDoc/CClassIdentifierDoc.h"
+#include "Doc/SchemaTypesDoc/CInstanceParameterDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodParameterDoc.h"
#include "Doc/SchemaTypesDoc/CMethodDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
#include "Doc/SchemaTypesDoc/CMethodParameterDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+
+#include "Doc/SchemaTypesDoc/CClassCardinalityDoc.h"
#include "Doc/SchemaTypesDoc/CPhysicalRelationshipDoc.h"
using namespace Caf;
*/
#include "stdafx.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+
+#include "Doc/SchemaTypesDoc/CClassCardinalityDoc.h"
#include "Doc/SchemaTypesDoc/CRelationshipDoc.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
-#include "Doc/SchemaTypesDoc/SchemaTypesDocInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Exception/CCafException.h"
#include "AttachmentUtils.h"
using namespace Caf;
#ifndef AttachmentUtils_h_
#define AttachmentUtils_h_
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+
namespace Caf {
class DOCUTILS_LINKAGE AttachmentUtils {
public:
*/
#include "stdafx.h"
+
+#include "Doc/SchemaTypesDoc/CCmdlMetadataDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassPropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassSubInstanceDoc.h"
+#include "Integration/IDocument.h"
+#include "Xml/XmlUtils/CXmlElement.h"
#include "DefnObjectConverter.h"
using namespace Caf;
#ifndef DefnObjectConverter_h_
#define DefnObjectConverter_h_
+
+#include "Doc/SchemaTypesDoc/CCmdlMetadataDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassSubInstanceDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
namespace Caf {
class DOCUTILS_LINKAGE DefnObjectConverter {
public:
#ifndef DocUtils_Inc_h_
#define DocUtils_Inc_h_
-#include "EnumConvertersXml.h"
+#include "Doc/DocUtils/EnumConvertersXml.h"
#include "DefnObjectConverter.h"
#include "ParameterUtils.h"
#include "AttachmentUtils.h"
#endif
#endif
-#include "EnumConvertersXml.h"
+#include "Doc/DocUtils/EnumConvertersXml.h"
#include "DefnObjectConverter.h"
#include "ParameterUtils.h"
#include "AttachmentUtils.h"
*/
#include "stdafx.h"
-#include "EnumConvertersXml.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+#include "Doc/CafInstallRequestDoc/CafInstallRequestDocTypes.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestInstanceParameterDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestParameterDoc.h"
+#include "Exception/CCafException.h"
#include "ParameterUtils.h"
using namespace Caf;
#ifndef ParameterUtils_h_
#define ParameterUtils_h_
+
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestInstanceParameterDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestParameterDoc.h"
+
namespace Caf {
class DOCUTILS_LINKAGE ParameterUtils {
public:
*/
#include "stdafx.h"
-#include "AddInCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAddInCollectionDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/AddInCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "AddInsXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAddInCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAddInsDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/AddInsXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/AddInCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "AttachmentCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/AttachmentCollectionXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/AttachmentXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "AttachmentNameCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentNameCollectionDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/AttachmentNameCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "AttachmentXml.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/AttachmentXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "AuthnAuthzCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAuthnAuthzCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAuthnAuthzDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/AuthnAuthzCollectionXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/AuthnAuthzXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "AuthnAuthzXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAuthnAuthzDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/AuthnAuthzXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ClassFiltersXml.h"
+
+#include "Doc/CafCoreTypesDoc/CClassFiltersDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/ClassFiltersXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ClassSpecifierXml.h"
+
+#include "Doc/CafCoreTypesDoc/CClassFiltersDoc.h"
+#include "Doc/CafCoreTypesDoc/CClassSpecifierDoc.h"
+#include "Doc/CafCoreTypesDoc/CFullyQualifiedClassGroupDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/ClassSpecifierXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/FullyQualifiedClassGroupXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/ClassFiltersXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "FullyQualifiedClassGroupXml.h"
+
+#include "Doc/CafCoreTypesDoc/CFullyQualifiedClassGroupDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/FullyQualifiedClassGroupXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "LoggingLevelCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CLoggingLevelCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CLoggingLevelElemDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/LoggingLevelCollectionXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/LoggingLevelElemXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "LoggingLevelElemXml.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+
+#include "Doc/CafCoreTypesDoc/CLoggingLevelElemDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/LoggingLevelElemXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "OperationXml.h"
+
+#include "Doc/CafCoreTypesDoc/COperationDoc.h"
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/OperationXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/ParameterCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ParameterCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestInstanceParameterDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestParameterDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/ParameterCollectionXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/RequestParameterXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/RequestInstanceParameterXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/RequestParameterXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "PropertyCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CPropertyCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CPropertyDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/PropertyCollectionXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/PropertyXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "PropertyXml.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+
+#include "Doc/CafCoreTypesDoc/CPropertyDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/PropertyXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ProtocolCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CProtocolCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CProtocolDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/ProtocolCollectionXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/ProtocolXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ProtocolXml.h"
+
+#include "Doc/CafCoreTypesDoc/CProtocolDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/ProtocolXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "RequestConfigXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAddInsDoc.h"
+#include "Doc/CafCoreTypesDoc/CLoggingLevelCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestConfigDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/RequestConfigXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/AddInsXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/LoggingLevelCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "RequestHeaderXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAuthnAuthzCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CPropertyCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CProtocolCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestConfigDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/RequestHeaderXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/RequestConfigXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/AuthnAuthzCollectionXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/ProtocolCollectionXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/PropertyCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "RequestInstanceParameterXml.h"
+
+#include "Doc/CafCoreTypesDoc/CRequestInstanceParameterDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/RequestInstanceParameterXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "RequestParameterXml.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+
+#include "Doc/CafCoreTypesDoc/CRequestParameterDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/RequestParameterXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "RequestXml.h"
+
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/RequestXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "StatisticsXml.h"
+
+#include "Doc/CafCoreTypesDoc/CPropertyCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CStatisticsDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafCoreTypesXml/StatisticsXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/PropertyCollectionXml.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
+
#include <DocContracts.h>
#include <DocUtils.h>
-#include "CafCoreTypesXmlInc.h"
#endif /* STDAFX_H_ */
#include "stdafx.h"
+#include "Doc/DocXml/CafCoreTypesXml/RequestXml.h"
+#include "Doc/DocXml/CafInstallRequestXml/InstallPackageSpecXml.h"
+#include "Doc/DocXml/CafInstallRequestXml/InstallProviderSpecXml.h"
+#include "Doc/DocXml/CafInstallRequestXml/InstallRequestXml.h"
+
+#include "Doc/CafInstallRequestDoc/CInstallPackageSpecDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallProviderSpecDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallRequestDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlRoots.h"
+
using namespace Caf;
std::string XmlRoots::saveInstallRequestToString(
*/
#include "stdafx.h"
-#include "FullPackageElemXml.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/PackageDefnXml.h"
+
+#include "Doc/CafInstallRequestDoc/CFullPackageElemDoc.h"
+#include "Doc/CafInstallRequestDoc/CPackageDefnDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafInstallRequestXml/FullPackageElemXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "GetInventoryJobXml.h"
+
+#include "Doc/CafInstallRequestDoc/CGetInventoryJobDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafInstallRequestXml/GetInventoryJobXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "InstallBatchXml.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/GetInventoryJobXml.h"
+#include "Doc/DocXml/CafInstallRequestXml/InstallProviderJobXml.h"
+#include "Doc/DocXml/CafInstallRequestXml/UninstallProviderJobXml.h"
+
+#include "Doc/CafInstallRequestDoc/CGetInventoryJobDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallBatchDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallProviderJobDoc.h"
+#include "Doc/CafInstallRequestDoc/CUninstallProviderJobDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafInstallRequestXml/InstallBatchXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "InstallPackageSpecXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/AttachmentCollectionXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/AttachmentNameCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentNameCollectionDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallPackageSpecDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafInstallRequestXml/InstallPackageSpecXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "InstallProviderJobXml.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+#include "Doc/DocXml/CafInstallRequestXml/FullPackageElemXml.h"
+#include "Doc/CafInstallRequestDoc/CafInstallRequestDocTypes.h"
+
+#include "Doc/CafInstallRequestDoc/CFullPackageElemDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallProviderJobDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafInstallRequestXml/InstallProviderJobXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "InstallProviderSpecXml.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/MinPackageElemXml.h"
+
+#include "Doc/CafInstallRequestDoc/CInstallProviderSpecDoc.h"
+#include "Doc/CafInstallRequestDoc/CMinPackageElemDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafInstallRequestXml/InstallProviderSpecXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "InstallRequestXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/AttachmentCollectionXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/RequestHeaderXml.h"
+#include "Doc/DocXml/CafInstallRequestXml/InstallBatchXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallBatchDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallRequestDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafInstallRequestXml/InstallRequestXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "MinPackageElemXml.h"
+
+#include "Doc/CafInstallRequestDoc/CMinPackageElemDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafInstallRequestXml/MinPackageElemXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "PackageDefnXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/AttachmentNameCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentNameCollectionDoc.h"
+#include "Doc/CafInstallRequestDoc/CPackageDefnDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafInstallRequestXml/PackageDefnXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "UninstallProviderJobXml.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+#include "Doc/CafInstallRequestDoc/CafInstallRequestDocTypes.h"
+
+#include "Doc/CafInstallRequestDoc/CUninstallProviderJobDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/CafInstallRequestXml/UninstallProviderJobXml.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
+
#include <DocContracts.h>
#include <DocUtils.h>
-#include "CafInstallRequestXmlInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
-#include "DiagRequestXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/RequestHeaderXml.h"
+#include "Doc/DocXml/DiagTypesXml/DiagBatchXml.h"
+
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Doc/DiagRequestDoc/CDiagRequestDoc.h"
+#include "Doc/DiagTypesDoc/CDiagBatchDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/DiagRequestXml/DiagRequestXml.h"
using namespace Caf;
#include "stdafx.h"
+#include "Doc/DocXml/CafCoreTypesXml/RequestXml.h"
+#include "Doc/DocXml/DiagRequestXml/DiagRequestXml.h"
+
+#include "Doc/DiagRequestDoc/CDiagRequestDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/DiagRequestXml/DiagRequestXmlRoots.h"
+
using namespace Caf;
std::string XmlRoots::saveDiagRequestToString(
#endif
#include <CommonDefines.h>
+
#include <DocContracts.h>
#include <DocUtils.h>
-#include "DiagRequestXmlInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
-#include "DiagBatchXml.h"
+
+#include "Doc/DocXml/DiagTypesXml/DiagCollectInstancesXml.h"
+#include "Doc/DocXml/DiagTypesXml/DiagDeleteValueCollectionXml.h"
+#include "Doc/DocXml/DiagTypesXml/DiagSetValueCollectionXml.h"
+
+#include "Doc/DiagTypesDoc/CDiagBatchDoc.h"
+#include "Doc/DiagTypesDoc/CDiagCollectInstancesDoc.h"
+#include "Doc/DiagTypesDoc/CDiagDeleteValueCollectionDoc.h"
+#include "Doc/DiagTypesDoc/CDiagSetValueCollectionDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/DiagTypesXml/DiagBatchXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "DiagCollectInstancesXml.h"
+
+#include "Doc/DiagTypesDoc/CDiagCollectInstancesDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/DiagTypesXml/DiagCollectInstancesXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "DiagDeleteValueCollectionXml.h"
+
+#include "Doc/DocXml/DiagTypesXml/DiagDeleteValueXml.h"
+
+#include "Doc/DiagTypesDoc/CDiagDeleteValueCollectionDoc.h"
+#include "Doc/DiagTypesDoc/CDiagDeleteValueDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/DiagTypesXml/DiagDeleteValueCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "DiagDeleteValueXml.h"
+
+#include "Doc/DiagTypesDoc/CDiagDeleteValueDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/DiagTypesXml/DiagDeleteValueXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "DiagSetValueCollectionXml.h"
+
+#include "Doc/DocXml/DiagTypesXml/DiagSetValueXml.h"
+
+#include "Doc/DiagTypesDoc/CDiagSetValueCollectionDoc.h"
+#include "Doc/DiagTypesDoc/CDiagSetValueDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/DiagTypesXml/DiagSetValueCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "DiagSetValueXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/PropertyXml.h"
+
+#include "Doc/CafCoreTypesDoc/CPropertyDoc.h"
+#include "Doc/DiagTypesDoc/CDiagSetValueDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/DiagTypesXml/DiagSetValueXml.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
+
#include <DocContracts.h>
#include <DocUtils.h>
-#include "DiagTypesXmlInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
-#include "MgmtRequestXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/AttachmentCollectionXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/RequestHeaderXml.h"
+#include "Doc/DocXml/MgmtTypesXml/MgmtBatchXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Doc/MgmtRequestDoc/CMgmtRequestDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtBatchDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/MgmtRequestXml/MgmtRequestXml.h"
using namespace Caf;
#include "stdafx.h"
+#include "Doc/DocXml/CafCoreTypesXml/RequestXml.h"
+#include "Doc/DocXml/MgmtRequestXml/MgmtRequestXml.h"
+
+#include "Doc/MgmtRequestDoc/CMgmtRequestDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/MgmtRequestXml/MgmtRequestXmlRoots.h"
+
using namespace Caf;
std::string XmlRoots::saveMgmtRequestToString(
#endif
#include <CommonDefines.h>
+
#include <DocContracts.h>
#include <DocUtils.h>
-#include "MgmtRequestXmlInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
-#include "MgmtBatchXml.h"
+
+#include "Doc/DocXml/MgmtTypesXml/MgmtCollectInstancesCollectionXml.h"
+#include "Doc/DocXml/MgmtTypesXml/MgmtCollectSchemaXml.h"
+#include "Doc/DocXml/MgmtTypesXml/MgmtInvokeOperationCollectionXml.h"
+
+#include "Doc/MgmtTypesDoc/CMgmtBatchDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectSchemaDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationCollectionDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/MgmtTypesXml/MgmtBatchXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "MgmtCollectInstancesCollectionXml.h"
+
+#include "Doc/DocXml/MgmtTypesXml/MgmtCollectInstancesXml.h"
+
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/MgmtTypesXml/MgmtCollectInstancesCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "MgmtCollectInstancesXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/ClassSpecifierXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/ParameterCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CClassSpecifierDoc.h"
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/MgmtTypesXml/MgmtCollectInstancesXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "MgmtCollectSchemaXml.h"
+
+#include "Doc/MgmtTypesDoc/CMgmtCollectSchemaDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/MgmtTypesXml/MgmtCollectSchemaXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "MgmtInvokeOperationCollectionXml.h"
+
+#include "Doc/DocXml/MgmtTypesXml/MgmtInvokeOperationXml.h"
+
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/MgmtTypesXml/MgmtInvokeOperationCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "MgmtInvokeOperationXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/ClassSpecifierXml.h"
+
+#include "Doc/CafCoreTypesDoc/CClassSpecifierDoc.h"
+#include "Doc/CafCoreTypesDoc/COperationDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/MgmtTypesXml/MgmtInvokeOperationXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/OperationXml.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
+
#include <DocContracts.h>
#include <DocUtils.h>
-#include "MgmtTypesXmlInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
-#include "MultiPmeMgmtBatchCollectionXml.h"
+
+#include "Doc/DocXml/MultiPmeMgmtRequestXml/MultiPmeMgmtBatchXml.h"
+
+#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtBatchCollectionDoc.h"
+#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtBatchDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/MultiPmeMgmtRequestXml/MultiPmeMgmtBatchCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "MultiPmeMgmtBatchXml.h"
+
+#include "Doc/DocXml/MgmtTypesXml/MgmtBatchXml.h"
+
+#include "Doc/DocXml/MultiPmeMgmtRequestXml/PmeIdCollectionXml.h"
+
+#include "Doc/MgmtTypesDoc/CMgmtBatchDoc.h"
+#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtBatchDoc.h"
+#include "Doc/MultiPmeMgmtRequestDoc/CPmeIdCollectionDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/MultiPmeMgmtRequestXml/MultiPmeMgmtBatchXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "MultiPmeMgmtRequestXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/RequestHeaderXml.h"
+#include "Doc/DocXml/MultiPmeMgmtRequestXml/MultiPmeMgmtBatchCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtBatchCollectionDoc.h"
+#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtRequestDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/MultiPmeMgmtRequestXml/MultiPmeMgmtRequestXml.h"
using namespace Caf;
#include "stdafx.h"
+#include "Doc/DocXml/CafCoreTypesXml/RequestXml.h"
+#include "Doc/DocXml/MultiPmeMgmtRequestXml/MultiPmeMgmtRequestXml.h"
+
+#include "Doc/MultiPmeMgmtRequestDoc/CMultiPmeMgmtRequestDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/MultiPmeMgmtRequestXml/MultiPmeMgmtRequestXmlRoots.h"
+
using namespace Caf;
std::string XmlRoots::saveMultiPmeMgmtRequestToString(
*/
#include "stdafx.h"
-#include "PmeIdCollectionXml.h"
+
+#include "Doc/MultiPmeMgmtRequestDoc/CPmeIdCollectionDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/MultiPmeMgmtRequestXml/PmeIdCollectionXml.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
+
#include <DocContracts.h>
#include <DocUtils.h>
-#include "MultiPmeMgmtRequestXmlInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
-#include "PayloadEnvelopeXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/AttachmentCollectionXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/PropertyCollectionXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/ProtocolCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CPropertyCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CProtocolCollectionDoc.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/PayloadEnvelopeXml/PayloadEnvelopeXml.h"
using namespace Caf;
#include "stdafx.h"
+#include "Doc/DocXml/PayloadEnvelopeXml/PayloadEnvelopeXml.h"
+
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/PayloadEnvelopeXml/PayloadEnvelopeXmlRoots.h"
+
using namespace Caf;
std::string XmlRoots::savePayloadEnvelopeToString(
#endif
#include <CommonDefines.h>
+
#include <DocContracts.h>
#include <DocUtils.h>
-#include "PayloadEnvelopeXmlInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
-#include "CertCollectionXml.h"
+
+#include "Doc/PersistenceDoc/CCertCollectionDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/PersistenceXml/CertCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CertPathCollectionXml.h"
+
+#include "Doc/PersistenceDoc/CCertPathCollectionDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/PersistenceXml/CertPathCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "LocalSecurityXml.h"
+
+#include "Doc/PersistenceDoc/CLocalSecurityDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/PersistenceXml/LocalSecurityXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "PersistenceProtocolCollectionXml.h"
+
+#include "Doc/DocXml/PersistenceXml/PersistenceProtocolXml.h"
+
+#include "Doc/PersistenceDoc/CPersistenceProtocolCollectionDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/PersistenceXml/PersistenceProtocolCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "PersistenceProtocolXml.h"
+
+#include "Doc/DocXml/PersistenceXml/CertCollectionXml.h"
+#include "Doc/DocXml/PersistenceXml/CertPathCollectionXml.h"
+
+#include "Doc/PersistenceDoc/CCertCollectionDoc.h"
+#include "Doc/PersistenceDoc/CCertPathCollectionDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/PersistenceXml/PersistenceProtocolXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "PersistenceXml.h"
+
+#include "Doc/DocXml/PersistenceXml/LocalSecurityXml.h"
+#include "Doc/DocXml/PersistenceXml/PersistenceProtocolCollectionXml.h"
+#include "Doc/DocXml/PersistenceXml/RemoteSecurityCollectionXml.h"
+
+#include "Doc/PersistenceDoc/CLocalSecurityDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolCollectionDoc.h"
+#include "Doc/PersistenceDoc/CRemoteSecurityCollectionDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/PersistenceXml/PersistenceXml.h"
using namespace Caf;
#include "stdafx.h"
+#include "Doc/DocXml/PersistenceXml/PersistenceXml.h"
+
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/PersistenceXml/PersistenceXmlRoots.h"
+
using namespace Caf;
std::string XmlRoots::savePersistenceToString(
*/
#include "stdafx.h"
-#include "RemoteSecurityCollectionXml.h"
+
+#include "Doc/DocXml/PersistenceXml/RemoteSecurityXml.h"
+
+#include "Doc/PersistenceDoc/CRemoteSecurityCollectionDoc.h"
+#include "Doc/PersistenceDoc/CRemoteSecurityDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/PersistenceXml/RemoteSecurityCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "RemoteSecurityXml.h"
+
+#include "Doc/DocXml/PersistenceXml/CertCollectionXml.h"
+#include "Doc/DocXml/PersistenceXml/CertPathCollectionXml.h"
+
+#include "Doc/PersistenceDoc/CCertCollectionDoc.h"
+#include "Doc/PersistenceDoc/CCertPathCollectionDoc.h"
+#include "Doc/PersistenceDoc/CRemoteSecurityDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/PersistenceXml/RemoteSecurityXml.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
+
#include <DocContracts.h>
#include <DocUtils.h>
-#include "PersistenceXmlInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
-#include "ClassCollectionXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/FullyQualifiedClassGroupXml.h"
+
+#include "Doc/CafCoreTypesDoc/CFullyQualifiedClassGroupDoc.h"
+#include "Doc/ProviderInfraDoc/CClassCollectionDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderInfraXml/ClassCollectionXml.h"
using namespace Caf;
#include "stdafx.h"
+#include "Doc/DocXml/ProviderInfraXml/ProviderRegXml.h"
+#include "Doc/DocXml/ProviderInfraXml/SchemaSummaryXml.h"
+
+#include "Doc/ProviderInfraDoc/CProviderRegDoc.h"
+#include "Doc/ProviderInfraDoc/CSchemaSummaryDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderInfraXml/ProviderInfraXmlRoots.h"
+
using namespace Caf;
std::string XmlRoots::saveProviderRegToString(
*/
#include "stdafx.h"
-#include "ProviderRegXml.h"
+
+#include "Doc/ProviderInfraDoc/CProviderRegDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderInfraXml/ProviderRegXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "SchemaSummaryXml.h"
+
+#include "Doc/DocXml/ProviderInfraXml/ClassCollectionXml.h"
+
+#include "Doc/ProviderInfraDoc/CClassCollectionDoc.h"
+#include "Doc/ProviderInfraDoc/CSchemaSummaryDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderInfraXml/SchemaSummaryXml.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
+
#include <DocContracts.h>
#include <DocUtils.h>
-#include "ProviderInfraXmlInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
-#include "ProviderBatchXml.h"
+
+#include "Doc/DocXml/ProviderRequestXml/ProviderCollectInstancesCollectionXml.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderInvokeOperationCollectionXml.h"
+
+#include "Doc/ProviderRequestDoc/CProviderBatchDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationCollectionDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderBatchXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ProviderCollectInstancesCollectionXml.h"
+
+#include "Doc/DocXml/ProviderRequestXml/ProviderCollectInstancesXml.h"
+
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderCollectInstancesCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ProviderCollectInstancesXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/ParameterCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderCollectInstancesXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ProviderCollectSchemaRequestXml.h"
+
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestHeaderXml.h"
+
+#include "Doc/ProviderRequestDoc/CProviderCollectSchemaRequestDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestHeaderDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderCollectSchemaRequestXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ProviderInvokeOperationCollectionXml.h"
+
+#include "Doc/DocXml/ProviderRequestXml/ProviderInvokeOperationXml.h"
+
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderInvokeOperationCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ProviderInvokeOperationXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/OperationXml.h"
+
+#include "Doc/CafCoreTypesDoc/COperationDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderInvokeOperationXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ProviderRequestConfigXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/LoggingLevelCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CLoggingLevelCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestConfigDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestConfigXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ProviderRequestHeaderXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/PropertyCollectionXml.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestConfigXml.h"
+
+#include "Doc/CafCoreTypesDoc/CPropertyCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestConfigDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestHeaderDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestHeaderXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ProviderRequestXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/AttachmentCollectionXml.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderBatchXml.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestHeaderXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderBatchDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestHeaderDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXml.h"
using namespace Caf;
#include "stdafx.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderCollectSchemaRequestXml.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXml.h"
+
+#include "Doc/ProviderRequestDoc/CProviderCollectSchemaRequestDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXmlRoots.h"
+
using namespace Caf;
std::string XmlRoots::saveProviderCollectSchemaRequestToString(
#endif
#include <CommonDefines.h>
+
#include <DocContracts.h>
#include <DocUtils.h>
-#include "ProviderRequestXmlInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
-#include "CdifXml.h"
+
+#include "Doc/DocXml/ProviderResultsXml/DefinitionObjectCollectionXml.h"
+#include "Doc/DocXml/ProviderResultsXml/RequestIdentifierXml.h"
+#include "Doc/DocXml/ProviderResultsXml/SchemaXml.h"
+
+#include "Doc/ProviderResultsDoc/CCdifDoc.h"
+#include "Doc/ProviderResultsDoc/CDefinitionObjectCollectionDoc.h"
+#include "Doc/ProviderResultsDoc/CRequestIdentifierDoc.h"
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderResultsXml/CdifXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "DefinitionObjectCollectionXml.h"
+
+#include "Doc/ProviderResultsDoc/CDefinitionObjectCollectionDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderResultsXml/DefinitionObjectCollectionXml.h"
using namespace Caf;
#include "stdafx.h"
+#include "Doc/DocXml/ProviderResultsXml/CdifXml.h"
+#include "Doc/DocXml/ProviderResultsXml/SchemaXml.h"
+
+#include "Doc/ProviderResultsDoc/CCdifDoc.h"
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderResultsXml/ProviderResultsXmlRoots.h"
+
using namespace Caf;
std::string XmlRoots::saveSchemaToString(
*/
#include "stdafx.h"
-#include "RequestIdentifierXml.h"
+
+#include "Doc/DocXml/SchemaTypesXml/ActionClassXml.h"
+
+#include "Doc/ProviderResultsDoc/CRequestIdentifierDoc.h"
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderResultsXml/RequestIdentifierXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "SchemaXml.h"
+
+#include "Doc/DocXml/SchemaTypesXml/ActionClassXml.h"
+#include "Doc/DocXml/SchemaTypesXml/DataClassXml.h"
+
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassDoc.h"
+#include "Doc/SchemaTypesDoc/CLogicalRelationshipDoc.h"
+#include "Doc/SchemaTypesDoc/CPhysicalRelationshipDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ProviderResultsXml/SchemaXml.h"
+#include "Doc/DocXml/SchemaTypesXml/LogicalRelationshipXml.h"
+#include "Doc/DocXml/SchemaTypesXml/PhysicalRelationshipXml.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
+
#include <DocContracts.h>
#include <DocUtils.h>
-#include "ProviderResultsXmlInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
-#include "ErrorResponseXml.h"
+
+#include "Doc/DocXml/ResponseXml/ResponseHeaderXml.h"
+
+#include "Doc/ResponseDoc/CErrorResponseDoc.h"
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ResponseXml/ErrorResponseXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "EventKeyCollectionXml.h"
+
+#include "Doc/DocXml/ResponseXml/EventKeyXml.h"
+
+#include "Doc/ResponseDoc/CEventKeyCollectionDoc.h"
+#include "Doc/ResponseDoc/CEventKeyDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ResponseXml/EventKeyCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "EventKeyXml.h"
+
+#include "Doc/ResponseDoc/CEventKeyDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ResponseXml/EventKeyXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "EventManifestXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/AttachmentCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/ResponseDoc/CEventManifestDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ResponseXml/EventManifestXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ManifestCollectionXml.h"
+
+#include "Doc/DocXml/ResponseXml/ManifestXml.h"
+
+#include "Doc/ResponseDoc/CManifestCollectionDoc.h"
+#include "Doc/ResponseDoc/CManifestDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ResponseXml/ManifestCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ManifestXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/AttachmentNameCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentNameCollectionDoc.h"
+#include "Doc/ResponseDoc/CManifestDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ResponseXml/ManifestXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ProviderEventResponseXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/StatisticsXml.h"
+#include "Doc/DocXml/ResponseXml/EventKeyCollectionXml.h"
+#include "Doc/DocXml/ResponseXml/ResponseHeaderXml.h"
+
+#include "Doc/CafCoreTypesDoc/CStatisticsDoc.h"
+#include "Doc/ResponseDoc/CEventKeyCollectionDoc.h"
+#include "Doc/ResponseDoc/CEventManifestDoc.h"
+#include "Doc/ResponseDoc/CProviderEventResponseDoc.h"
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ResponseXml/ProviderEventResponseXml.h"
+#include "Doc/DocXml/ResponseXml/EventManifestXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ProviderResponseXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/AttachmentCollectionXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/StatisticsXml.h"
+#include "Doc/DocXml/ResponseXml/ManifestXml.h"
+#include "Doc/DocXml/ResponseXml/ResponseHeaderXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CStatisticsDoc.h"
+#include "Doc/ResponseDoc/CManifestDoc.h"
+#include "Doc/ResponseDoc/CProviderResponseDoc.h"
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ResponseXml/ProviderResponseXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ResponseHeaderXml.h"
+
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ResponseXml/ResponseHeaderXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ResponseXml.h"
+
+#include "Doc/DocXml/CafCoreTypesXml/AttachmentCollectionXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/StatisticsXml.h"
+#include "Doc/DocXml/ResponseXml/ManifestCollectionXml.h"
+#include "Doc/DocXml/ResponseXml/ResponseHeaderXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CStatisticsDoc.h"
+#include "Doc/ResponseDoc/CManifestCollectionDoc.h"
+#include "Doc/ResponseDoc/CResponseDoc.h"
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ResponseXml/ResponseXml.h"
using namespace Caf;
#include "stdafx.h"
+#include "Doc/DocXml/ResponseXml/ResponseXml.h"
+
+#include "Doc/ResponseDoc/CErrorResponseDoc.h"
+#include "Doc/ResponseDoc/CProviderEventResponseDoc.h"
+#include "Doc/ResponseDoc/CProviderResponseDoc.h"
+#include "Doc/ResponseDoc/CResponseDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/ResponseXml/ResponseXmlRoots.h"
+#include "Doc/DocXml/ResponseXml/ErrorResponseXml.h"
+#include "Doc/DocXml/ResponseXml/ProviderResponseXml.h"
+#include "Doc/DocXml/ResponseXml/ProviderEventResponseXml.h"
+
using namespace Caf;
std::string XmlRoots::saveErrorResponseToString(
#endif
#include <CommonDefines.h>
+
#include <DocContracts.h>
#include <DocUtils.h>
-#include "ResponseXmlInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
-#include "ActionClassInstanceCollectionXml.h"
+
+#include "Doc/DocXml/SchemaTypesXml/ActionClassInstanceXml.h"
+
+#include "Doc/SchemaTypesDoc/CActionClassInstanceCollectionDoc.h"
+#include "Doc/SchemaTypesDoc/CActionClassInstanceDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/ActionClassInstanceCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ActionClassInstanceXml.h"
+
+#include "Doc/DocXml/SchemaTypesXml/InstanceOperationCollectionXml.h"
+
+#include "Doc/SchemaTypesDoc/CActionClassInstanceDoc.h"
+#include "Doc/SchemaTypesDoc/CInstanceOperationCollectionDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/ActionClassInstanceXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ActionClassXml.h"
+
+#include "Doc/DocXml/SchemaTypesXml/MethodXml.h"
+
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+#include "Doc/SchemaTypesDoc/CCollectMethodDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/ActionClassXml.h"
+#include "Doc/DocXml/SchemaTypesXml/CollectMethodXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ClassCardinalityXml.h"
+
+#include "Doc/SchemaTypesDoc/CClassCardinalityDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/ClassCardinalityXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ClassFieldXml.h"
+
+#include "Doc/SchemaTypesDoc/CClassFieldDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/ClassFieldXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ClassIdentifierXml.h"
+
+#include "Doc/SchemaTypesDoc/CClassIdentifierDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/ClassIdentifierXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ClassInstancePropertyXml.h"
+
+#include "Doc/DocXml/SchemaTypesXml/ClassIdentifierXml.h"
+
+#include "Doc/SchemaTypesDoc/CClassIdentifierDoc.h"
+#include "Doc/SchemaTypesDoc/CClassInstancePropertyDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/ClassInstancePropertyXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "ClassPropertyXml.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+
+#include "Doc/SchemaTypesDoc/CClassPropertyDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/ClassPropertyXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CmdlMetadataXml.h"
+
+#include "Doc/SchemaTypesDoc/CCmdlMetadataDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/CmdlMetadataXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CmdlUnionXml.h"
+
+#include "Doc/SchemaTypesDoc/CCmdlUnionDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/CmdlUnionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CollectMethodXml.h"
+
+#include "Doc/DocXml/SchemaTypesXml/ClassIdentifierXml.h"
+#include "Doc/DocXml/SchemaTypesXml/InstanceParameterXml.h"
+#include "Doc/DocXml/SchemaTypesXml/MethodParameterXml.h"
+
+#include "Doc/SchemaTypesDoc/CClassIdentifierDoc.h"
+#include "Doc/SchemaTypesDoc/CCollectMethodDoc.h"
+#include "Doc/SchemaTypesDoc/CInstanceParameterDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodParameterDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/CollectMethodXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "DataClassInstanceCollectionXml.h"
+
+#include "Doc/DocXml/SchemaTypesXml/DataClassInstanceXml.h"
+
+#include "Doc/SchemaTypesDoc/CDataClassInstanceCollectionDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/DataClassInstanceCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "DataClassInstanceXml.h"
+
+#include "Doc/DocXml/SchemaTypesXml/CmdlMetadataXml.h"
+#include "Doc/DocXml/SchemaTypesXml/CmdlUnionXml.h"
+#include "Doc/DocXml/SchemaTypesXml/DataClassSubInstanceXml.h"
+
+#include "Doc/SchemaTypesDoc/CCmdlMetadataDoc.h"
+#include "Doc/SchemaTypesDoc/CCmdlUnionDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassPropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassSubInstanceDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/DataClassInstanceXml.h"
+#include "Doc/DocXml/SchemaTypesXml/DataClassPropertyXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "DataClassPropertyXml.h"
+
+#include "Doc/DocXml/SchemaTypesXml/CmdlMetadataXml.h"
+
+#include "Doc/SchemaTypesDoc/CCmdlMetadataDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassPropertyDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/DataClassPropertyXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "DataClassSubInstanceXml.h"
+
+#include "Doc/DocXml/SchemaTypesXml/CmdlMetadataXml.h"
+#include "Doc/DocXml/SchemaTypesXml/CmdlUnionXml.h"
+
+#include "Doc/SchemaTypesDoc/CCmdlMetadataDoc.h"
+#include "Doc/SchemaTypesDoc/CCmdlUnionDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassPropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassSubInstanceDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/DataClassSubInstanceXml.h"
+#include "Doc/DocXml/SchemaTypesXml/DataClassPropertyXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "DataClassXml.h"
+
+#include "Doc/DocXml/SchemaTypesXml/ClassInstancePropertyXml.h"
+#include "Doc/DocXml/SchemaTypesXml/ClassPropertyXml.h"
+
+#include "Doc/SchemaTypesDoc/CClassInstancePropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CClassPropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/DataClassXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "InstanceOperationCollectionXml.h"
+
+#include "Doc/DocXml/SchemaTypesXml/InstanceOperationXml.h"
+
+#include "Doc/SchemaTypesDoc/CInstanceOperationCollectionDoc.h"
+#include "Doc/SchemaTypesDoc/CInstanceOperationDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/InstanceOperationCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "InstanceOperationXml.h"
+
+#include "Doc/SchemaTypesDoc/CInstanceOperationDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/InstanceOperationXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "InstanceParameterXml.h"
+
+#include "Doc/SchemaTypesDoc/CInstanceParameterDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/InstanceParameterXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "JoinTypeXml.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+#include "Doc/DocXml/SchemaTypesXml/ClassFieldXml.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+
+#include "Doc/SchemaTypesDoc/CClassFieldDoc.h"
+#include "Doc/SchemaTypesDoc/CJoinTypeDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/JoinTypeXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "LogicalRelationshipXml.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+#include "Doc/DocXml/SchemaTypesXml/ClassCardinalityXml.h"
+#include "Doc/DocXml/SchemaTypesXml/JoinTypeXml.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+
+#include "Doc/SchemaTypesDoc/CClassCardinalityDoc.h"
+#include "Doc/SchemaTypesDoc/CJoinTypeDoc.h"
+#include "Doc/SchemaTypesDoc/CLogicalRelationshipDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/LogicalRelationshipXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "MethodParameterXml.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+
+#include "Doc/SchemaTypesDoc/CMethodParameterDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/MethodParameterXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "MethodXml.h"
+
+#include "Doc/DocXml/SchemaTypesXml/ClassIdentifierXml.h"
+#include "Doc/DocXml/SchemaTypesXml/InstanceParameterXml.h"
+#include "Doc/DocXml/SchemaTypesXml/MethodParameterXml.h"
+
+#include "Doc/SchemaTypesDoc/CClassIdentifierDoc.h"
+#include "Doc/SchemaTypesDoc/CInstanceParameterDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodParameterDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/MethodXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "PhysicalRelationshipXml.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+#include "Doc/DocXml/SchemaTypesXml/ClassCardinalityXml.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+
+#include "Doc/SchemaTypesDoc/CClassCardinalityDoc.h"
+#include "Doc/SchemaTypesDoc/CPhysicalRelationshipDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/PhysicalRelationshipXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "RelationshipXml.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+#include "Doc/DocXml/SchemaTypesXml/ClassCardinalityXml.h"
+#include "Doc/SchemaTypesDoc/SchemaTypesDocTypes.h"
+
+#include "Doc/SchemaTypesDoc/CClassCardinalityDoc.h"
+#include "Doc/SchemaTypesDoc/CRelationshipDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Doc/DocXml/SchemaTypesXml/RelationshipXml.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
+
#include <DocContracts.h>
#include <DocUtils.h>
-#include "SchemaTypesXmlInc.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
-#include "CCafException.h"
+#include "Exception/CCafException.h"
#include <stdio.h>
#include <stdarg.h>
#include "CBacktraceUtils.h"
void _exclass_::throwSelf() { throw this; } \
void _exclass_::throwAddRefedSelf() { this->AddRef(); throw this; }
+#include "Exception/CCafException.h"
+
namespace Caf {
// General Runtime Exceptions
*/
#include "stdafx.h"
+#include "Exception/CCafException.h"
#include "CValidate.h"
#include "ValidationMacros.h"
#endif
#include "CBacktraceUtils.h"
-#include "CCafException.h"
#include "ClassMacros.h"
#include "ExceptionMacros.h"
#include "CCafExceptionEx.h"
#include <BaseDefines.h>
#include <CommonGlobals.h>
-#include "CCafException.h"
#include "ClassMacros.h"
#include "ExceptionMacros.h"
*/
#include "stdafx.h"
-#include "CBeanPropertiesHelper.h"
+#include "Exception/CCafException.h"
+#include "Integration/Caf/CBeanPropertiesHelper.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CCafMessageCreator.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlRoots.h"
+#include "Doc/DocXml/DiagRequestXml/DiagRequestXmlRoots.h"
+#include "Doc/DocXml/MgmtRequestXml/MgmtRequestXmlRoots.h"
+#include "Doc/DocXml/ProviderInfraXml/ProviderInfraXmlRoots.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXmlRoots.h"
+#include "Doc/DocXml/ResponseXml/ResponseXmlRoots.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+#include "Doc/DocXml/CafCoreTypesXml/AttachmentCollectionXml.h"
+
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+#include "Integration/Caf/CCafMessageHeadersWriter.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/CafCoreTypesDoc/CPropertyCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CPropertyDoc.h"
+#include "Doc/CafCoreTypesDoc/CProtocolCollectionDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallRequestDoc.h"
+#include "Doc/DiagRequestDoc/CDiagRequestDoc.h"
+#include "Doc/MgmtRequestDoc/CMgmtRequestDoc.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Doc/ProviderInfraDoc/CProviderRegDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectSchemaRequestDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestHeaderDoc.h"
+#include "Doc/ResponseDoc/CErrorResponseDoc.h"
+#include "Doc/ResponseDoc/CResponseDoc.h"
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Integration/Caf/CCafMessagePayload.h"
+#include "Integration/Caf/CCafMessageCreator.h"
+#include "Doc/DocXml/PayloadEnvelopeXml/PayloadEnvelopeXmlRoots.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CCafMessageHeaders.h"
+
+#include "IVariant.h"
+#include "Integration/IIntMessage.h"
+#include "Exception/CCafException.h"
+#include "Integration/Caf/CCafMessageHeaders.h"
+#include "Integration/Core/FileHeaders.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CCafMessageHeadersWriter.h"
+
+#include "Integration/IIntMessage.h"
+#include "Integration/Caf/CCafMessageHeadersWriter.h"
+#include "Integration/Core/FileHeaders.h"
+#include "Integration/Core/MessageHeaders.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CCafMessagePayload.h"
-#include <DocXml.h>
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Doc/ResponseDoc/CEventKeyCollectionDoc.h"
+#include "Doc/ResponseDoc/CEventKeyDoc.h"
+#include "Doc/ResponseDoc/CManifestDoc.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Integration/Caf/CCafMessagePayload.h"
+#include "Doc/DocXml/CafCoreTypesXml/RequestHeaderXml.h"
+#include "Doc/DocXml/ResponseXml/ManifestXml.h"
+#include "Doc/DocXml/ResponseXml/EventKeyCollectionXml.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CCafMessagePayloadParser.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlRoots.h"
+#include "Doc/DocXml/MgmtRequestXml/MgmtRequestXmlRoots.h"
+#include "Doc/DocXml/ProviderInfraXml/ProviderInfraXmlRoots.h"
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXmlRoots.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/InstallProviderJobXml.h"
+#include "Doc/DocXml/CafInstallRequestXml/UninstallProviderJobXml.h"
+#include "Doc/DocXml/PayloadEnvelopeXml/PayloadEnvelopeXml.h"
+
+#include "Doc/CafInstallRequestDoc/CInstallProviderJobDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallRequestDoc.h"
+#include "Doc/CafInstallRequestDoc/CUninstallProviderJobDoc.h"
+#include "Doc/MgmtRequestDoc/CMgmtRequestDoc.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Doc/ProviderInfraDoc/CProviderRegDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
using namespace Caf;
#endif
#include <CommonDefines.h>
-#include <DocXml.h>
#include <DocUtils.h>
#include <Integration.h>
*/
#include "stdafx.h"
-#include "CAbstractMessageChannel.h"
+
+#include "Integration/IChannelInterceptor.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/Core/CAbstractMessageChannel.h"
CAbstractMessageChannel::CAbstractMessageChannel() :
CAF_CM_INIT("CAbstractMessageChannel") {
*/
#include "stdafx.h"
-#include "CAbstractMessageRouter.h"
+
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/Core/CIntException.h"
+#include "Exception/CCafException.h"
+#include "Integration/Core/CAbstractMessageRouter.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CAbstractPollableChannel.h"
+
+#include "Integration/Dependencies/CPollerMetadata.h"
+#include "Integration/IChannelInterceptor.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/Core/CAbstractPollableChannel.h"
CAbstractPollableChannel::CAbstractPollableChannel() :
CAF_CM_INIT("CAbstractPollableChannel") {
*/
#include "stdafx.h"
-#include "CBroadcastingDispatcher.h"
+
+#include "Integration/Core/CIntException.h"
+#include "Integration/IErrorHandler.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageHandler.h"
+#include "Integration/Core/CBroadcastingDispatcher.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CChannelInterceptorAdapter.h"
+
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/Core/CChannelInterceptorAdapter.h"
CChannelInterceptorAdapter::CChannelInterceptorAdapter() {
}
*/
#include "stdafx.h"
-#include "CChannelResolver.h"
+
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/Core/CChannelResolver.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CDocument.h"
+
+#include "Integration/IDocument.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Integration/Core/CDocument.h"
+#include "Common/IAppConfig.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "MessageHeaders.h"
-#include "CErrorHandler.h"
+
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/IThrowable.h"
+#include "Integration/Core/CErrorHandler.h"
+#include "Integration/Core/CIntMessageHeaders.h"
+#include "Integration/Core/MessageHeaders.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CExpressionHandler.h"
+
+#include "Common/IAppConfig.h"
+#include "Common/IAppContext.h"
+#include "IBean.h"
+#include "IVariant.h"
+#include "Integration/Core/CExpressionHandler.h"
+#include "Common/CCafRegex.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CIntException.h"
+#include "Integration/Core/CIntException.h"
#define CAF_CM_DEFINE_INTEGRATION_EXCEPTION_CLASS(_exclass_) \
_exclass_::_exclass_() : CCafException( #_exclass_ ) {} \
*/
#include "stdafx.h"
-#include "CIntException.h"
+
+#include "ICafObject.h"
+#include "IVariant.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Integration/Core/CIntMessage.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CIntException.h"
+
+#include "ICafObject.h"
+#include "IVariant.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/Core/CIntMessageHeaders.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CIntegrationAppContext.h"
+
+#include "Common/IAppContext.h"
+#include "IBean.h"
+#include "Integration/Core/CChannelResolver.h"
+#include "Integration/Core/CDocument.h"
+#include "Integration/IChannelInterceptor.h"
+#include "Integration/IChannelInterceptorInstance.h"
+#include "Integration/IChannelInterceptorSupport.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationAppContext.h"
+#include "Integration/IIntegrationAppContextAware.h"
+#include "Integration/IIntegrationComponent.h"
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ILifecycle.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/IMessageProducer.h"
+#include "Integration/IPhased.h"
+#include "Integration/ISmartLifecycle.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Integration/Core/CIntegrationAppContext.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CMessageHandler.h"
+
+#include "ICafObject.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/Core/CMessageHandler.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CMessageHeaderUtils.h"
-using namespace Caf;
-
-/*
- * Created on: Nov 19, 2014
- * Author: bwilliams
- *
- * Copyright (c) 2012 VMware, Inc. All rights reserved.
- * -- VMware Confidential
- */
-
-#include "stdafx.h"
-#include "CMessageHeaderUtils.h"
+#include "Integration/IIntMessage.h"
+#include "Exception/CCafException.h"
+#include "Integration/Core/CMessageHeaderUtils.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CMessagingTemplate.h"
+
+#include "ICafObject.h"
+#include "Integration/Core/CErrorHandler.h"
+#include "Integration/Core/CMessageHandler.h"
+#include "Integration/Core/CSimpleAsyncTaskExecutor.h"
+#include "Integration/Core/CSourcePollingChannelAdapter.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/IPollableChannel.h"
+#include "Integration/ITaskExecutor.h"
+#include "Integration/Core/CMessagingTemplate.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CMessagingTemplateHandler.h"
+
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageHandler.h"
+#include "Integration/Core/CMessagingTemplateHandler.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CSimpleAsyncTaskExecutor.h"
+
+#include "Common/CAutoMutex.h"
+#include "Integration/Core/CIntException.h"
+#include "Integration/Core/CSimpleAsyncTaskExecutorState.h"
+#include "Integration/IErrorHandler.h"
+#include "Integration/IRunnable.h"
+#include "Integration/ITaskExecutor.h"
+#include "Integration/Core/CSimpleAsyncTaskExecutor.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CSimpleAsyncTaskExecutorState.h"
+
+#include "Common/CAutoMutex.h"
+#include "Integration/IErrorHandler.h"
+#include "Integration/IRunnable.h"
+#include "Integration/Core/CSimpleAsyncTaskExecutorState.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CSourcePollingChannelAdapter.h"
+
+#include "Integration/Core/CIntException.h"
+#include "Integration/IErrorHandler.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageHandler.h"
+#include "Integration/IPollableChannel.h"
+#include "Integration/Core/CSourcePollingChannelAdapter.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CUnicastingDispatcher.h"
+
+#include "Integration/Core/CIntException.h"
+#include "Integration/IErrorHandler.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageHandler.h"
+#include "Integration/Core/CUnicastingDispatcher.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "FileHeaders.h"
+#include "Integration/Core/FileHeaders.h"
namespace Caf {
namespace FileHeaders {
*/
#include "stdafx.h"
-#include "MessageHeaders.h"
+#include "Integration/Core/MessageHeaders.h"
namespace Caf {
namespace MessageHeaders {
#include <CommonDefines.h>
#include <Integration.h>
-#include "FileHeaders.h"
-#include "MessageHeaders.h"
-#include "CIntMessageHeaders.h"
-#include "CIntMessage.h"
-#include "CDocument.h"
-#include "CMessageHandler.h"
-#include "CErrorHandler.h"
-#include "CIntException.h"
-#include "CChannelResolver.h"
-#include "CIntegrationAppContext.h"
-#include "CSimpleAsyncTaskExecutorState.h"
-#include "CSimpleAsyncTaskExecutor.h"
-#include "CSourcePollingChannelAdapter.h"
-#include "CBroadcastingDispatcher.h"
-#include "CUnicastingDispatcher.h"
-
-#include "CMessagingTemplateHandler.h"
-#include "CMessagingTemplate.h"
-
+#include "Integration/Core/FileHeaders.h"
+#include "Integration/Core/MessageHeaders.h"
#endif /* STDAFX_H_ */
*/
#include "stdafx.h"
+#include "Exception/CCafException.h"
#include "CEcmDllManager.h"
#ifndef WIN32
*/
#include "stdafx.h"
+#include "Exception/CCafException.h"
#include "CEcmSubSystem.h"
#include "EcmSubSystemBase.h"
#include "CEcmSubSystemRegistry.h"
*/
#include "stdafx.h"
+#include "Exception/CCafException.h"
#include "CEcmSubSystemModule.h"
#include "CEcmSubSystemRegistry.h"
#include "CEcmDllManager.h"
*/
#include "stdafx.h"
+#include "Common/IAppConfig.h"
#include "CEcmSubSystemRegistry.h"
#include "CEcmDllManager.h"
#include <algorithm>
*/
#include "stdafx.h"
+#include "Exception/CCafException.h"
#include "EcmSubSystemBase.h"
#include <string.h>
#include <stdlib.h>
#ifndef _TCafSubSystemCreator_H_
#define _TCafSubSystemCreator_H_
+#include "Exception/CCafException.h"
+
namespace Caf {
template< typename Derived, typename SmartPtr = TCafSmartPtr< Derived > >
#define _TCafSubSystemSmartCl_H
#include "EcmSubSystemBase.h"
+#include "Exception/CCafException.h"
#include "CEcmSubSystem.h"
#include <map>
*/
#include "stdafx.h"
-#include "CMarkupParser.h"
+#include "Xml/MarkupParser/CMarkupParser.h"
+#include "Exception/CCafException.h"
#include <deque>
#include <algorithm>
#endif
#endif
-#include "CMarkupParser.h"
#endif /* MARKUPPARSERLINK_H_ */
*/
#include "stdafx.h"
-#include "CXmlElement.h"
+
+#include "Integration/IDocument.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Xml/MarkupParser/CMarkupParser.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Exception/CCafException.h"
#include "CXmlUtils.h"
using namespace Caf;
#ifndef CXmlUtils_H_
#define CXmlUtils_H_
-#include "CXmlElement.h"
+
+
+#include "Xml/XmlUtils/CXmlElement.h"
namespace Caf {
#endif
#endif
-#include "CXmlElement.h"
#include "CXmlUtils.h"
#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CEnvelopeToPayloadTransformerInstance_h_
+#define CEnvelopeToPayloadTransformerInstance_h_
+
+#include "Common/IAppContext.h"
+#include "CafIntegrationSubsys.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+
+#include "Integration/IErrorProcessor.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ITransformer.h"
+
+namespace Caf {
+
+class CEnvelopeToPayloadTransformerInstance :
+ public TCafSubSystemObjectRoot<CEnvelopeToPayloadTransformerInstance>,
+ public IIntegrationObject,
+ public IIntegrationComponentInstance,
+ public ITransformer,
+ public IErrorProcessor {
+public:
+ struct SExpandedFileAlias {
+ std::string _filePath;
+ std::string _encoding;
+ };
+ CAF_DECLARE_SMART_POINTER(SExpandedFileAlias);
+
+public:
+ CEnvelopeToPayloadTransformerInstance();
+ virtual ~CEnvelopeToPayloadTransformerInstance();
+
+ CAF_DECLARE_OBJECT_IDENTIFIER(_sObjIdEnvelopeToPayloadTransformerInstance)
+
+ CAF_BEGIN_INTERFACE_MAP(CEnvelopeToPayloadTransformerInstance)
+ CAF_INTERFACE_ENTRY(IIntegrationObject)
+ CAF_INTERFACE_ENTRY(IIntegrationComponentInstance)
+ CAF_INTERFACE_ENTRY(ITransformer)
+ CAF_INTERFACE_ENTRY(IErrorProcessor)
+ CAF_END_INTERFACE_MAP()
+
+public: // IIntegrationObject
+ void initialize(
+ const IBean::Cargs& ctorArgs,
+ const IBean::Cprops& properties,
+ const SmartPtrIDocument& configSection);
+
+ std::string getId() const;
+
+public: // IIntegrationComponentInstance
+ void wire(
+ const SmartPtrIAppContext& appContext,
+ const SmartPtrIChannelResolver& channelResolver);
+
+public: // ITransformer
+ SmartPtrIIntMessage transformMessage(
+ const SmartPtrIIntMessage& message);
+
+public: // IErrorProcessor
+ SmartPtrIIntMessage processErrorMessage(
+ const SmartPtrIIntMessage& message);
+
+private:
+ SmartPtrCDynamicByteArray findPayload(
+ const std::deque<SmartPtrCAttachmentDoc>& attachmentCollection) const;
+
+ std::deque<SmartPtrCAttachmentDoc> removePayload(
+ const std::deque<SmartPtrCAttachmentDoc>& attachmentCollection) const;
+
+private:
+ bool _isInitialized;
+ std::string _id;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CEnvelopeToPayloadTransformerInstance);
+};
+
+}
+
+#endif // #ifndef CEnvelopeToPayloadTransformerInstance_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CafIntegrationSubsys_h_
+#define CafIntegrationSubsys_h_
+
+namespace Caf {
+ extern const char* _sObjIdErrorToResponseTransformerInstance;
+ extern const char* _sObjIdErrorToResponseTransformer;
+ extern const char* _sObjIdPayloadHeaderEnricherInstance;
+ extern const char* _sObjIdPayloadHeaderEnricher;
+ extern const char* _sObjIdEnvelopeToPayloadTransformerInstance;
+ extern const char* _sObjIdEnvelopeToPayloadTransformer;
+}
+
+#endif // #ifndef CafIntegrationSubsys_h_
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
#include "CEnvelopeToPayloadTransformer.h"
using namespace Caf;
#ifndef CEnvelopeToPayloadTransformer_h_
#define CEnvelopeToPayloadTransformer_h_
+
+#include "IBean.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
#include "CEnvelopeToPayloadTransformerInstance.h"
+#include "Exception/CCafException.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
+#include "Integration/Caf/CCafMessageCreator.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
#include "CErrorToResponseTransformer.h"
using namespace Caf;
#ifndef CErrorToResponseTransformer_h_
#define CErrorToResponseTransformer_h_
+
+#include "IBean.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Integration/Caf/CCafMessageHeaders.h"
+#include "Common/IAppContext.h"
+#include "Doc/ResponseDoc/CErrorResponseDoc.h"
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
#include "CErrorToResponseTransformerInstance.h"
+#include "Integration/Caf/CCafMessageCreator.h"
using namespace Caf;
#ifndef CErrorToResponseTransformerInstance_h_
#define CErrorToResponseTransformerInstance_h_
+#include "CafIntegrationSubsys.h"
+#include "Common/IAppContext.h"
+#include "Integration/IErrorProcessor.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Integration/IIntegrationObject.h"
+
namespace Caf {
class CErrorToResponseTransformerInstance :
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
#include "CPayloadHeaderEnricher.h"
using namespace Caf;
#ifndef CPayloadHeaderEnricher_h_
#define CPayloadHeaderEnricher_h_
+
+#include "IBean.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Integration/Caf/CBeanPropertiesHelper.h"
+#include "Integration/Caf/CCafMessageHeadersWriter.h"
+#include "Common/IAppContext.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
#include "CPayloadHeaderEnricherInstance.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
using namespace Caf;
#ifndef CPayloadHeaderEnricherInstance_h_
#define CPayloadHeaderEnricherInstance_h_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ITransformer.h"
+
namespace Caf {
class CPayloadHeaderEnricherInstance :
#include "stdafx.h"
+#include "CEnvelopeToPayloadTransformerInstance.h"
+
using namespace Caf;
namespace Caf {
#include <CommonDefines.h>
#include <Integration.h>
-#include <DocXml.h>
#include <DocUtils.h>
-namespace Caf {
- extern const char* _sObjIdErrorToResponseTransformerInstance;
- extern const char* _sObjIdErrorToResponseTransformer;
- extern const char* _sObjIdPayloadHeaderEnricherInstance;
- extern const char* _sObjIdPayloadHeaderEnricher;
- extern const char* _sObjIdEnvelopeToPayloadTransformerInstance;
- extern const char* _sObjIdEnvelopeToPayloadTransformer;
-}
-
#include "CErrorToResponseTransformerInstance.h"
#include "CErrorToResponseTransformer.h"
#include "CPayloadHeaderEnricherInstance.h"
#include "CPayloadHeaderEnricher.h"
-#include "CEnvelopeToPayloadTransformerInstance.h"
#include "CEnvelopeToPayloadTransformer.h"
#endif // #ifndef stdafx_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CFileReadingMessageSource_h_
+#define CFileReadingMessageSource_h_
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/Core/CAbstractPollableChannel.h"
+
+namespace Caf {
+
+class CFileReadingMessageSource :
+ public CAbstractPollableChannel
+{
+private:
+ typedef std::map<std::string, bool> CFileCollection;
+ CAF_DECLARE_SMART_POINTER(CFileCollection);
+
+public:
+ CFileReadingMessageSource();
+ virtual ~CFileReadingMessageSource();
+
+public:
+ void initialize(
+ const SmartPtrIDocument& configSection);
+
+protected: // CAbstractPollableChannel
+ bool doSend(
+ const SmartPtrIIntMessage& message,
+ int32 timeout);
+
+ SmartPtrIIntMessage doReceive(const int32 timeout);
+
+private:
+ SmartPtrCFileCollection itemsInDirectory(
+ const std::string& directory,
+ const std::string& filenameRegex) const;
+
+ SmartPtrCFileCollection merge(
+ const SmartPtrCFileCollection& newFileCollection,
+ const SmartPtrCFileCollection& existingFileCollection) const;
+
+ std::string calcNextFile(
+ SmartPtrCFileCollection& fileCollection) const;
+
+ uint64 getTimeSec() const;
+
+ bool isRefreshNecessary(
+ const uint32 refreshSec,
+ const uint64 lastRefreshSec) const;
+
+private:
+ bool _isInitialized;
+ std::string _id;
+ std::string _directory;
+ std::string _filenameRegex;
+ bool _preventDuplicates;
+ uint32 _refreshSec;
+ uint64 _lastRefreshSec;
+
+ SmartPtrCFileCollection _fileCollection;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CFileReadingMessageSource);
+};
+
+CAF_DECLARE_SMART_POINTER(CFileReadingMessageSource);
+
+}
+
+#endif // #ifndef CFileReadingMessageSource_h_
--- /dev/null
+/*
+ * Created on: Aug 10, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CMessageHandlerChainInstance_h
+#define CMessageHandlerChainInstance_h
+
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "ICafObject.h"
+#include "Integration/Core/CMessageHandler.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/ISubscribableChannel.h"
+#include "Integration/ITaskExecutor.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ILifecycle.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/IMessageHandler.h"
+
+namespace Caf {
+
+class CMessageHandlerChainInstance :
+ public IIntegrationObject,
+ public IIntegrationComponentInstance,
+ public ILifecycle,
+ public IMessageHandler
+{
+public:
+ CMessageHandlerChainInstance();
+ virtual ~CMessageHandlerChainInstance();
+
+ CAF_BEGIN_QI()
+ CAF_QI_ENTRY(IIntegrationObject)
+ CAF_QI_ENTRY(IIntegrationComponentInstance)
+ CAF_QI_ENTRY(ILifecycle)
+ CAF_QI_ENTRY(IMessageHandler)
+ CAF_END_QI()
+
+public: // IIntegrationObject
+ void initialize(
+ const IBean::Cargs& ctorArgs,
+ const IBean::Cprops& properties,
+ const SmartPtrIDocument& configSection);
+
+ std::string getId() const;
+
+public: // IIntegrationComponentInstance
+ void wire(
+ const SmartPtrIAppContext& appContext,
+ const SmartPtrIChannelResolver& channelResolver);
+
+public: // ILifecycle
+ void start(const uint32 timeoutMs);
+ void stop(const uint32 timeoutMs);
+ bool isRunning() const;
+
+public: // IMessageHandler
+ void handleMessage(
+ const SmartPtrIIntMessage& message);
+ SmartPtrIIntMessage getSavedMessage() const;
+ void clearSavedMessage();
+
+private:
+ void logMessage(const SmartPtrIIntMessage& message) const;
+
+private:
+ class ChainedMessageHandler {
+ public:
+ ChainedMessageHandler();
+
+ void init(
+ const SmartPtrIAppContext& appContext,
+ const SmartPtrIChannelResolver& channelResolver);
+ void setId(const std::string& id);
+ void setOutputChannel(const SmartPtrIMessageChannel& channel);
+ void setMessageHandler(const SmartPtrICafObject& handlerObj);
+ void handleMessage(const SmartPtrIIntMessage& message);
+ SmartPtrIIntMessage getSavedMessage() const;
+ void clearSavedMessage();
+
+ private:
+ void logMessage(const SmartPtrIIntMessage& message) const;
+
+ private:
+ bool _isInitialized;
+ std::string _id;
+ SmartPtrIMessageChannel _outputChannel;
+ SmartPtrICafObject _messageHandlerObj;
+ SmartPtrCMessageHandler _messageHandler;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(ChainedMessageHandler);
+ };
+ CAF_DECLARE_SMART_POINTER(ChainedMessageHandler);
+ typedef std::deque<SmartPtrChainedMessageHandler> MessageHandlers;
+
+ class InterconnectChannel : public IMessageChannel {
+ public:
+ InterconnectChannel();
+ virtual ~InterconnectChannel();
+ void init(const SmartPtrChainedMessageHandler& nextHandler);
+ bool send(
+ const SmartPtrIIntMessage& message);
+ bool send(
+ const SmartPtrIIntMessage& message,
+ const int32 timeout);
+
+ private:
+ SmartPtrChainedMessageHandler _nextHandler;
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(InterconnectChannel);
+ };
+ CAF_DECLARE_SMART_POINTER(InterconnectChannel);
+
+ struct ChainLink {
+ CMessageHandlerChainInstance::SmartPtrChainedMessageHandler handler;
+ std::string id;
+ bool isMessageProducer;
+ };
+ CAF_DECLARE_SMART_POINTER(ChainLink);
+ typedef std::vector<SmartPtrChainLink> ChainLinks;
+
+ class SelfWeakReference : public IMessageHandler {
+ public:
+ SelfWeakReference();
+ void setReference(IMessageHandler *handler);
+ public: // IMessageHandler
+ void handleMessage(
+ const SmartPtrIIntMessage& message);
+ SmartPtrIIntMessage getSavedMessage() const;
+ void clearSavedMessage();
+ private:
+ IMessageHandler *_reference;
+ CAF_CM_CREATE_THREADSAFE;
+ };
+ CAF_DECLARE_SMART_POINTER(SelfWeakReference);
+
+private:
+ bool _isInitialized;
+ bool _isRunning;
+ IBean::Cargs _ctorArgs;
+ IBean::Cprops _properties;
+ SmartPtrIDocument _configSection;
+ std::string _id;
+ SmartPtrISubscribableChannel _subscribableInputChannel;
+ SmartPtrITaskExecutor _taskExecutor;
+ SmartPtrSelfWeakReference _weakRefSelf;
+ MessageHandlers _messageHandlers;
+ SmartPtrIIntMessage _savedMessage;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CMessageHandlerChainInstance);
+};
+
+CAF_DECLARE_SMART_QI_POINTER(CMessageHandlerChainInstance);
+
+}
+
+#endif /* CMessageHandlerChainInstance_h */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CXPathHeaderEnricherItem_h_
+#define CXPathHeaderEnricherItem_h_
+
+
+#include "Integration/IDocument.h"
+
+namespace Caf {
+
+class CXPathHeaderEnricherItem {
+private:
+ typedef std::map<std::string, bool> CFileCollection;
+ CAF_DECLARE_SMART_POINTER(CFileCollection);
+
+public:
+ CXPathHeaderEnricherItem();
+ virtual ~CXPathHeaderEnricherItem();
+
+public:
+ void initialize(
+ const SmartPtrIDocument& configSection,
+ const bool& defaultOverwrite);
+
+public:
+ std::string getName() const;
+ std::string getEvaluationType() const;
+ bool getOverwrite() const;
+ std::string getXpathExpression() const;
+ std::string getXpathExpressionRef() const;
+
+private:
+ bool _isInitialized;
+
+ std::string _name;
+ std::string _evaluationType;
+ bool _overwrite;
+ std::string _xpathExpression;
+ std::string _xpathExpressionRef;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_DECLARE_NOCOPY(CXPathHeaderEnricherItem);
+};
+
+CAF_DECLARE_SMART_POINTER(CXPathHeaderEnricherItem);
+
+}
+
+#endif // #ifndef CXPathHeaderEnricherItem_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef IntegrationSubsys_h_
+#define IntegrationSubsys_h_
+
+namespace Caf {
+ // Integration Contracts
+ extern const char* _sObjIdIntegrationObjectFactory;
+ extern const char* _sObjIdErrorChannel;
+ extern const char* _sObjIdNullChannel;
+ extern const char* _sObjIdHeaderExpressionInvoker;
+}
+
+#endif // #ifndef IntegrationSubsys_h_
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/Core/CErrorHandler.h"
+#include "Integration/Core/CUnicastingDispatcher.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/IMessageHandler.h"
+#include "Exception/CCafException.h"
#include "CDirectChannelInstance.h"
using namespace Caf;
#ifndef CDirectChannelInstance_h_
#define CDirectChannelInstance_h_
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageDispatcher.h"
+#include "Integration/IMessageHandler.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ISubscribableChannel.h"
+#include "Integration/Core/CAbstractMessageChannel.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
#include "CErrorChannel.h"
#include "CErrorChannelInstance.h"
#ifndef CErrorChannel_h_
#define CErrorChannel_h_
+
+#include "IBean.h"
+
+#include "IntegrationSubsys.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/Core/CErrorHandler.h"
+#include "Integration/Core/CUnicastingDispatcher.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/IMessageHandler.h"
+#include "Exception/CCafException.h"
#include "CErrorChannelInstance.h"
using namespace Caf;
#ifndef CErrorChannelInstance_h_
#define CErrorChannelInstance_h_
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageDispatcher.h"
+#include "Integration/IMessageHandler.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ISubscribableChannel.h"
+#include "Integration/Core/CAbstractMessageChannel.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
-#include "CFileInboundChannelAdapterInstance.h"
+
#include "CFileReadingMessageSource.h"
+#include "Common/IAppContext.h"
+#include "Integration/Core/CErrorHandler.h"
+#include "Integration/Core/CMessageHandler.h"
+#include "Integration/Core/CSimpleAsyncTaskExecutor.h"
+#include "Integration/Core/CSourcePollingChannelAdapter.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IMessageChannel.h"
+#include "CFileInboundChannelAdapterInstance.h"
using namespace Caf;
#ifndef CFileInboundChannelAdapterInstance_h_
#define CFileInboundChannelAdapterInstance_h_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/ITaskExecutor.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ILifecycle.h"
+#include "Integration/IMessageProducer.h"
+
namespace Caf {
class CFileInboundChannelAdapterInstance :
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Exception/CCafException.h"
#include "CFileOutboundChannelAdapterInstance.h"
#include "CDirectChannelInstance.h"
+#include "Integration/Core/FileHeaders.h"
using namespace Caf;
#ifndef CFileOutboundChannelAdapterInstance_h_
#define CFileOutboundChannelAdapterInstance_h_
+
+#include "Integration/IErrorProcessor.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IMessageHandler.h"
+
namespace Caf {
class CFileOutboundChannelAdapterInstance :
*/
#include "stdafx.h"
+
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
#include "CFileReadingMessageSource.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/Core/CIntMessageHeaders.h"
#include "CFileToStringTransformerInstance.h"
+#include "Integration/Core/FileHeaders.h"
using namespace Caf;
#ifndef CFileToStringTransformerInstance_h_
#define CFileToStringTransformerInstance_h_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ITransformer.h"
+
namespace Caf {
class CFileToStringTransformerInstance :
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "IBean.h"
+#include "IVariant.h"
+#include "Integration/Core/CExpressionHandler.h"
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/ITransformer.h"
+#include "Exception/CCafException.h"
+#include "Common/IAppConfig.h"
#include "CHeaderEnricherTransformerInstance.h"
+#include "Integration/Core/MessageHeaders.h"
using namespace Caf;
#ifndef CHeaderEnricherTransformerInstance_h_
#define CHeaderEnricherTransformerInstance_h_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/Core/CExpressionHandler.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/ITransformer.h"
+#include "Integration/IIntegrationObject.h"
+
namespace Caf {
class CHeaderEnricherTransformerInstance :
*/
#include "stdafx.h"
+
+#include "IVariant.h"
+#include "Integration/IIntMessage.h"
+#include "Exception/CCafException.h"
#include "CHeaderExpressionInvoker.h"
using namespace Caf;
#ifndef CHEADEREXPRESSIONINVOKER_H_
#define CHEADEREXPRESSIONINVOKER_H_
+
+#include "IBean.h"
+
+#include "IVariant.h"
+#include "IntegrationSubsys.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IExpressionInvoker.h"
+
namespace Caf {
class CHeaderExpressionInvoker :
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Exception/CCafException.h"
#include "CHeaderValueRouterInstance.h"
using namespace Caf;
#ifndef CHeaderValueRouterInstance_h_
#define CHeaderValueRouterInstance_h_
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/Core/CAbstractMessageRouter.h"
+
namespace Caf {
class CHeaderValueRouterInstance :
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Exception/CCafException.h"
#include "CIntegrationObjectFactory.h"
#include "CObjectFactoryTables.h"
#include "CDirectChannelInstance.h"
#ifndef CIntegrationObjectFactory_h
#define CIntegrationObjectFactory_h
+
+#include "IBean.h"
+
+#include "IntegrationSubsys.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf {
class CIntegrationObjectFactory :
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Exception/CCafException.h"
#include "CLoggingChannelAdapterInstance.h"
using namespace Caf;
#ifndef CLOGGINGCHANNELADAPTERINSTANCE_H_
#define CLOGGINGCHANNELADAPTERINSTANCE_H_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IMessageHandler.h"
+
namespace Caf {
class CLoggingChannelAdapterInstance :
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "IBean.h"
+#include "ICafObject.h"
+#include "Integration/Core/CErrorHandler.h"
+#include "Integration/Core/CSimpleAsyncTaskExecutor.h"
+#include "Integration/Core/CSourcePollingChannelAdapter.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationComponent.h"
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/IPollableChannel.h"
#include "CMessageHandlerChainInstance.h"
+#include "Exception/CCafException.h"
#include "CObjectFactoryTables.h"
+#include "Integration/Core/CMessageHeaderUtils.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
#include "CNullChannel.h"
#include "CNullChannelInstance.h"
#ifndef CNullChannel_h_
#define CNullChannel_h_
+
+#include "IBean.h"
+
+#include "IntegrationSubsys.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
#include "CNullChannelInstance.h"
using namespace Caf;
#ifndef CNullChannelInstance_h_
#define CNullChannelInstance_h_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/Core/CAbstractMessageChannel.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "CMessageHandlerChainInstance.h"
#include "CObjectFactoryTables.h"
#include "CServiceActivatorInstance.h"
#include "CWireTapInstance.h"
#include "CPayloadContentRouterInstance.h"
#include "CLoggingChannelAdapterInstance.h"
#include "CRecipientListRouterInstance.h"
-#include "CMessageHandlerChainInstance.h"
#include "CRouterInstance.h"
-#include "CXPathHeaderEnricherItem.h"
#include "CXPathHeaderEnricherTransformerInstance.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Common/CCafRegex.h"
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Exception/CCafException.h"
#include "CPayloadContentRouterInstance.h"
using namespace Caf;
#ifndef CPayloadContentRouterInstance_h_
#define CPayloadContentRouterInstance_h_
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/Core/CAbstractMessageRouter.h"
+
namespace Caf {
class CPayloadContentRouterInstance :
public IIntegrationObject,
public IIntegrationComponentInstance,
- public CAbstractMessageRouter
-{
+ public CAbstractMessageRouter {
public:
CPayloadContentRouterInstance();
virtual ~CPayloadContentRouterInstance();
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/Core/CBroadcastingDispatcher.h"
+#include "Integration/Core/CErrorHandler.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/IMessageHandler.h"
+#include "Exception/CCafException.h"
#include "CPublishSubscribeChannelInstance.h"
using namespace Caf;
#ifndef CPublishSubscribeChannelInstance_h_
#define CPublishSubscribeChannelInstance_h_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageDispatcher.h"
+#include "Integration/IMessageHandler.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ISubscribableChannel.h"
+#include "Integration/Core/CAbstractMessageChannel.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Exception/CCafException.h"
#include "CQueueChannelInstance.h"
using namespace Caf;
#ifndef CQueueChannelInstance_h_
#define CQueueChannelInstance_h_
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/Core/CAbstractPollableChannel.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
class CQueueChannelInstance :
public IIntegrationObject,
public IIntegrationComponentInstance,
- public CAbstractPollableChannel
-{
+ public CAbstractPollableChannel {
public:
CQueueChannelInstance();
virtual ~CQueueChannelInstance();
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "IVariant.h"
+#include "Integration/Core/CExpressionHandler.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Exception/CCafException.h"
+#include "Common/IAppConfig.h"
#include "CRecipientListRouterInstance.h"
using namespace Caf;
#ifndef CRecipientListRouterInstance_h
#define CRecipientListRouterInstance_h
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/Core/CAbstractMessageRouter.h"
+
namespace Caf {
class CRecipientListRouterInstance :
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "IVariant.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Exception/CCafException.h"
+#include "Common/IAppConfig.h"
#include "CRouterInstance.h"
using namespace Caf;
#ifndef CRouterInstance_h
#define CRouterInstnace_h
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Common/IAppContext.h"
+#include "Integration/Core/CExpressionHandler.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/Core/CAbstractMessageRouter.h"
+
namespace Caf {
class CRouterInstance :
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "IBean.h"
+#include "ICafObject.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationComponent.h"
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IMessageChannel.h"
+#include "Exception/CCafException.h"
#include "CServiceActivatorInstance.h"
#include "CObjectFactoryTables.h"
#ifndef CServiceActivatorInstance_h_
#define CServiceActivatorInstance_h_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/Core/CMessagingTemplate.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+
namespace Caf {
class CServiceActivatorInstance :
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
#include "CWireTapInstance.h"
CWireTapInstance::CWireTapInstance() :
#ifndef CWIRETAPINSTANCE_H_
#define CWIRETAPINSTANCE_H_
+#include "Integration/IChannelInterceptorInstance.h"
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ILifecycle.h"
+#include "Integration/Core/CChannelInterceptorAdapter.h"
+
namespace Caf {
class CWireTapInstance :
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
#include "CXPathHeaderEnricherItem.h"
using namespace Caf;
#include "stdafx.h"
#include "CXPathHeaderEnricherItem.h"
+#include "Common/IAppContext.h"
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Exception/CCafException.h"
+#include "Common/IAppConfig.h"
+
#include "CXPathHeaderEnricherTransformerInstance.h"
using namespace Caf;
#ifndef CXPathHeaderEnricherTransformerInstance_h_
#define CXPathHeaderEnricherTransformerInstance_h_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "CXPathHeaderEnricherItem.h"
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ITransformer.h"
+
namespace Caf {
class CXPathHeaderEnricherTransformerInstance :
//{{CAF_SUBSYSTEM}}
#include <CommonDefines.h>
-#include <Integration.h>
-namespace Caf {
- // Integration Contracts
- extern const char* _sObjIdIntegrationObjectFactory;
- extern const char* _sObjIdErrorChannel;
- extern const char* _sObjIdNullChannel;
- extern const char* _sObjIdHeaderExpressionInvoker;
-}
+#include "Integration/IIntegrationObject.h"
+#include <Integration.h>
namespace Caf {
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: May 18, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CINIFILEWITHOUTSECTION_H_
+#define CINIFILEWITHOUTSECTION_H_
+
+
+#include "Common/CCafRegex.h"
+#include "Common/CIniFile.h"
+
+namespace Caf {
+
+class CIniFileWithoutSection {
+public:
+ struct SIniEntry {
+ std::string _name;
+ std::string _valueRaw;
+ std::string _valueExpanded;
+ };
+ CAF_DECLARE_SMART_POINTER(SIniEntry);
+
+public:
+ CIniFileWithoutSection();
+ virtual ~CIniFileWithoutSection();
+
+public:
+ void initialize(const std::string& configFilePath);
+
+ std::deque<SmartPtrSIniEntry> getEntryCollection();
+
+ SmartPtrSIniEntry findOptionalEntry(
+ const std::string& keyName);
+
+ SmartPtrSIniEntry findRequiredEntry(
+ const std::string& keyName);
+
+ std::string findOptionalString(
+ const std::string& keyName);
+
+ std::string findRequiredString(
+ const std::string& keyName);
+
+ std::string findOptionalRawString(
+ const std::string& keyName);
+
+ std::string findRequiredRawString(
+ const std::string& keyName);
+
+ void log();
+
+ void setValue(
+ const std::string valueName,
+ const std::string valueValue);
+
+ void deleteValue(
+ const std::string valueName);
+
+private:
+ struct SReplacement {
+ SmartPtrCCafRegex _regex;
+ std::string _value;
+ };
+ CAF_DECLARE_SMART_POINTER(SReplacement);
+
+private:
+ std::deque<SmartPtrSIniEntry> parse(
+ const std::string& configFilePath) const;
+
+ SmartPtrSReplacement createReplacement(
+ const std::string& keyName,
+ const std::string& value) const;
+
+ SmartPtrSIniEntry createIniEntry(
+ const std::string& keyName,
+ const std::string& valueRaw,
+ const std::string& valueExpanded) const;
+
+ std::deque<std::string> loadTextFileIntoCollection(
+ const std::string& filePath) const;
+
+ void saveTextFile(
+ const std::deque<std::string> fileContents,
+ const std::string filePath) const;
+
+private:
+ bool _isInitialized;
+ std::string _configFilePath;
+ std::deque<SmartPtrSIniEntry> _entryCollection;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CIniFileWithoutSection);
+};
+
+CAF_DECLARE_SMART_POINTER(CIniFileWithoutSection);
+
+}
+
+#endif /* CINIFILEWITHOUTSECTION_H_ */
*/
#include "stdafx.h"
+
+#include "CIniFileWithoutSection.h"
+#include "Common/CIniFile.h"
+#include "Doc/CafCoreTypesDoc/COperationDoc.h"
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationDoc.h"
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+#include "Doc/SchemaTypesDoc/CClassInstancePropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CClassPropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassPropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassSubInstanceDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodParameterDoc.h"
+#include "Integration/IDocument.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Exception/CCafException.h"
#include "CConfigProvider.h"
+#include "IProviderRequest.h"
+#include "IProviderResponse.h"
using namespace Caf;
#ifndef CConfigProvider_h_
#define CConfigProvider_h_
+
+#include "IInvokedProvider.h"
+
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Common/CCafRegex.h"
+#include "Common/CIniFile.h"
#include "CIniFileWithoutSection.h"
+#include "Exception/CCafException.h"
using namespace Caf;
#include <DocUtils.h>
#include <ProviderFxLink.h>
-#include "../../Config_Provider/src/CConfigProvider.h"
-#include "../../Config_Provider/src/CIniFileWithoutSection.h"
+#include "CConfigProvider.h"
#endif // #ifndef stdafx_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: May 3, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CPackageInstaller_h_
+#define CPackageInstaller_h_
+
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentNameCollectionDoc.h"
+#include "Doc/CafInstallRequestDoc/CFullPackageElemDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallPackageSpecDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallProviderSpecDoc.h"
+#include "Doc/CafInstallRequestDoc/CMinPackageElemDoc.h"
+
+namespace Caf {
+
+/// Sends responses/errors back to the client.
+class CPackageInstaller {
+public:
+ typedef std::deque<SmartPtrCInstallPackageSpecDoc> CInstallPackageSpecCollection;
+ CAF_DECLARE_SMART_POINTER(CInstallPackageSpecCollection);
+
+ struct CInstallPackageMatch {
+ CInstallUtils::MATCH_STATUS _matchStatus;
+ SmartPtrCInstallPackageSpecDoc _matchedInstallPackageSpec;
+ };
+ CAF_DECLARE_SMART_POINTER(CInstallPackageMatch);
+
+public:
+ static void installPackages(
+ const std::deque<SmartPtrCFullPackageElemDoc>& fullPackageElemCollection,
+ const SmartPtrCAttachmentCollectionDoc& attachmentCollection,
+ const std::string& outputDir);
+
+ static void uninstallPackages(
+ const std::deque<SmartPtrCMinPackageElemDoc>& minPackageElemCollection,
+ const std::deque<SmartPtrCInstallProviderSpecDoc>& installProviderSpecCollection,
+ const std::string& outputDir);
+
+private:
+ static void installPackage(
+ const SmartPtrCInstallPackageSpecDoc& installPackageSpec,
+ const SmartPtrCInstallPackageSpecDoc& uninstallPackageSpec,
+ const std::string& outputDir);
+
+ static void executePackage(
+ const SmartPtrCInstallPackageSpecDoc& installPackageSpec,
+ const std::string& startupArgument,
+ const std::string& outputDir);
+
+ static SmartPtrCInstallPackageSpecDoc resolveAndCopyAttachments(
+ const SmartPtrCInstallPackageSpecDoc& installPackageSpec);
+
+ static void saveInstallPackageSpec(
+ const SmartPtrCInstallPackageSpecDoc& installPackageSpec);
+
+ static std::map<int32, SmartPtrCFullPackageElemDoc> orderFullPackageElems(
+ const std::deque<SmartPtrCFullPackageElemDoc>& fullPackageElemCollection);
+
+ static std::map<int32, SmartPtrCMinPackageElemDoc> orderMinPackageElems(
+ const std::deque<SmartPtrCMinPackageElemDoc>& minPackageElemCollection);
+
+ static SmartPtrCAttachmentCollectionDoc resolveAttachments(
+ const SmartPtrCAttachmentNameCollectionDoc& attachmentNameCollection,
+ const SmartPtrCAttachmentCollectionDoc& attachmentCollection);
+
+ static SmartPtrCAttachmentCollectionDoc copyAttachments(
+ const SmartPtrCAttachmentDoc& startupAttachment,
+ const SmartPtrCAttachmentDoc& packageAttachment,
+ const SmartPtrCAttachmentCollectionDoc& supportingAttachmentCollection,
+ const std::string& outputDir);
+
+ static SmartPtrCInstallPackageMatch matchInstallPackageSpec(
+ const SmartPtrCInstallPackageSpecDoc& installPackageSpec);
+
+ static SmartPtrCInstallPackageSpecCollection readInstallPackageSpecs();
+
+ static uint32 countPackageReferences(
+ const SmartPtrCInstallPackageSpecDoc& installPackageSpec,
+ const std::deque<SmartPtrCInstallProviderSpecDoc>& installProviderSpecCollection);
+
+ static void logDebug(
+ const std::string& message,
+ const SmartPtrCInstallPackageSpecDoc& installPackageSpec1,
+ const SmartPtrCInstallPackageSpecDoc& installPackageSpec2);
+
+ static void logWarn(
+ const std::string& message,
+ const SmartPtrCInstallPackageSpecDoc& installPackageSpec1,
+ const SmartPtrCInstallPackageSpecDoc& installPackageSpec2);
+
+ static void cleanupPackage(
+ const SmartPtrCInstallPackageMatch& installPackageMatch);
+
+private:
+ CAF_CM_DECLARE_NOCREATE(CPackageInstaller);
+};
+
+}
+
+#endif // #ifndef CPackageInstaller_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: May 3, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CProviderInstaller_h_
+#define CProviderInstaller_h_
+
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallProviderJobDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallProviderSpecDoc.h"
+#include "Doc/CafInstallRequestDoc/CUninstallProviderJobDoc.h"
+
+namespace Caf {
+
+class CProviderInstaller {
+public:
+ typedef std::deque<SmartPtrCInstallProviderSpecDoc> CInstallProviderSpecCollection;
+ CAF_DECLARE_SMART_POINTER(CInstallProviderSpecCollection);
+
+ struct CInstallProviderMatch {
+ CInstallUtils::MATCH_STATUS _matchStatus;
+ SmartPtrCInstallProviderSpecDoc _matchedInstallProviderSpec;
+ };
+ CAF_DECLARE_SMART_POINTER(CInstallProviderMatch);
+
+public:
+ static void installProvider(
+ const SmartPtrCInstallProviderJobDoc& installProviderJob,
+ const SmartPtrCAttachmentCollectionDoc& attachmentCollection,
+ const std::string& outputDir);
+
+ static void uninstallProvider(
+ const SmartPtrCUninstallProviderJobDoc& uninstallProviderJob,
+ const std::string& outputDir);
+
+ static SmartPtrCInstallProviderSpecCollection readInstallProviderSpecs();
+
+private:
+ static void installProviderLow(
+ const SmartPtrCInstallProviderJobDoc& installProviderJob,
+ const SmartPtrCAttachmentCollectionDoc& attachmentCollection,
+ const std::string& outputDir);
+
+ static void uninstallProviderLow(
+ const SmartPtrCInstallProviderSpecDoc& installProviderSpec,
+ const std::string& outputDir);
+
+ static void storeInstallProviderSpec(
+ const SmartPtrCInstallProviderSpecDoc& installProviderSpec);
+
+ static SmartPtrCInstallProviderMatch matchInstallProviderSpec(
+ const SmartPtrCInstallProviderSpecDoc& installProviderSpec);
+
+ static SmartPtrCInstallProviderSpecDoc createInstallProviderSpec(
+ const SmartPtrCInstallProviderJobDoc& installProviderJob);
+
+ static void logDebug(
+ const std::string& message,
+ const SmartPtrCInstallProviderSpecDoc& installProviderSpec1,
+ const SmartPtrCInstallProviderSpecDoc& installProviderSpec2);
+
+ static void logWarn(
+ const std::string& message,
+ const SmartPtrCInstallProviderSpecDoc& installProviderSpec1,
+ const SmartPtrCInstallProviderSpecDoc& installProviderSpec2);
+
+ static void cleanupProvider(
+ const SmartPtrCInstallProviderSpecDoc& installProviderSpec);
+
+ static std::string calcProviderFqn(
+ const SmartPtrCInstallProviderSpecDoc& installProviderSpec);
+
+ static std::string calcProviderFqn(
+ const SmartPtrCUninstallProviderJobDoc& uninstallProviderJob);
+
+private:
+ CAF_CM_DECLARE_NOCREATE(CProviderInstaller);
+};
+
+}
+
+#endif // #ifndef CProviderInstaller_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: July 25, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef _InstallProvider_IPackage_h_
+#define _InstallProvider_IPackage_h_
+
+
+#include "ICafObject.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+
+namespace Caf {
+
+/// TODO - describe interface
+struct __declspec(novtable)
+IPackage : public ICafObject {
+ CAF_DECL_UUID("e372d4bc-2384-4fcc-8042-f916f2d11bd2")
+
+ virtual void fullPackageElem(
+ const SmartPtrCAttachmentDoc packageAttachment,
+ const std::string arguments,
+ const SmartPtrCAttachmentCollectionDoc supportingAttachmentCollection,
+ const std::string outputDir) = 0;
+
+ virtual void unfullPackageElem(
+ const SmartPtrCAttachmentDoc packageAttachment,
+ const std::string arguments,
+ const SmartPtrCAttachmentCollectionDoc supportingAttachmentCollection,
+ const std::string outputDir) = 0;
+};
+
+CAF_DECLARE_SMART_INTERFACE_POINTER(IPackage);
+
+}
+
+#endif
*/
#include "stdafx.h"
+#include "Doc/CafInstallRequestDoc/CafInstallRequestDocTypes.h"
+
+#include "CProviderInstaller.h"
+#include "Doc/CafCoreTypesDoc/COperationDoc.h"
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallProviderJobDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallProviderSpecDoc.h"
+#include "Doc/CafInstallRequestDoc/CMinPackageElemDoc.h"
+#include "Doc/CafInstallRequestDoc/CUninstallProviderJobDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationDoc.h"
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+#include "Doc/SchemaTypesDoc/CClassInstancePropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CClassPropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassPropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassSubInstanceDoc.h"
+#include "Doc/SchemaTypesDoc/CInstanceParameterDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodParameterDoc.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Exception/CCafException.h"
#include "CInstallProvider.h"
+#include "IProviderResponse.h"
+#include "IProviderRequest.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
+#include "Integration/Caf/CCafMessagePayload.h"
using namespace Caf;
#ifndef CInstallProvider_h_
#define CInstallProvider_h_
+
+#include "IInvokedProvider.h"
+#include "Doc/CafInstallRequestDoc/CafInstallRequestDocTypes.h"
+
+#include "Doc/CafInstallRequestDoc/CInstallProviderSpecDoc.h"
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+#include "Exception/CCafException.h"
#include "CInstallUtils.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Exception/CCafException.h"
#include "CPackageExecutor.h"
using namespace Caf;
#ifndef CPackageExecutor_h_
#define CPackageExecutor_h_
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+
namespace Caf {
/// Utilities used in the install process.
*/
#include "stdafx.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlRoots.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentNameCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CInlineAttachmentDoc.h"
+#include "Doc/CafInstallRequestDoc/CFullPackageElemDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallPackageSpecDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallProviderSpecDoc.h"
+#include "Doc/CafInstallRequestDoc/CMinPackageElemDoc.h"
+#include "Doc/CafInstallRequestDoc/CPackageDefnDoc.h"
#include "CPackageInstaller.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/CafInstallRequestXmlRoots.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafInstallRequestDoc/CFullPackageElemDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallProviderJobDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallProviderSpecDoc.h"
+#include "Doc/CafInstallRequestDoc/CMinPackageElemDoc.h"
+#include "Doc/CafInstallRequestDoc/CUninstallProviderJobDoc.h"
#include "CProviderInstaller.h"
+#include "CPackageInstaller.h"
using namespace Caf;
//{{CAF_SUBSYSTEM}}
#include <CommonDefines.h>
-#include <DocXml.h>
#include <DocUtils.h>
#include <Integration.h>
#include <ProviderFxLink.h>
extern const char* _sInstallProviderSpecFilename;
}
-#include "IPackage.h"
#include "CInstallUtils.h"
#include "CPathBuilder.h"
#include "CPackageExecutor.h"
-#include "CPackageInstaller.h"
-#include "CProviderInstaller.h"
#include "CInstallProvider.h"
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/CafCoreTypesDoc/COperationDoc.h"
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationDoc.h"
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodParameterDoc.h"
+#include "Exception/CCafException.h"
#include "CRemoteCommandProvider.h"
+#include "IProviderRequest.h"
using namespace Caf;
#ifndef CRemoteCommandProvider_h_
#define CRemoteCommandProvider_h_
+
+#include "IInvokedProvider.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
//{{CAF_SUBSYSTEM}}
#include <CommonDefines.h>
-#include <DocXml.h>
#include <DocUtils.h>
#include <ProviderFxLink.h>
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/CafCoreTypesDoc/COperationDoc.h"
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationDoc.h"
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+#include "Doc/SchemaTypesDoc/CClassPropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassPropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodParameterDoc.h"
+#include "Exception/CCafException.h"
#include "CTestInfraProvider.h"
+#include "IProviderResponse.h"
+#include "IProviderRequest.h"
using namespace Caf;
#ifndef CTestInfraProvider_h_
#define CTestInfraProvider_h_
+
+#include "IInvokedProvider.h"
+
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CManagementAgentHostWork_h_
+#define CManagementAgentHostWork_h_
+
+#include "Common/IWork.h"
+
+namespace Caf {
+
+/// Sends responses/errors back to the client.
+class CManagementAgentHostWork :
+ public IWork
+{
+public:
+ CManagementAgentHostWork();
+ virtual ~CManagementAgentHostWork();
+
+public:
+ void initialize();
+
+public: // IWork
+ void doWork();
+ void stopWork();
+
+private:
+ bool _isInitialized;
+ bool _isWorking;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CManagementAgentHostWork);
+};
+
+CAF_DECLARE_SMART_POINTER(CManagementAgentHostWork);
+
+}
+
+#endif // #ifndef CManagementAgentHostWork_h_
*/
#include "stdafx.h"
+
+#include "Integration/Core/CIntegrationAppContext.h"
#include "CManagementAgentHostWork.h"
+#include "Common/CLoggingUtils.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "CManagementAgentHostWork.h"
+#include "Common/CLoggingUtils.h"
+#include "Exception/CCafException.h"
+#include "Common/IAppConfig.h"
#ifndef WIN32
#include <syslog.h>
#endif
return 1;
}
- const std::string procPath = argv[0];
+ const std::string procPath(argv[0]);
CDaemonUtils::MakeDaemon(
argc,
argv,
#include "CWinService.h"
#endif
-#include "CManagementAgentHostWork.h"
#endif // #ifndef stdafx_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CAttachmentRequestTransformerInstance_h_
+#define CAttachmentRequestTransformerInstance_h_
+
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ITransformer.h"
+
+namespace Caf {
+
+class CAttachmentRequestTransformerInstance :
+ public TCafSubSystemObjectRoot<CAttachmentRequestTransformerInstance>,
+ public IIntegrationObject,
+ public IIntegrationComponentInstance,
+ public ITransformer {
+public:
+ struct SExpandedFileAlias {
+ std::string _filePath;
+ std::string _encoding;
+ };
+ CAF_DECLARE_SMART_POINTER(SExpandedFileAlias);
+
+public:
+ CAttachmentRequestTransformerInstance();
+ virtual ~CAttachmentRequestTransformerInstance();
+
+ CAF_DECLARE_OBJECT_IDENTIFIER(_sObjIdAttachmentRequestTransformerInstance)
+
+ CAF_BEGIN_INTERFACE_MAP(CAttachmentRequestTransformerInstance)
+ CAF_INTERFACE_ENTRY(IIntegrationObject)
+ CAF_INTERFACE_ENTRY(IIntegrationComponentInstance)
+ CAF_INTERFACE_ENTRY(ITransformer)
+ CAF_END_INTERFACE_MAP()
+
+public: // IIntegrationObject
+ void initialize(
+ const IBean::Cargs& ctorArgs,
+ const IBean::Cprops& properties,
+ const SmartPtrIDocument& configSection);
+
+ std::string getId() const;
+
+public: // IIntegrationComponentInstance
+ void wire(
+ const SmartPtrIAppContext& appContext,
+ const SmartPtrIChannelResolver& channelResolver);
+
+public: // ITransformer
+ SmartPtrIIntMessage transformMessage(
+ const SmartPtrIIntMessage& message);
+
+private:
+ std::string calcOutputDirPath(
+ const SmartPtrCPayloadEnvelopeDoc& payloadEnvelope) const;
+
+ std::string calcFilePath(
+ const UriUtils::SUriRecord& uriRecord) const;
+
+ std::string calcRelPath(
+ const std::string& filePath,
+ const UriUtils::SUriRecord& uriRecord) const;
+
+ void moveFile(
+ const std::string& srcFilePath,
+ const std::string& dstFilePath) const;
+
+private:
+ bool _isInitialized;
+ std::string _id;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CAttachmentRequestTransformerInstance);
+};
+
+}
+
+#endif // #ifndef CAttachmentRequestTransformerInstance_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef _MaIntegration_CConfigEnvReadingMessageSource_h_
+#define _MaIntegration_CConfigEnvReadingMessageSource_h_
+
+#include "IConfigEnv.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/Core/CAbstractPollableChannel.h"
+
+namespace Caf {
+
+class CConfigEnvReadingMessageSource :
+ public CAbstractPollableChannel {
+private:
+ typedef std::map<std::string, bool> CFileCollection;
+ CAF_DECLARE_SMART_POINTER(CFileCollection);
+
+public:
+ CConfigEnvReadingMessageSource();
+ virtual ~CConfigEnvReadingMessageSource();
+
+public:
+ void initialize(
+ const SmartPtrIDocument& configSection,
+ const SmartPtrIConfigEnv& configEnv);
+
+protected: // CAbstractPollableChannel
+ bool doSend(
+ const SmartPtrIIntMessage& message,
+ int32 timeout);
+
+ SmartPtrIIntMessage doReceive(const int32 timeout);
+
+private:
+ bool _isInitialized;
+ std::string _id;
+
+ SmartPtrIConfigEnv _configEnv;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CConfigEnvReadingMessageSource);
+};
+
+CAF_DECLARE_SMART_POINTER(CConfigEnvReadingMessageSource);
+
+}
+
+#endif // #ifndef _MaIntegration_CConfigEnvReadingMessageSource_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CDiagToMgmtRequestTransformerInstance_h_
+#define CDiagToMgmtRequestTransformerInstance_h_
+
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "CEnvelopeToPayloadTransformerInstance.h"
+#include "Common/IAppContext.h"
+#include "Doc/CafCoreTypesDoc/COperationDoc.h"
+#include "Doc/DiagTypesDoc/CDiagCollectInstancesDoc.h"
+#include "Doc/DiagTypesDoc/CDiagDeleteValueCollectionDoc.h"
+#include "Doc/DiagTypesDoc/CDiagSetValueCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationDoc.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ITransformer.h"
+
+namespace Caf {
+
+class CDiagToMgmtRequestTransformerInstance :
+ public TCafSubSystemObjectRoot<CDiagToMgmtRequestTransformerInstance>,
+ public IIntegrationObject,
+ public IIntegrationComponentInstance,
+ public ITransformer {
+public:
+ struct SExpandedFileAlias {
+ std::string _filePath;
+ std::string _encoding;
+ };
+ CAF_DECLARE_SMART_POINTER(SExpandedFileAlias);
+
+public:
+ CDiagToMgmtRequestTransformerInstance();
+ virtual ~CDiagToMgmtRequestTransformerInstance();
+
+ CAF_DECLARE_OBJECT_IDENTIFIER(_sObjIdDiagToMgmtRequestTransformerInstance)
+
+ CAF_BEGIN_INTERFACE_MAP(CDiagToMgmtRequestTransformerInstance)
+ CAF_INTERFACE_ENTRY(IIntegrationObject)
+ CAF_INTERFACE_ENTRY(IIntegrationComponentInstance)
+ CAF_INTERFACE_ENTRY(ITransformer)
+ CAF_END_INTERFACE_MAP()
+
+public: // IIntegrationObject
+ void initialize(
+ const IBean::Cargs& ctorArgs,
+ const IBean::Cprops& properties,
+ const SmartPtrIDocument& configSection);
+
+ std::string getId() const;
+
+public: // IIntegrationComponentInstance
+ void wire(
+ const SmartPtrIAppContext& appContext,
+ const SmartPtrIChannelResolver& channelResolver);
+
+public: // ITransformer
+ SmartPtrIIntMessage transformMessage(
+ const SmartPtrIIntMessage& message);
+
+private:
+ SmartPtrCMgmtCollectInstancesCollectionDoc createMgmtCollectInstancesCollection(
+ const SmartPtrCDiagCollectInstancesDoc& diagCollectInstances) const;
+
+ SmartPtrCMgmtInvokeOperationCollectionDoc createMgmtInvokeOperationCollection(
+ const SmartPtrCDiagSetValueCollectionDoc& diagSetValueCollection,
+ const SmartPtrCDiagDeleteValueCollectionDoc& diagDeleteValueCollection) const;
+
+ SmartPtrCMgmtCollectInstancesDoc createCollectInstances(
+ const UUID& jobId,
+ const SmartPtrSExpandedFileAlias& expandedFileAlias) const;
+
+ SmartPtrCOperationDoc createSetValueOperation(
+ const std::string& valueName,
+ const std::deque<std::string>& valueCollection,
+ const SmartPtrSExpandedFileAlias& expandedFileAlias) const;
+
+ SmartPtrCOperationDoc createDeleteValueOperation(
+ const std::string& valueName,
+ const SmartPtrSExpandedFileAlias& expandedFileAlias) const;
+
+ SmartPtrCMgmtInvokeOperationDoc createInvokeOperation(
+ const UUID& jobId,
+ const SmartPtrCOperationDoc operation) const;
+
+ std::deque<CDiagToMgmtRequestTransformerInstance::SmartPtrSExpandedFileAlias> expandFileAliases() const;
+
+ SmartPtrSExpandedFileAlias expandFileAlias(
+ const std::string& fileAlias) const;
+
+ std::string findUriParameter(
+ const std::string& parameterName,
+ const UriUtils::SUriRecord& uri) const;
+
+private:
+ bool _isInitialized;
+ std::string _id;
+
+ std::string _fileAliasPrefix;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CDiagToMgmtRequestTransformerInstance);
+};
+
+}
+
+#endif // #ifndef CDiagToMgmtRequestTransformerInstance_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef _MaIntegration_CMonitorReadingMessageSource_h_
+#define _MaIntegration_CMonitorReadingMessageSource_h_
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/Core/CAbstractPollableChannel.h"
+
+namespace Caf {
+
+class CMonitorReadingMessageSource :
+ public CAbstractPollableChannel {
+private:
+ typedef std::map<std::string, bool> CFileCollection;
+ CAF_DECLARE_SMART_POINTER(CFileCollection);
+
+public:
+ CMonitorReadingMessageSource();
+ virtual ~CMonitorReadingMessageSource();
+
+public:
+ void initialize(
+ const SmartPtrIDocument& configSection);
+
+protected: // CAbstractPollableChannel
+ bool doSend(
+ const SmartPtrIIntMessage& message,
+ int32 timeout);
+
+ SmartPtrIIntMessage doReceive(const int32 timeout);
+
+private:
+ bool isListenerRunning() const;
+
+ void startListener(
+ const std::string& reason) const;
+
+ void stopListener(
+ const std::string& reason) const;
+
+ void restartListener(
+ const std::string& reason) const;
+
+ std::string executeScript(
+ const std::string& scriptPath,
+ const std::string& scriptResultsDir) const;
+
+ bool areSystemResourcesLow() const;
+
+ bool isTimeForListenerRestart() const;
+
+ uint64 calcListenerRestartMs() const;
+
+private:
+ bool _isInitialized;
+ std::string _id;
+
+ uint64 _listenerStartTimeMs;
+ uint64 _listenerRestartMs;
+
+ std::string _monitorDir;
+ std::string _restartListenerPath;
+ std::string _listenerConfiguredStage2Path;
+
+ std::string _scriptOutputDir;
+ std::string _stopListenerScript;
+ std::string _startListenerScript;
+ std::string _isListenerRunningScript;
+
+ std::string _listenerStartupType;
+ int32 _listenerRetryCnt;
+ int32 _listenerRetryMax;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CMonitorReadingMessageSource);
+};
+
+CAF_DECLARE_SMART_POINTER(CMonitorReadingMessageSource);
+
+}
+
+#endif // #ifndef _MaIntegration_CMonitorReadingMessageSource_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef _MaIntegration_CPersistenceReadingMessageSource_h_
+#define _MaIntegration_CPersistenceReadingMessageSource_h_
+
+#include "IPersistence.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/Core/CAbstractPollableChannel.h"
+
+namespace Caf {
+
+class CPersistenceReadingMessageSource :
+ public CAbstractPollableChannel {
+private:
+ typedef std::map<std::string, bool> CFileCollection;
+ CAF_DECLARE_SMART_POINTER(CFileCollection);
+
+public:
+ CPersistenceReadingMessageSource();
+ virtual ~CPersistenceReadingMessageSource();
+
+public:
+ void initialize(
+ const SmartPtrIDocument& configSection,
+ const SmartPtrIPersistence& persistence);
+
+protected: // CAbstractPollableChannel
+ bool doSend(
+ const SmartPtrIIntMessage& message,
+ int32 timeout);
+
+ SmartPtrIIntMessage doReceive(const int32 timeout);
+
+private:
+ bool _isInitialized;
+ std::string _id;
+
+ SmartPtrIPersistence _persistence;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CPersistenceReadingMessageSource);
+};
+
+CAF_DECLARE_SMART_POINTER(CPersistenceReadingMessageSource);
+
+}
+
+#endif // #ifndef _MaIntegration_CPersistenceReadingMessageSource_h_
--- /dev/null
+/*
+ * Author: brets
+ * Created: Nov 20, 2015
+ *
+ * Copyright (c) 2015 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CProviderExecutorRequest_h_
+#define CProviderExecutorRequest_h_
+
+
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+#include "Integration/IIntMessage.h"
+
+namespace Caf {
+
+/// TODO - describe class
+class CProviderExecutorRequest {
+public:
+ CProviderExecutorRequest();
+ virtual ~CProviderExecutorRequest();
+
+public:
+ void initialize(const SmartPtrIIntMessage& request);
+
+ const SmartPtrIIntMessage getInternalRequest() const;
+ const SmartPtrCProviderRequestDoc getRequest() const;
+ const std::string& getOutputDirectory() const;
+ const std::string& getProviderUri() const;
+
+private:
+ bool _isInitialized;
+ SmartPtrIIntMessage _internalRequest;
+ SmartPtrCProviderRequestDoc _request;
+ std::string _outputDir;
+ std::string _providerUri;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CProviderExecutorRequest);
+};
+
+CAF_DECLARE_SMART_POINTER(CProviderExecutorRequest);
+
+}
+
+#endif // #ifndef CProviderExecutorRequest_h_
--- /dev/null
+/*
+ * Author: brets
+ * Created: Nov 20, 2015
+ *
+ * Copyright (c) 2015 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CProviderExecutorRequestHandler_h_
+#define CProviderExecutorRequestHandler_h_
+
+
+#include "Integration/IRunnable.h"
+
+#include "CProviderExecutorRequest.h"
+#include "Common/CAutoMutex.h"
+#include "Integration/IErrorHandler.h"
+#include "Integration/ITaskExecutor.h"
+#include "Integration/ITransformer.h"
+
+namespace Caf {
+
+/// TODO - describe class
+class CProviderExecutorRequestHandler : public IRunnable {
+public:
+ CProviderExecutorRequestHandler();
+ virtual ~CProviderExecutorRequestHandler();
+
+public:
+ void initialize(const std::string& providerUri,
+ const SmartPtrITransformer beginImpersonationTransformer,
+ const SmartPtrITransformer endImpersonationTransformer,
+ const SmartPtrIErrorHandler errorHandler);
+
+ void handleRequest(const SmartPtrCProviderExecutorRequest request);
+
+public: // IRunnable
+ void run();
+ void cancel();
+
+private:
+ SmartPtrCProviderExecutorRequest getNextPendingRequest();
+
+ void processRequest(const SmartPtrCProviderExecutorRequest& request) const;
+
+ void executeRequestAsync(
+ const SmartPtrCProviderExecutorRequest& request);
+
+ std::deque<SmartPtrITaskExecutor> removeFinishedTaskExecutors(
+ const std::deque<SmartPtrITaskExecutor> taskExecutors) const;
+
+private:
+ bool _isInitialized;
+ bool _isCancelled;
+ std::string _providerPath;
+ std::string _providerUri;
+ std::deque<SmartPtrITaskExecutor> _taskExecutors;
+ SmartPtrCAutoMutex _mutex;
+ std::deque<SmartPtrCProviderExecutorRequest> _pendingRequests;
+ SmartPtrITransformer _beginImpersonationTransformer;
+ SmartPtrITransformer _endImpersonationTransformer;
+ SmartPtrIErrorHandler _errorHandler;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_CREATE_THREADSAFE;
+ CAF_CM_DECLARE_NOCOPY(CProviderExecutorRequestHandler);
+};
+
+CAF_DECLARE_SMART_POINTER(CProviderExecutorRequestHandler);
+
+}
+
+#endif // #ifndef CProviderExecutorRequestHandler_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CResponseFactory_h_
+#define CResponseFactory_h_
+
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectSchemaRequestDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+#include "Doc/ResponseDoc/CManifestCollectionDoc.h"
+#include "Doc/ResponseDoc/CManifestDoc.h"
+#include "Doc/ResponseDoc/CResponseDoc.h"
+
+namespace Caf {
+
+/// Builds the response XML document.
+class CResponseFactory {
+public:
+ static SmartPtrCResponseDoc createResponse(
+ const SmartPtrCProviderCollectSchemaRequestDoc& providerCollectSchemaRequest,
+ const std::string& outputDir,
+ const std::string& schemaCacheDir);
+
+ static SmartPtrCResponseDoc createResponse(
+ const SmartPtrCProviderRequestDoc& providerRequest,
+ const std::string& outputDir);
+
+private:
+ static void findAndStoreGlobalAttachmentsAndProviderResponses(
+ const std::string& outputDir,
+ const std::string& schemaCacheDir,
+ SmartPtrCManifestCollectionDoc& manifestCollection,
+ SmartPtrCAttachmentCollectionDoc& attachmentCollection);
+
+ static void findAndStoreProviderResponses(
+ const std::string& outputDir,
+ const std::string& schemaCacheDir,
+ std::map<std::string, SmartPtrCAttachmentDoc>& globalAttachmentCollection,
+ std::deque<SmartPtrCManifestDoc>& manifestCollection);
+
+ static void findAndStoreGlobalAttachments(
+ const std::string& outputDir,
+ std::map<std::string, SmartPtrCAttachmentDoc>& globalAttachmentCollection);
+
+ static void resolveAndStoreGlobalAttachments(
+ const std::deque<SmartPtrCAttachmentDoc> attachmentCollectionInner,
+ const std::string& outputDir,
+ const std::string& schemaCacheDir,
+ std::map<std::string, SmartPtrCAttachmentDoc>& globalAttachmentCollection);
+
+ static void storeGlobalAttachments(
+ const std::string& attachmentName,
+ const std::string& attachmentType,
+ const std::deque<std::string>& attachmentPathCollection,
+ const std::string& baseDir,
+ std::map<std::string, SmartPtrCAttachmentDoc>& attachmentCollection);
+
+ static void storeGlobalAttachment(
+ const std::string& attachmentName,
+ const std::string& attachmentType,
+ const std::string& attachmentPath,
+ const std::string& baseDir,
+ std::map<std::string, SmartPtrCAttachmentDoc>& attachmentCollection);
+
+ static void resolveAttachmentPath(
+ const std::string& attachmentPath,
+ const std::string& baseDir,
+ std::string& relPath,
+ std::string& attachmentPathNew);
+
+ static std::string removeLeadingChars(
+ const std::string& sourceStr,
+ const char leadingChar);
+
+private:
+ CAF_CM_DECLARE_NOCREATE(CResponseFactory);
+};
+
+CAF_DECLARE_SMART_POINTER(CResponseFactory);
+
+}
+
+#endif // #ifndef CResponseFactory_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CSchemaCacheManager_h_
+#define CSchemaCacheManager_h_
+
+
+#include "Doc/CafCoreTypesDoc/CFullyQualifiedClassGroupDoc.h"
+#include "Doc/ProviderInfraDoc/CSchemaSummaryDoc.h"
+
+namespace Caf {
+
+/// Simple container class for identifying a class.
+class CClassId {
+public:
+ SmartPtrCFullyQualifiedClassGroupDoc _fqc;
+ std::string toString() const {
+ return _fqc->getClassNamespace() + "::" + _fqc->getClassName() + "::" + _fqc->getClassVersion();
+ }
+};
+bool operator< (const CClassId& lhs, const CClassId& rhs);
+
+/// Creates a provider request.
+class CSchemaCacheManager {
+private:
+ typedef std::map<CClassId, std::string> CClassCollection;
+
+public:
+ CSchemaCacheManager();
+ virtual ~CSchemaCacheManager();
+
+public:
+ void initialize();
+
+ std::string findProvider(
+ const SmartPtrCFullyQualifiedClassGroupDoc& fqc);
+
+private:
+ void processSchemaSummaries(
+ const std::string& schemaCacheDirPath,
+ CClassCollection& classCollection) const;
+
+ void addNewClasses(
+ const SmartPtrCSchemaSummaryDoc& schemaSummary,
+ const std::string& schemaSummaryFilePath,
+ CClassCollection& classCollection) const;
+
+ void waitForSchemaCacheCreation(
+ const std::string& schemaCacheDir,
+ const uint16 maxWaitSecs) const;
+
+private:
+ bool _isInitialized;
+ std::string _schemaCacheDirPath;
+ CClassCollection _classCollection;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CSchemaCacheManager);
+};
+
+CAF_DECLARE_SMART_POINTER(CSchemaCacheManager);
+
+}
+
+#endif // #ifndef CSchemaCacheManager_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Oct 22, 2010
+ *
+ * Copyright (c) 2010 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CSinglePmeRequestSplitterInstance_h_
+#define CSinglePmeRequestSplitterInstance_h_
+
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "CSchemaCacheManager.h"
+#include "Common/IAppContext.h"
+#include "Doc/CafCoreTypesDoc/CClassSpecifierDoc.h"
+#include "Doc/CafCoreTypesDoc/CFullyQualifiedClassGroupDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Doc/MgmtRequestDoc/CMgmtRequestDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectSchemaDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectSchemaRequestDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestHeaderDoc.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IMessageSplitter.h"
+
+namespace Caf {
+
+// Moved the following typedefs from the class because Windows produced
+// the warning "decorated name length exceeded, name was truncated" because
+// their name included CSinglePmeRequestSplitterInstance.
+struct CSplitterJob {
+ SmartPtrCFullyQualifiedClassGroupDoc _fqc;
+ SmartPtrCMgmtCollectInstancesDoc _mgmtCollectInstances;
+ SmartPtrCMgmtInvokeOperationDoc _mgmtInvokeOperation;
+};
+CAF_DECLARE_SMART_POINTER(CSplitterJob);
+
+typedef std::deque<SmartPtrCSplitterJob> CSplitterJobsCollection;
+CAF_DECLARE_SMART_POINTER(CSplitterJobsCollection);
+
+typedef std::map<std::string, SmartPtrCSplitterJobsCollection> CProviderJobsCollection;
+CAF_DECLARE_SMART_POINTER(CProviderJobsCollection);
+
+class CSinglePmeRequestSplitterInstance :
+ public TCafSubSystemObjectRoot<CSinglePmeRequestSplitterInstance>,
+ public IIntegrationObject,
+ public IIntegrationComponentInstance,
+ public IMessageSplitter {
+private:
+ typedef std::deque<SmartPtrCFullyQualifiedClassGroupDoc> CClassCollection;
+ CAF_DECLARE_SMART_POINTER(CClassCollection);
+
+public:
+ CSinglePmeRequestSplitterInstance();
+ virtual ~CSinglePmeRequestSplitterInstance();
+
+ CAF_DECLARE_OBJECT_IDENTIFIER(_sObjIdSinglePmeRequestSplitterInstance)
+
+ CAF_BEGIN_INTERFACE_MAP(CSinglePmeRequestSplitterInstance)
+ CAF_INTERFACE_ENTRY(IIntegrationObject)
+ CAF_INTERFACE_ENTRY(IIntegrationComponentInstance)
+ CAF_INTERFACE_ENTRY(IMessageSplitter)
+ CAF_END_INTERFACE_MAP()
+
+public: // IIntegrationObject
+ void initialize(
+ const IBean::Cargs& ctorArgs,
+ const IBean::Cprops& properties,
+ const SmartPtrIDocument& configSection);
+
+ std::string getId() const;
+
+public: // IIntegrationComponentInstance
+ void wire(
+ const SmartPtrIAppContext& appContext,
+ const SmartPtrIChannelResolver& channelResolver);
+
+public: // IMessageSplitter
+ SmartPtrCMessageCollection splitMessage(
+ const SmartPtrIIntMessage& message);
+
+private:
+ SmartPtrCProviderCollectSchemaRequestDoc createCollectSchemaRequest(
+ const SmartPtrCMgmtRequestDoc& mgmtRequest,
+ const SmartPtrCMgmtCollectSchemaDoc& mgmtCollectSchema,
+ const SmartPtrCProviderRequestHeaderDoc& providerRequestHeader,
+ const std::string& outputDir) const;
+
+ SmartPtrCProviderRequestDoc createProviderRequest(
+ const SmartPtrCMgmtRequestDoc& mgmtRequest,
+ const SmartPtrCSplitterJobsCollection& jobsCollection,
+ const SmartPtrCProviderRequestHeaderDoc& providerRequestHeader,
+ const std::string& outputDir) const;
+
+ void addCollectInstancesJobs(
+ const SmartPtrCMgmtCollectInstancesCollectionDoc& mgmtCollectInstancesCollection,
+ SmartPtrCProviderJobsCollection& providerJobsCollection) const;
+
+ void addInvokeOperationJobs(
+ const SmartPtrCMgmtInvokeOperationCollectionDoc& mgmtInvokeOperationCollection,
+ SmartPtrCProviderJobsCollection& providerJobsCollection) const;
+
+ SmartPtrCClassCollection resolveClassSpecifier(
+ const SmartPtrCClassSpecifierDoc& classSpecifier) const;
+
+ std::string findProviderUri(
+ const SmartPtrCFullyQualifiedClassGroupDoc& fqc) const;
+
+ void createDirectory(
+ const std::string& directory) const;
+
+ void saveRequest(
+ const std::string& outputDir,
+ const SmartPtrCDynamicByteArray& payload) const;
+
+ SmartPtrCProviderRequestHeaderDoc convertRequestHeader(
+ const SmartPtrCRequestHeaderDoc& requestHeader) const;
+
+private:
+ bool _isInitialized;
+ std::string _id;
+ SmartPtrCSchemaCacheManager _schemaCacheManager;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CSinglePmeRequestSplitterInstance);
+};
+
+}
+
+#endif // #ifndef CSinglePmeRequestSplitterInstance_h_
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Nov 12, 2015
+ *
+ * Copyright (c) 2015 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef _MaContracts_IConfigEnv_h_
+#define _MaContracts_IConfigEnv_h_
+
+
+#include "ICafObject.h"
+
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "IPersistence.h"
+
+namespace Caf {
+
+/// TODO - describe interface
+struct __declspec(novtable)
+IConfigEnv : public ICafObject {
+ CAF_DECL_UUID("dea6cea4-9385-458e-b549-d05640382da6")
+
+ virtual void initialize(
+ const SmartPtrIPersistence& persistenceRemove = SmartPtrIPersistence()) = 0;
+
+ virtual SmartPtrCPersistenceDoc getUpdated(
+ const int32 timeout) = 0;
+
+ virtual void update(
+ const SmartPtrCPersistenceDoc& persistence) = 0;
+};
+
+CAF_DECLARE_SMART_INTERFACE_POINTER(IConfigEnv);
+
+}
+
+#endif
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Nov 12, 2015
+ *
+ * Copyright (c) 2015 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef _MaContracts_IPersistence_h_
+#define _MaContracts_IPersistence_h_
+
+
+#include "ICafObject.h"
+
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+
+namespace Caf {
+
+/// TODO - describe interface
+struct __declspec(novtable)
+IPersistence : public ICafObject {
+ CAF_DECL_UUID("5b48f8ef-7023-4583-9d2d-b15ae566b0cc")
+
+ virtual void initialize() = 0;
+
+ virtual SmartPtrCPersistenceDoc getUpdated(
+ const int32 timeout) = 0;
+
+ virtual void update(
+ const SmartPtrCPersistenceDoc& persistence) = 0;
+
+ virtual void remove(
+ const SmartPtrCPersistenceDoc& persistence) = 0;
+};
+
+CAF_DECLARE_SMART_INTERFACE_POINTER(IPersistence);
+
+}
+
+#endif
--- /dev/null
+/*
+ * Created on: Nov 11, 2015
+ * Author: bwilliams
+ *
+ * Copyright (c) 2015 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef _MaIntegration_h_
+#define _MaIntegration_h_
+
+namespace Caf {
+
+/** @brief CAF AMQP Integration */
+namespace MaIntegration {
+ extern const char* _sObjIdIntegrationObjects;
+}}
+
+namespace Caf {
+ extern const char* _sObjIdCollectSchemaExecutor;
+ extern const char* _sObjIdProviderCollectSchemaExecutor;
+ extern const char* _sObjIdProviderExecutor;
+ extern const char* _sObjIdSinglePmeRequestSplitterInstance;
+ extern const char* _sObjIdSinglePmeRequestSplitter;
+ extern const char* _sObjIdDiagToMgmtRequestTransformerInstance;
+ extern const char* _sObjIdDiagToMgmtRequestTransformer;
+ extern const char* _sObjIdInstallToMgmtRequestTransformerInstance;
+ extern const char* _sObjIdInstallToMgmtRequestTransformer;
+
+ extern const char* _sObjIdAttachmentRequestTransformerInstance;
+ extern const char* _sObjIdAttachmentRequestTransformer;
+ extern const char* _sObjIdVersionTransformerInstance;
+ extern const char* _sObjIdVersionTransformer;
+
+ extern const char* _sObjIdPersistenceNamespaceDb;
+ extern const char* _sObjIdConfigEnv;
+}
+
+#endif /* _MaIntegration_h_ */
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
#include "CAttachmentRequestTransformer.h"
using namespace Caf;
#ifndef CAttachmentRequestTransformer_h_
#define CAttachmentRequestTransformer_h_
+
+#include "IBean.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
#include "CAttachmentRequestTransformerInstance.h"
+#include "Exception/CCafException.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
+#include "Integration/Caf/CCafMessageCreator.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXmlRoots.h"
+
+#include "Integration/Caf/CCafMessageHeaders.h"
+#include "Common/CLoggingSetter.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectSchemaRequestDoc.h"
+#include "Doc/ResponseDoc/CResponseDoc.h"
+#include "Integration/IIntMessage.h"
#include "CCollectSchemaExecutor.h"
+#include "CResponseFactory.h"
+#include "Integration/Caf/CCafMessageCreator.h"
using namespace Caf;
#ifndef CCollectSchemaExecutor_h_
#define CCollectSchemaExecutor_h_
+
+#include "IBean.h"
+
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageProcessor.h"
+
using namespace Caf;
/// TODO - describe class
*/
#include "stdafx.h"
+
+#include "Doc/PersistenceDoc/CLocalSecurityDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolDoc.h"
+#include "IPersistence.h"
+#include "Exception/CCafException.h"
#include "CConfigEnv.h"
using namespace Caf;
#ifndef _MaIntegration_CConfigEnv_h_
#define _MaIntegration_CConfigEnv_h_
+
+#include "IBean.h"
+
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "IPersistence.h"
+#include "IConfigEnv.h"
+
using namespace Caf;
/// TODO - describe class
*/
#include "stdafx.h"
-#include "CConfigEnvInboundChannelAdapterInstance.h"
+
#include "CConfigEnvReadingMessageSource.h"
+#include "Common/IAppContext.h"
+#include "IBean.h"
+#include "IConfigEnv.h"
+#include "Integration/Core/CErrorHandler.h"
+#include "Integration/Core/CMessageHandler.h"
+#include "Integration/Core/CSimpleAsyncTaskExecutor.h"
+#include "Integration/Core/CSourcePollingChannelAdapter.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IMessageChannel.h"
+#include "CConfigEnvInboundChannelAdapterInstance.h"
using namespace Caf;
#ifndef CConfigEnvInboundChannelAdapterInstance_h_
#define CConfigEnvInboundChannelAdapterInstance_h_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "IConfigEnv.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/ITaskExecutor.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ILifecycle.h"
+#include "Integration/IMessageProducer.h"
+
namespace Caf {
class CConfigEnvInboundChannelAdapterInstance :
*/
#include "stdafx.h"
+
+#include "Doc/PersistenceDoc/CCertCollectionDoc.h"
+#include "Doc/PersistenceDoc/CLocalSecurityDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolCollectionDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolDoc.h"
+#include "Exception/CCafException.h"
#include "CConfigEnvMerge.h"
#ifdef WIN32
#ifndef _MaIntegration_CConfigEnvMerge_h_
#define _MaIntegration_CConfigEnvMerge_h_
+
+#include "Doc/PersistenceDoc/CCertCollectionDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolDoc.h"
+
using namespace Caf;
/// TODO - describe class
*/
#include "stdafx.h"
+
+#include "Doc/DocXml/PersistenceXml/PersistenceXmlRoots.h"
+
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "IConfigEnv.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
#include "CConfigEnvMessageHandler.h"
using namespace Caf;
#ifndef _MaIntegration_CConfigEnvMessageHandler_h_
#define _MaIntegration_CConfigEnvMessageHandler_h_
+
+#include "Integration/IErrorProcessor.h"
+
+#include "IConfigEnv.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageHandler.h"
+
namespace Caf {
class CConfigEnvMessageHandler :
*/
#include "stdafx.h"
+
+#include "CConfigEnvMessageHandler.h"
+#include "Common/IAppContext.h"
+#include "IBean.h"
+#include "IConfigEnv.h"
+#include "IPersistence.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/IMessageHandler.h"
#include "CConfigEnvOutboundChannelAdapterInstance.h"
using namespace Caf;
#ifndef CConfigEnvOutboundChannelAdapterInstance_h_
#define CConfigEnvOutboundChannelAdapterInstance_h_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "IConfigEnv.h"
+#include "IPersistence.h"
+#include "Integration/Core/CMessagingTemplate.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ILifecycle.h"
+
namespace Caf {
class CConfigEnvOutboundChannelAdapterInstance :
*/
#include "stdafx.h"
+
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "IConfigEnv.h"
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
#include "CConfigEnvReadingMessageSource.h"
+#include "Exception/CCafException.h"
+#include "Doc/DocXml/PersistenceXml/PersistenceXmlRoots.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
#include "CDiagToMgmtRequestTransformer.h"
using namespace Caf;
#ifndef CDiagToMgmtRequestTransformer_h_
#define CDiagToMgmtRequestTransformer_h_
+
+#include "IBean.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Doc/DocXml/DiagRequestXml/DiagRequestXmlRoots.h"
+
+#include "CEnvelopeToPayloadTransformerInstance.h"
+#include "Common/IAppContext.h"
+#include "Doc/CafCoreTypesDoc/CClassSpecifierDoc.h"
+#include "Doc/CafCoreTypesDoc/CFullyQualifiedClassGroupDoc.h"
+#include "Doc/CafCoreTypesDoc/COperationDoc.h"
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CPropertyDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestInstanceParameterDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestParameterDoc.h"
+#include "Doc/DiagRequestDoc/CDiagRequestDoc.h"
+#include "Doc/DiagTypesDoc/CDiagCollectInstancesDoc.h"
+#include "Doc/DiagTypesDoc/CDiagDeleteValueCollectionDoc.h"
+#include "Doc/DiagTypesDoc/CDiagDeleteValueDoc.h"
+#include "Doc/DiagTypesDoc/CDiagSetValueCollectionDoc.h"
+#include "Doc/DiagTypesDoc/CDiagSetValueDoc.h"
+#include "Doc/MgmtRequestDoc/CMgmtRequestDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtBatchDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationDoc.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
#include "CDiagToMgmtRequestTransformerInstance.h"
+#include "Exception/CCafException.h"
+#include "Integration/Caf/CCafMessageCreator.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
#include "CInstallToMgmtRequestTransformer.h"
using namespace Caf;
#ifndef CInstallToMgmtRequestTransformer_h_
#define CInstallToMgmtRequestTransformer_h_
+
+#include "IBean.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Doc/DocXml/CafInstallRequestXml/InstallProviderJobXml.h"
+#include "Doc/DocXml/CafInstallRequestXml/UninstallProviderJobXml.h"
+
+#include "Common/IAppContext.h"
+#include "Doc/CafCoreTypesDoc/CClassSpecifierDoc.h"
+#include "Doc/CafCoreTypesDoc/CFullyQualifiedClassGroupDoc.h"
+#include "Doc/CafCoreTypesDoc/COperationDoc.h"
+#include "Doc/CafCoreTypesDoc/CParameterCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestInstanceParameterDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestParameterDoc.h"
+#include "Doc/CafInstallRequestDoc/CGetInventoryJobDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallProviderJobDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallRequestDoc.h"
+#include "Doc/CafInstallRequestDoc/CUninstallProviderJobDoc.h"
+#include "Doc/MgmtRequestDoc/CMgmtRequestDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtBatchDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationDoc.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Xml/XmlUtils/CXmlElement.h"
+#include "Exception/CCafException.h"
#include "CInstallToMgmtRequestTransformerInstance.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
+#include "Integration/Caf/CCafMessageCreator.h"
using namespace Caf;
#ifndef CInstallToMgmtRequestTransformerInstance_h_
#define CInstallToMgmtRequestTransformerInstance_h_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "Doc/CafCoreTypesDoc/COperationDoc.h"
+#include "Doc/CafInstallRequestDoc/CGetInventoryJobDoc.h"
+#include "Doc/CafInstallRequestDoc/CInstallProviderJobDoc.h"
+#include "Doc/CafInstallRequestDoc/CUninstallProviderJobDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationDoc.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ITransformer.h"
+
namespace Caf {
class CInstallToMgmtRequestTransformerInstance :
*/
#include "stdafx.h"
-#include "CMonitorInboundChannelAdapterInstance.h"
+
#include "CMonitorReadingMessageSource.h"
+#include "Common/IAppContext.h"
+#include "Integration/Core/CErrorHandler.h"
+#include "Integration/Core/CMessageHandler.h"
+#include "Integration/Core/CSimpleAsyncTaskExecutor.h"
+#include "Integration/Core/CSourcePollingChannelAdapter.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IMessageChannel.h"
+#include "CMonitorInboundChannelAdapterInstance.h"
using namespace Caf;
#ifndef CMonitorInboundChannelAdapterInstance_h_
#define CMonitorInboundChannelAdapterInstance_h_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/ITaskExecutor.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ILifecycle.h"
+#include "Integration/IMessageProducer.h"
+
namespace Caf {
class CMonitorInboundChannelAdapterInstance :
*/
#include "stdafx.h"
+
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
#include "CMonitorReadingMessageSource.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "CPersistenceInboundChannelAdapterInstance.h"
+
#include "CPersistenceReadingMessageSource.h"
+#include "Common/IAppContext.h"
+#include "IBean.h"
+#include "IPersistence.h"
+#include "Integration/Core/CErrorHandler.h"
+#include "Integration/Core/CMessageHandler.h"
+#include "Integration/Core/CSimpleAsyncTaskExecutor.h"
+#include "Integration/Core/CSourcePollingChannelAdapter.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IMessageChannel.h"
+#include "CPersistenceInboundChannelAdapterInstance.h"
using namespace Caf;
#ifndef CPersistenceInboundChannelAdapterInstance_h_
#define CPersistenceInboundChannelAdapterInstance_h_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "IPersistence.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/ITaskExecutor.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ILifecycle.h"
+#include "Integration/IMessageProducer.h"
+
namespace Caf {
class CPersistenceInboundChannelAdapterInstance :
*/
#include "stdafx.h"
+
+#include "Doc/PersistenceDoc/CCertCollectionDoc.h"
+#include "Doc/PersistenceDoc/CLocalSecurityDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolCollectionDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolDoc.h"
+#include "Doc/PersistenceDoc/CRemoteSecurityCollectionDoc.h"
+#include "Doc/PersistenceDoc/CRemoteSecurityDoc.h"
#include "CPersistenceMerge.h"
using namespace Caf;
#ifndef _MaIntegration_CPersistenceMerge_h_
#define _MaIntegration_CPersistenceMerge_h_
+
+#include "Doc/PersistenceDoc/CCertCollectionDoc.h"
+#include "Doc/PersistenceDoc/CLocalSecurityDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolCollectionDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolDoc.h"
+#include "Doc/PersistenceDoc/CRemoteSecurityCollectionDoc.h"
+#include "Doc/PersistenceDoc/CRemoteSecurityDoc.h"
+
using namespace Caf;
/// TODO - describe class
*/
#include "stdafx.h"
+
+#include "Doc/DocXml/PersistenceXml/PersistenceXmlRoots.h"
+
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "IPersistence.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
#include "CPersistenceMessageHandler.h"
using namespace Caf;
#ifndef _MaIntegration_CPersistenceMessageHandler_h_
#define _MaIntegration_CPersistenceMessageHandler_h_
+
+#include "Integration/IErrorProcessor.h"
+
+#include "IPersistence.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageHandler.h"
+
namespace Caf {
class CPersistenceMessageHandler :
*/
#include "stdafx.h"
+
+#include "Doc/PersistenceDoc/CCertCollectionDoc.h"
+#include "Doc/PersistenceDoc/CLocalSecurityDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolCollectionDoc.h"
+#include "Doc/PersistenceDoc/CPersistenceProtocolDoc.h"
+#include "Doc/PersistenceDoc/CRemoteSecurityCollectionDoc.h"
+#include "Doc/PersistenceDoc/CRemoteSecurityDoc.h"
+#include "Exception/CCafException.h"
#include "CPersistenceNamespaceDb.h"
#include <string>
#ifndef _MaIntegration_CPersistenceNamespaceDb_h_
#define _MaIntegration_CPersistenceNamespaceDb_h_
+
+#include "IBean.h"
+
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "IPersistence.h"
+
using namespace Caf;
/// TODO - describe class
*/
#include "stdafx.h"
+
+#include "CPersistenceMessageHandler.h"
+#include "Common/IAppContext.h"
+#include "IBean.h"
+#include "IPersistence.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IMessageChannel.h"
+#include "Integration/IMessageHandler.h"
#include "CPersistenceOutboundChannelAdapterInstance.h"
using namespace Caf;
#ifndef CPersistenceOutboundChannelAdapterInstance_h_
#define CPersistenceOutboundChannelAdapterInstance_h_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "IPersistence.h"
+#include "Integration/Core/CMessagingTemplate.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ILifecycle.h"
+
namespace Caf {
class CPersistenceOutboundChannelAdapterInstance :
*/
#include "stdafx.h"
+
+#include "Doc/PersistenceDoc/CPersistenceDoc.h"
+#include "IPersistence.h"
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
#include "CPersistenceReadingMessageSource.h"
+#include "Exception/CCafException.h"
+#include "Doc/DocXml/PersistenceXml/PersistenceXmlRoots.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/DocXml/ProviderInfraXml/ProviderInfraXmlRoots.h"
+#include "Doc/DocXml/ProviderResultsXml/ProviderResultsXmlRoots.h"
+#include "Doc/DocXml/ResponseXml/ResponseXmlRoots.h"
+
+#include "Common/CLoggingSetter.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/CafCoreTypesDoc/CFullyQualifiedClassGroupDoc.h"
+#include "Doc/ProviderInfraDoc/CClassCollectionDoc.h"
+#include "Doc/ProviderInfraDoc/CProviderRegDoc.h"
+#include "Doc/ProviderInfraDoc/CSchemaSummaryDoc.h"
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+#include "Doc/ResponseDoc/CProviderResponseDoc.h"
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassDoc.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Exception/CCafException.h"
#include "CProviderCollectSchemaExecutor.h"
+#include "Integration/Caf/CCafMessageCreator.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
using namespace Caf;
#ifndef CProviderCollectSchemaExecutor_h_
#define CProviderCollectSchemaExecutor_h_
+
+#include "IBean.h"
+
+#include "Common/CLoggingSetter.h"
+#include "Doc/ProviderInfraDoc/CProviderRegDoc.h"
+#include "Doc/ProviderInfraDoc/CSchemaSummaryDoc.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IMessageProcessor.h"
+
using namespace Caf;
/// TODO - describe class
*/
#include "stdafx.h"
+
+#include "CProviderExecutorRequest.h"
+#include "Common/IAppContext.h"
+#include "IBean.h"
+#include "Integration/Core/CErrorHandler.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationComponent.h"
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ITransformer.h"
+#include "Exception/CCafException.h"
#include "CProviderExecutor.h"
using namespace Caf;
#ifndef CProviderExecutor_h_
#define CProviderExecutor_h_
+
+#include "IBean.h"
+
+#include "CProviderExecutorRequestHandler.h"
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IErrorHandler.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/ITransformer.h"
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Integration/IMessageHandler.h"
+
using namespace Caf;
/// TODO - describe class
*/
#include "stdafx.h"
+
+#include "Doc/CafCoreTypesDoc/CPropertyDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+#include "Integration/IIntMessage.h"
+#include "CProviderExecutorRequest.h"
+#include "Exception/CCafException.h"
#include "CProviderExecutor.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "CResponseFactory.h"
+#include "CProviderExecutorRequest.h"
+#include "Common/CLoggingSetter.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+#include "Doc/ResponseDoc/CResponseDoc.h"
+#include "Integration/Core/CIntException.h"
+#include "Integration/Core/CSimpleAsyncTaskExecutor.h"
+#include "Integration/IErrorHandler.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/ITaskExecutor.h"
+#include "Integration/ITransformer.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
#include "CProviderExecutorRequestHandler.h"
+#include "Exception/CCafException.h"
+#include "Integration/Caf/CCafMessageCreator.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
+#include "Integration/Caf/CCafMessagePayload.h"
+#include "Integration/Core/FileHeaders.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/DocXml/ResponseXml/ResponseXmlRoots.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/CafCoreTypesDoc/CInlineAttachmentDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectSchemaRequestDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+#include "Doc/ResponseDoc/CManifestCollectionDoc.h"
+#include "Doc/ResponseDoc/CManifestDoc.h"
+#include "Doc/ResponseDoc/CProviderResponseDoc.h"
+#include "Doc/ResponseDoc/CResponseDoc.h"
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
#include "CResponseFactory.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Doc/DocXml/ProviderInfraXml/ProviderInfraXmlRoots.h"
+
+#include "Doc/CafCoreTypesDoc/CFullyQualifiedClassGroupDoc.h"
+#include "Doc/ProviderInfraDoc/CClassCollectionDoc.h"
+#include "Doc/ProviderInfraDoc/CSchemaSummaryDoc.h"
#include "CSchemaCacheManager.h"
+#include "Exception/CCafException.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
#include "CSinglePmeRequestSplitter.h"
using namespace Caf;
#ifndef CSinglePmeRequestSplitter_h_
#define CSinglePmeRequestSplitter_h_
+
+#include "IBean.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "Doc/CafCoreTypesDoc/CClassSpecifierDoc.h"
+#include "Doc/CafCoreTypesDoc/CFullyQualifiedClassGroupDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestConfigDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "Doc/MgmtRequestDoc/CMgmtRequestDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtBatchDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectInstancesDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtCollectSchemaDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationCollectionDoc.h"
+#include "Doc/MgmtTypesDoc/CMgmtInvokeOperationDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderBatchDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectSchemaRequestDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestConfigDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestHeaderDoc.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
#include "CSinglePmeRequestSplitterInstance.h"
+#include "Exception/CCafException.h"
+#include "Integration/Caf/CCafMessageCreator.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
+#include "Integration/Caf/CCafMessagePayload.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
#include "CVersionTransformer.h"
using namespace Caf;
#ifndef CVersionTransformer_h_
#define CVersionTransformer_h_
+
+#include "IBean.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Common/IAppContext.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Exception/CCafException.h"
#include "CVersionTransformerInstance.h"
+#include "Integration/Caf/CCafMessagePayloadParser.h"
using namespace Caf;
#ifndef CVersionTransformerInstance_h_
#define CVersionTransformerInstance_h_
+
+#include "Integration/IIntegrationComponentInstance.h"
+
+#include "Common/IAppContext.h"
+#include "Doc/PayloadEnvelopeDoc/CPayloadEnvelopeDoc.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ITransformer.h"
+
namespace Caf {
class CVersionTransformerInstance :
*/
#include "stdafx.h"
+
+#include "CConfigEnvInboundChannelAdapterInstance.h"
+#include "CConfigEnvOutboundChannelAdapterInstance.h"
+#include "CMonitorInboundChannelAdapterInstance.h"
+#include "CPersistenceOutboundChannelAdapterInstance.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Exception/CCafException.h"
#include "IntegrationObjects.h"
#include "CPersistenceInboundChannelAdapterInstance.h"
#ifndef _MaIntegration_IntegrationObjects_h_
#define _MaIntegration_IntegrationObjects_h_
+
+#include "IBean.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf { namespace MaIntegration {
class IntegrationObjects :
//#include <DocContracts.h>
// Interfaces
-#include "IPersistence.h"
-#include "IConfigEnv.h"
#endif
*/
#include "stdafx.h"
+#include "MaIntegration.h"
#include "IntegrationObjects.h"
+#include "CAttachmentRequestTransformerInstance.h"
+#include "CDiagToMgmtRequestTransformerInstance.h"
+#include "CSinglePmeRequestSplitterInstance.h"
namespace Caf {
#include <CommonDefines.h>
#include <Integration.h>
-#include <DocXml.h>
#include <DocUtils.h>
#include "MaContracts.h"
#include "MaIntegration.h"
#include "IntegrationObjects.h"
-#include "CAttachmentRequestTransformerInstance.h"
#include "CAttachmentRequestTransformer.h"
-#include "CDiagToMgmtRequestTransformerInstance.h"
#include "CDiagToMgmtRequestTransformer.h"
#include "CInstallToMgmtRequestTransformerInstance.h"
#include "CInstallToMgmtRequestTransformer.h"
#include "CPersistenceNamespaceDb.h"
-#include "CPersistenceReadingMessageSource.h"
#include "CPersistenceMessageHandler.h"
#include "CPersistenceInboundChannelAdapterInstance.h"
#include "CPersistenceOutboundChannelAdapterInstance.h"
#include "CPersistenceMerge.h"
#include "CConfigEnvMerge.h"
#include "CConfigEnv.h"
-#include "CConfigEnvReadingMessageSource.h"
#include "CConfigEnvMessageHandler.h"
#include "CConfigEnvInboundChannelAdapterInstance.h"
#include "CConfigEnvOutboundChannelAdapterInstance.h"
-#include "CSchemaCacheManager.h"
-#include "CResponseFactory.h"
#include "CCollectSchemaExecutor.h"
#include "CProviderCollectSchemaExecutor.h"
-#include "CProviderExecutorRequest.h"
-#include "CProviderExecutorRequestHandler.h"
#include "CProviderExecutor.h"
#include "CSinglePmeRequestSplitter.h"
-#include "CSinglePmeRequestSplitterInstance.h"
-#include "CMonitorReadingMessageSource.h"
#include "CMonitorInboundChannelAdapterInstance.h"
#include "CVersionTransformer.h"
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Aug 16, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CVgAuthContext_H_
+#define CVgAuthContext_H_
+
+namespace Caf {
+
+class CVgAuthContext {
+public:
+ CVgAuthContext();
+ virtual ~CVgAuthContext();
+
+public:
+ void initialize(
+ const std::string& applicationName);
+
+ VGAuthContext* getPtr() const;
+
+ std::string getApplicationName() const;
+
+private:
+ bool _isInitialized;
+ VGAuthContext* _vgAuthContext;
+ std::string _applicationName;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CVgAuthContext);
+};
+
+CAF_DECLARE_SMART_POINTER(CVgAuthContext);
+
+}
+
+#endif /* CVgAuthContext_H_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Aug 16, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CVgAuthImpersonation_H_
+#define CVgAuthImpersonation_H_
+
+
+#include "CVgAuthContext.h"
+#include "CVgAuthUserHandle.h"
+
+namespace Caf {
+
+class CVgAuthImpersonation {
+public:
+ CVgAuthImpersonation();
+ virtual ~CVgAuthImpersonation();
+
+public:
+ void impersonateAndManage(
+ const SmartPtrCVgAuthContext& vgAuthContext,
+ const SmartPtrCVgAuthUserHandle& vgAuthUserHandle);
+
+public:
+ static void beginImpersonation(
+ const SmartPtrCVgAuthContext& vgAuthContext,
+ const SmartPtrCVgAuthUserHandle& vgAuthUserHandle);
+
+ static void endImpersonation(
+ const SmartPtrCVgAuthContext& vgAuthContext);
+
+private:
+ void impersonateLocal(
+ const SmartPtrCVgAuthContext& vgAuthContext,
+ const SmartPtrCVgAuthUserHandle& vgAuthUserHandle) const;
+
+private:
+ bool _isInitialized;
+ SmartPtrCVgAuthContext _vgAuthContext;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CVgAuthImpersonation);
+};
+
+CAF_DECLARE_SMART_POINTER(CVgAuthImpersonation);
+
+}
+
+#endif /* CVgAuthImpersonation_H_ */
--- /dev/null
+/*
+ * Author: bwilliams
+ * Created: Aug 16, 2012
+ *
+ * Copyright (c) 2012 Vmware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef CVgAuthUserHandle_H_
+#define CVgAuthUserHandle_H_
+
+
+#include "CVgAuthContext.h"
+
+namespace Caf {
+
+class CVgAuthUserHandle {
+public:
+ CVgAuthUserHandle();
+ virtual ~CVgAuthUserHandle();
+
+public:
+ void initialize(
+ const SmartPtrCVgAuthContext& vgAuthContext,
+ const std::string& signedSamlToken);
+
+ void initialize(
+ const SmartPtrCVgAuthContext& vgAuthContext,
+ const std::string& signedSamlToken,
+ const std::string& userName);
+
+public:
+ std::string getUserName(
+ const SmartPtrCVgAuthContext& vgAuthContext) const;
+
+ VGAuthUserHandle* getPtr() const;
+
+private:
+ bool _isInitialized;
+ VGAuthUserHandle* _vgAuthUserHandle;
+
+private:
+ CAF_CM_CREATE;
+ CAF_CM_CREATE_LOG;
+ CAF_CM_DECLARE_NOCOPY(CVgAuthUserHandle);
+};
+
+CAF_DECLARE_SMART_POINTER(CVgAuthUserHandle);
+
+}
+
+#endif /* CVgAuthUserHandle_H_ */
--- /dev/null
+/*
+ * Created on: Jan 25, 2012
+ * Author: mdonahue
+ *
+ * Copyright (c) 2012 VMware, Inc. All rights reserved.
+ * -- VMware Confidential
+ */
+
+#ifndef _IVgAuthImpersonation_H_
+#define _IVgAuthImpersonation_H_
+
+namespace Caf {
+
+struct __declspec(novtable)
+ IVgAuthImpersonation : public ICafObject
+{
+ CAF_DECL_UUID("63cfac22-e1b8-4977-8907-9582657b7420")
+
+ virtual void endImpersonation() = 0;
+};
+
+CAF_DECLARE_SMART_INTERFACE_POINTER(IVgAuthImpersonation);
+
+}
+
+#endif /* _IVgAuthImpersonation_H_ */
*/
#include "stdafx.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
#include "CGuestAuthenticator.h"
using namespace Caf;
#ifndef CGuestAuthenticator_h_
#define CGuestAuthenticator_h_
+
+#include "IBean.h"
+
+#include "Integration/IDocument.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/IIntegrationComponent.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+
+#include "Integration/Caf/CCafMessagePayload.h"
+#include "CVgAuthImpersonation.h"
+#include "CVgAuthInitializer.h"
+#include "CVgAuthContext.h"
+#include "CVgAuthUserHandle.h"
+#include "Common/IAppContext.h"
+#include "Doc/CafCoreTypesDoc/CAuthnAuthzCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAuthnAuthzDoc.h"
+#include "Doc/CafCoreTypesDoc/CRequestHeaderDoc.h"
+#include "ICafObject.h"
+#include "IVgAuthImpersonation.h"
+#include "Integration/Core/CIntMessage.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Integration/Core/CIntMessageHeaders.h"
#include "CGuestAuthenticatorInstance.h"
using namespace Caf;
#ifndef CGuestAuthenticatorInstance_h_
#define CGuestAuthenticatorInstance_h_
+
+#include "Integration/IErrorProcessor.h"
+
+#include "Common/IAppContext.h"
+#include "Integration/IChannelResolver.h"
+#include "Integration/IDocument.h"
+#include "Integration/IIntMessage.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Integration/IIntegrationComponentInstance.h"
+#include "Integration/IIntegrationObject.h"
+#include "Integration/ITransformer.h"
+
namespace Caf {
class CGuestAuthenticatorInstance :
*/
#include "stdafx.h"
+#include "Exception/CCafException.h"
#include "CVgAuthError.h"
using namespace Caf;
*/
#include "stdafx.h"
+
+#include "CVgAuthContext.h"
+#include "CVgAuthUserHandle.h"
#include "CVgAuthImpersonation.h"
CVgAuthImpersonation::CVgAuthImpersonation() :
*/
#include "stdafx.h"
+
+#include "CVgAuthContext.h"
#include "CVgAuthInitializer.h"
+#include "CVgAuthImpersonation.h"
CVgAuthInitializer::CVgAuthInitializer() :
_isInitialized(false),
#ifndef CVGAUTHINITIALIZER_H_
#define CVGAUTHINITIALIZER_H_
+
+#include "IVgAuthImpersonation.h"
+
+#include "CVgAuthContext.h"
+
namespace Caf {
class CVgAuthInitializer : public IVgAuthImpersonation {
*/
#include "stdafx.h"
+
+#include "CVgAuthContext.h"
#include "CVgAuthUserHandle.h"
CVgAuthUserHandle::CVgAuthUserHandle() :
#include <CommonDefines.h>
#include <Integration.h>
-#include <DocXml.h>
#include <DocUtils.h>
#ifndef __APPLE__
#include <VGAuthAuthentication.h>
-#include "IVgAuthImpersonation.h"
#include "CVgAuthError.h"
-#include "CVgAuthContext.h"
-#include "CVgAuthUserHandle.h"
-#include "CVgAuthImpersonation.h"
#include "CVgAuthInitializer.h"
#include "CGuestAuthenticatorInstance.h"
#include "CGuestAuthenticator.h"
#ifndef CProviderDocHelper_H_
#define CProviderDocHelper_H_
+
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+#include "Doc/SchemaTypesDoc/CClassIdentifierDoc.h"
+#include "Doc/SchemaTypesDoc/CClassInstancePropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CClassPropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CCollectMethodDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassPropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassSubInstanceDoc.h"
+#include "Doc/SchemaTypesDoc/CInstanceParameterDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodParameterDoc.h"
+
namespace Caf {
class PROVIDERFX_LINKAGE CProviderDocHelper {
#ifndef CProviderDriver_h_
#define CProviderDriver_h_
+
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+#include "Doc/ProviderResultsDoc/CRequestIdentifierDoc.h"
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+
namespace Caf {
struct IInvokedProvider; // Forward declaration
#ifndef _ProviderContracts_IInvokedProvider_H_
#define _ProviderContracts_IInvokedProvider_H_
+
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+
namespace Caf {
struct IProviderRequest; // Forward declaration
#ifndef _ProviderContracts_IProviderRequest_H_
#define _ProviderContracts_IProviderRequest_H_
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationDoc.h"
+
namespace Caf {
struct __declspec(novtable) IProviderRequest {
#ifndef _ProviderContracts_IProviderResponse_H_
#define _ProviderContracts_IProviderResponse_H_
+
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+
namespace Caf {
struct __declspec(novtable) IProviderResponse {
#endif
#endif
-#include "IInvokedProvider.h"
-#include "IProviderRequest.h"
-#include "IProviderResponse.h"
#include "CProviderDriver.h"
#include "CProviderDocHelper.h"
*/
#include "stdafx.h"
+
+#include "Doc/DocXml/ProviderResultsXml/ProviderResultsXmlRoots.h"
+#include "Doc/DocXml/ResponseXml/ResponseXmlRoots.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentNameCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CInlineAttachmentDoc.h"
+#include "Doc/ProviderResultsDoc/CCdifDoc.h"
+#include "Doc/ProviderResultsDoc/CDefinitionObjectCollectionDoc.h"
+#include "Doc/ProviderResultsDoc/CRequestIdentifierDoc.h"
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+#include "Doc/ResponseDoc/CManifestDoc.h"
+#include "Doc/ResponseDoc/CProviderResponseDoc.h"
+#include "Doc/ResponseDoc/CResponseHeaderDoc.h"
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+#include "Doc/SchemaTypesDoc/CCollectMethodDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodDoc.h"
#include "CProviderCdifFormatter.h"
-#include "../../Framework/src/Doc/DocXml/ProviderResultsXml/ProviderResultsXmlLink.h"
-#include "../../Framework/src/Doc/DocXml/ResponseXml/ResponseXmlLink.h"
+#include "Doc/DocXml/ProviderResultsXml/ProviderResultsXmlLink.h"
+#include "Doc/DocXml/ResponseXml/ResponseXmlLink.h"
#include "../../Framework/src/Doc/DocUtils/DocUtilsLink.h"
-#include "../include/IProviderResponse.h"
using namespace Caf;
#ifndef CProviderCdifFormatter_h_
#define CProviderCdifFormatter_h_
+#include "IProviderResponse.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentNameCollectionDoc.h"
+#include "Doc/ProviderResultsDoc/CRequestIdentifierDoc.h"
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+
namespace Caf {
/// Sends responses/errors back to the client.
*/
#include "stdafx.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+#include "Doc/CafCoreTypesDoc/CafCoreTypesDocTypes.h"
+
+#include "Doc/ProviderResultsDoc/CSchemaDoc.h"
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+#include "Doc/SchemaTypesDoc/CClassIdentifierDoc.h"
+#include "Doc/SchemaTypesDoc/CClassInstancePropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CClassPropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CCmdlMetadataDoc.h"
+#include "Doc/SchemaTypesDoc/CCollectMethodDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassInstanceDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassPropertyDoc.h"
+#include "Doc/SchemaTypesDoc/CDataClassSubInstanceDoc.h"
+#include "Doc/SchemaTypesDoc/CInstanceParameterDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodParameterDoc.h"
#include "../include/CProviderDocHelper.h"
using namespace Caf;
*/
#include "stdafx.h"
-#include "../include/CProviderDriver.h"
-#include "../include/IInvokedProvider.h"
-#include "../../Framework/src/Doc/DocXml/ProviderResultsXml/ProviderResultsXmlLink.h"
+
+#include "Doc/DocXml/ProviderRequestXml/ProviderRequestXmlRoots.h"
+#include "Doc/DocXml/ProviderResultsXml/ProviderResultsXmlRoots.h"
+#include "Doc/DocXml/ResponseXml/ResponseXmlRoots.h"
+
+#include "Doc/DocUtils/EnumConvertersXml.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/CafCoreTypesDoc/CAttachmentDoc.h"
+#include "Doc/CafCoreTypesDoc/CInlineAttachmentDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+#include "Doc/ProviderResultsDoc/CRequestIdentifierDoc.h"
+#include "Doc/ResponseDoc/CProviderResponseDoc.h"
+#include "Doc/SchemaTypesDoc/CActionClassDoc.h"
+#include "Doc/SchemaTypesDoc/CCollectMethodDoc.h"
+#include "Doc/SchemaTypesDoc/CMethodDoc.h"
+#include "Memory/DynamicArray/DynamicArrayInc.h"
+#include "Exception/CCafException.h"
+#include "Common/IAppConfig.h"
+#include "CProviderDriver.h"
#include "CProviderCdifFormatter.h"
#include "CProviderRequest.h"
-#include "../../Framework/src/Integration/Caf/IntegrationCafLink.h"
-
+#include "IInvokedProvider.h"
+#include "Integration/Caf/CCafMessagePayload.h"
using namespace Caf;
#ifndef CProviderRequest_h_
#define CProviderRequest_h_
+
+#include "IProviderRequest.h"
+
+#include "Doc/CafCoreTypesDoc/CAttachmentCollectionDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderCollectInstancesDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderInvokeOperationDoc.h"
+#include "Doc/ProviderRequestDoc/CProviderRequestDoc.h"
+
namespace Caf {
// Request information forwarded to the provider
//{{CAF_SUBSYSTEM}}
#include <CommonDefines.h>
-#include <DocXml.h>
#include <DocUtils.h>
#include <Integration.h>
projects / thirdparty / open-vm-tools.git / commitdiff
