engine_client_cpp.hpp

Go to the documentation of this file.

/*
 * engine_client_cpp.hpp
 *
 * $Copyright(c) 2002-2012 Progress Software Corporation and/or its subsidiaries and affiliates. All rights reserved.$
 * $Copyright (c) 2013-2017 Software AG, Darmstadt, Germany and/or Software AG USA Inc., Reston, VA, USA, and/or its subsidiaries and/or its affiliates and/or their licensors.$
 * Use, reproduction, transfer, publication or disclosure is prohibited except as specifically provided for in your License Agreement with Software AG
 *
 * $Id: engine_client_cpp.hpp 314448 2017-08-08 16:13:03Z bsp $
 */

#ifndef ENGINE_CLIENT_CPP_HPP
#define ENGINE_CLIENT_CPP_HPP

#include <AP_Types.h>
#include <AP_Platform.h>
#include <iostream>
#include <sstream>
#include <exception>
#include <iterator>
#include <algorithm>
#include <utility>
#include <string>
#include <assert.h>
#include <sag_internal/engine_client_c.h>
#include <iomanip>
#include <vector>


using std::pair;

#undef ERROR

namespace com {

namespace apama {

        class AP_ENGINE_CLIENT_API EngineException : public std::exception
        {
        public:
                EngineException(const char *message);
                EngineException(const EngineException& ce);

                EngineException& operator= (const EngineException& ce) {
                        EngineException(ce).swap(*this);
                        return *this;
                }

                virtual ~EngineException() throw();

                virtual const char* what() const throw() { return m_message; }

                virtual const char* const* getWarnings() const { return m_warnings; }

        protected:
                void swap(EngineException &);
                const char* const* m_warnings;

        private:
                char *m_message;
        };


        typedef enum {
                OFF_LEVEL,
                FORCE_LEVEL,
                CRIT_LEVEL,
                FATAL_LEVEL,
                ERROR_LEVEL,
                WARN_LEVEL,
                INFO_LEVEL,
                DEBUG_LEVEL,
                TRACE_LEVEL
        } LogLevel;


        AP_ENGINE_CLIENT_API void setLogLevel(LogLevel level);

        AP_ENGINE_CLIENT_API void setLogFile(const AP_char8* filename, bool truncate, bool utf8 = false);

        AP_ENGINE_CLIENT_API void setLogFD(int fd);
                
        AP_ENGINE_CLIENT_API void setLogMutex(void *mutex);
                
        AP_ENGINE_CLIENT_API void reOpenLog();
                
                
        AP_ENGINE_CLIENT_API AP_char8* convertToUTF8(const AP_char8* s);

        AP_ENGINE_CLIENT_API AP_char8* convertFromUTF8(const AP_char8* s);

        AP_ENGINE_CLIENT_API void char8free(char *string);

        namespace event {

                class AP_ENGINE_CLIENT_API Event
                {
                        friend AP_ENGINE_CLIENT_API Event* createEvent(const char* eventString, const char* channelString);
                        friend AP_ENGINE_CLIENT_API void deleteEvent(Event* ev);

                public:
                        virtual const char* getText() const = 0;

                        virtual const char* getChannel() const = 0;

                         virtual double getTime() const = 0;

                        inline friend std::ostream& operator << (std::ostream& stream, const Event& obj) {
                                stream << obj.getText();
                                return stream;
                        }
                        inline friend std::ostream& operator << (std::ostream& stream, const Event* obj) {
                                stream << obj->getText();
                                return stream;
                        }

                private:
                        Event(const Event&);
                        Event& operator= (const Event&);

                protected:
                        Event();
                        virtual ~Event();
                };


                class AP_ENGINE_CLIENT_API EventSupplier
                {
                        friend AP_ENGINE_CLIENT_API void deleteEventSupplier(EventSupplier* evsup);

                public:
                        virtual void disconnect() = 0;

                protected:
                        EventSupplier();
                        virtual ~EventSupplier();

                private:
                        EventSupplier(const EventSupplier&);
                        EventSupplier& operator= (const EventSupplier&);
                };


                class AP_ENGINE_CLIENT_API EventConsumer
                {
                public:
                        virtual void sendEvents(const Event* const* events) = 0;

                protected:
                        EventConsumer();
                        virtual ~EventConsumer();

                private:
                        EventConsumer(const EventConsumer&);
                        EventConsumer& operator= (const EventConsumer&);
                };

                class  AP_ENGINE_CLIENT_API DisconnectableEventConsumer : public EventConsumer
                {
                public:
                        virtual void disconnect(const char* reason) = 0;
                        
                protected:
                        DisconnectableEventConsumer();
                        virtual ~DisconnectableEventConsumer();
                        
                private:
                        DisconnectableEventConsumer(const DisconnectableEventConsumer&);
                        DisconnectableEventConsumer& operator= (const DisconnectableEventConsumer&);
                };


                AP_ENGINE_CLIENT_API Event* createEvent(const char* eventString, const char* channelString);

                AP_ENGINE_CLIENT_API void deleteEvent(Event* ev);


                AP_ENGINE_CLIENT_API void deleteEventSupplier(EventSupplier* evsup);

        } // namespace event

        namespace engine {

                class AP_ENGINE_CLIENT_API MonitorScript
                {
                        friend AP_ENGINE_CLIENT_API MonitorScript* createMonitorScript(const char* monitorString);
                        friend AP_ENGINE_CLIENT_API void deleteMonitorScript(MonitorScript* mon);

                public:
                        virtual const char* getText() const = 0;

                        inline friend std::ostream& operator << (std::ostream& stream, const MonitorScript& obj) {
                                stream << obj.getText();
                                return stream;
                        }
                        inline friend std::ostream& operator << (std::ostream& stream, const MonitorScript* obj) {
                                stream << obj->getText();
                                return stream;
                        }

                private:
                        MonitorScript(const MonitorScript&);
                        MonitorScript& operator= (const MonitorScript&);

                protected:
                        MonitorScript();
                        virtual ~MonitorScript();
                };

                class EngineStatus;
                std::ostream& operator << (std::ostream& stream, const EngineStatus& obj);
                std::ostream& operator << (std::ostream& stream, const EngineStatus* obj);


                class AP_ENGINE_CLIENT_API EngineStatus
                {
                        friend class EngineManagement; /* getStatus */

                public:

#ifdef _MSC_VER
// needed or MSVC complains about the use of pair<string> here, even though it's all inlined
#pragma warning (disable : 4251)
#endif
                        class AP_ENGINE_CLIENT_API StatusIterator : public std::iterator<std::forward_iterator_tag, int>
                        {
                        public:
                                typedef pair<std::string, std::string> pair_t;

                                explicit StatusIterator(const EngineStatus &es, bool end=false);
                                StatusIterator():
                                        m_status(0),
                                        m_opaqueState(0),
                                        iterPair()
                                {}
                                ~StatusIterator()
                                {
                                        if (m_status && m_opaqueState) m_status->disposeIterator(m_opaqueState);
                                }
                                StatusIterator operator++(int dummy/*@unused@*/)
                                {
                                        StatusIterator current(*this);
                                        ++(*this); //this->operator++() // prefix ++
                                        return current;
                                }
                                StatusIterator& operator++();
                                bool operator==(const StatusIterator& ref) const
                                {
                                        return (m_status == ref.m_status) &&
                                                        (((0 == m_opaqueState) && (0 == ref.m_opaqueState)) ||
                                                        (iterPair.first == ref.iterPair.first));
                                }
                                bool operator!=(const StatusIterator& ref) const { return !((*this)==ref); }
                                pair_t &operator*() { return iterPair; }
                                pair_t *operator->() { return &iterPair; }
                                bool valid() { return 0 != m_opaqueState; }

                                StatusIterator(const StatusIterator& ref)
                                        : m_status(ref.m_status),
                                        m_opaqueState(m_status->copyIterator(ref.m_opaqueState)),
                                        iterPair(ref.iterPair)
                                {}
                                StatusIterator &operator=(const StatusIterator &other)
                                {
                                        StatusIterator(other).swap(*this);
                                        return *this;
                                }

                        private:
                                void step();
                                void swap(StatusIterator &other)
                                {
                                        std::swap(m_status, other.m_status);
                                        std::swap(m_opaqueState, other.m_opaqueState);
                                        std::swap(iterPair, other.iterPair);
                                }

                                const EngineStatus *m_status;
                                void *m_opaqueState;
                                pair_t iterPair;
                        };

                        typedef StatusIterator iterator;
                        typedef StatusIterator const_iterator;

                        AP_uint64 getUptime() const {
                                return getStatusIntValue("uptime");
                        }

                        AP_uint32 getNumContexts() const {
                                return (AP_uint32) getStatusIntValue("numContexts");
                        }

                        AP_uint32 getNumMonitors() const {
                                return (AP_uint32) getStatusIntValue("numMonitors");
                        }

                        AP_uint32 getNumProcesses() const {
                                return (AP_uint32) getStatusIntValue("numProcesses");
                        }

                        AP_uint32 getNumJavaApplications() const {
                                return (AP_uint32) getStatusIntValue("numJavaApplications");
                        }

                        AP_uint32 getNumListeners() const {
                                return (AP_uint32) getStatusIntValue("numListeners");
                        }

                        AP_uint32 getNumEventTypes() const {
                                return (AP_uint32) getStatusIntValue("numEventTypes");
                        }

                        AP_uint32 getNumQueuedFastTrack() const {
                                return (AP_uint32) getStatusIntValue("numQueuedFastTrack");
                        }

                        AP_uint32 getNumQueuedInput() const {
                                return (AP_uint32) getStatusIntValue("numQueuedInput");
                        }

                        AP_uint64 getNumReceived() const {
                                return getStatusIntValue("numReceived");
                        }

                        AP_uint64 getNumFastTracked() const {
                                return getStatusIntValue("numFastTracked");
                        }

                        AP_uint32 getNumConsumers() const {
                                return (AP_uint32) getStatusIntValue("numConsumers");
                        }

                        AP_uint32 getNumOutEventsQueued() const {
                                return (AP_uint32) getStatusIntValue("numOutEventsQueued");
                        }

                        AP_uint64 getNumOutEventsCreated() const {
                                return getStatusIntValue("numEmits");
                        }

                        AP_uint64 getNumOutEventsSent() const {
                                return getStatusIntValue("numOutEventsSent");
                        }

                        AP_uint32 getNumInputQueuedInput() const {
                                return (AP_uint32) getStatusIntValue("numInputQueuedInput");
                        }

                        const AP_char8* getMostBackedUpInput() const {
                                return (*this)["mostBackedUpInputContext"];
                        }

                        const AP_char8 *getSlowestReceiver() const {
                                return (*this)["slowestReceiver"];
                        }

                        AP_uint32 getSlowestReceiverQueueSize() const {
                                return (AP_uint32) getStatusIntValue("slowestReceiverQueueSize");
                        }

                        AP_uint32 getMostBackedUpQueueSize() const {
                                return (AP_uint32) getStatusIntValue("mostBackedUpQueueSize");
                        }

                        AP_uint32 getNumSubListeners() const {
                                return (AP_uint32) getStatusIntValue("numSubListeners");
                        }

                        AP_uint64 getNumProcessed() const {
                                return getStatusIntValue("numProcessed");
                        }
                        const_iterator begin() const {
                                return StatusIterator(*this);
                        }

                        const_iterator end() const {
                                return StatusIterator(*this, true);
                        }

                        const AP_char8* operator[] (const char *ref) const {
                            return getStatusValue(ref);
                        }

                        const AP_char8* operator[] (std::string &ref) const {
                                return this->operator[](ref.c_str());
                        }

                        AP_int64 getUserInt(const char* key) {
                                return userInt(key);
                        }

                        AP_int64 getUserIntOr(const char* key, int alt) {
                                return userIntOr(key, alt);
                        }

                        AP_float64 getUserFloat(const char* key) {
                                return userFloat(key);
                        }

                        AP_float64 getUserFloatOr(const char* key, float alt) {
                                return userFloatOr(key, alt);
                        }

                        AP_bool getUserBool(const char* key) {
                                return userBool(key);
                        }

                        AP_bool getUserBoolOr(const char* key, bool alt) {
                                return userBoolOr(key, alt);
                        }

                        const AP_char8* getUserString(const char* key) {
                                return userString(key);
                        }

                        const AP_char8* getUserStringOr(const char* key, const char* alt) {
                                return userStringOr(key, alt);
                        }

                        std::string getAllStatusValues() {
                                std::ostringstream ost;
                                ost << getStandardStatusValues();
                                for (EngineStatus::StatusIterator it = begin(); it != end(); ++it) {
                                        if (it->first.find("user-") != std::string::npos)
                                                ost << std::setw(32) << setiosflags(std::ios_base::left) << it->first.append(":") << it->second << std::endl;
                                }
                                return ost.str();
                        }

                        std::string getStandardStatusValues() {
                                std::ostringstream ost;
                                ost << *this;
                                return ost.str();
                        }

                        static std::string getRawHeader() {
                                std::ostringstream ost;
                                ost << "Uptime (ms),# Contexts,# Monitors,# Sub-monitors,# Java apps,# Listeners,";
                                ost << "# Sub-listeners,# Event types,Input queue,# Received events,";
                                ost << "Route queue,# Routed events,# Consumers,Output queue,";
                                ost << "# Created output events,# Sent output events,# Processed events,";
                                ost << "Slowest context name,Slowest context queue size,Slowest receiver,Slowest receiver queue";
                                return ost.str();
                        }

                        std::string getRawHeaderAll() {
                                std::ostringstream ost;
                                ost << getRawHeader();
                                for (EngineStatus::StatusIterator it = begin(); it != end(); ++it) {
                                        if (it->first.find("user-") != std::string::npos)
                                                ost << "," << it->first;
                                }
                                return ost.str();
                        }

                        std::string getStandardStatusValuesRaw() {
                                std::ostringstream ost;
                                ost << getUptime()
                                << "," << getNumContexts()
                                << "," << getNumMonitors()
                                << "," << getNumProcesses()
                                << "," << getNumJavaApplications()
                                << "," << getNumListeners()
                                << "," << getNumSubListeners()
                                << "," << getNumEventTypes()
                                << "," << getNumQueuedInput()
                                << "," << getNumReceived()
                                << "," << getNumQueuedFastTrack()
                                << "," << getNumFastTracked()
                                << "," << getNumConsumers()
                                << "," << getNumOutEventsQueued()
                                << "," << getNumOutEventsCreated()
                                << "," << getNumOutEventsSent()
                                << "," << getNumProcessed()
                                << "," << getMostBackedUpInput()
                                << "," << getMostBackedUpQueueSize()
                                << "," << getSlowestReceiver()
                                << "," << getSlowestReceiverQueueSize();
                                return ost.str();
                        }

                        std::string getAllStatusValuesRaw() {
                                std::ostringstream ost;
                                ost << getStandardStatusValuesRaw();
                                for (EngineStatus::StatusIterator it = begin(); it != end(); ++it) {
                                        if (it->first.find("user-") != std::string::npos)
                                                ost << "," << it->second;
                                }
                                return ost.str();
                        }

                        ~EngineStatus()
                        {
                                if (c_status) {
                                        c_status->functions->deleteStatus(reinterpret_cast<AP_EngineStatus *>(c_status));
                                }
                        }
                        EngineStatus(const EngineStatus &other)
                                : c_status(other.c_status ? reinterpret_cast<AP_EngineStatus_API*>(other.c_status->functions->copyStatus(reinterpret_cast<AP_EngineStatus *>(other.c_status))) : 0)
                        {}
                        EngineStatus &operator=(const EngineStatus &other)
                        {
                                EngineStatus(other).swap(*this);
                                return *this;
                        }
                        EngineStatus(): c_status(0) {}
                private:
                        EngineStatus(AP_EngineStatus_API *api): c_status(api) {}
                        void swap(EngineStatus &other) {
                                std::swap(c_status, other.c_status);
                        }
                        void getNext(const char *&name, const char *&value, void *&opaqueState) const {
                                if (c_status)
                                        c_status->functions->getNextStatusItem(reinterpret_cast<AP_EngineStatus *>(c_status), &name, &value, &opaqueState);
                        }
                        const AP_char8* getStatusValue(const char *name) const {
                                return c_status->functions->getStatusValue(reinterpret_cast<AP_EngineStatus *>(c_status), name);
                        }
                        AP_uint64 getStatusIntValue(const char *name) const {
                                return c_status->functions->getStatusIntValue(reinterpret_cast<AP_EngineStatus *>(c_status), name);
                        }
                        void disposeIterator(void *opaqueState) const {
                                c_status->functions->disposeIterator(reinterpret_cast<AP_EngineStatus *>(c_status), opaqueState);
                        }
                        void *copyIterator(void *opaqueState) const {
                                return c_status->functions->copyIterator(reinterpret_cast<AP_EngineStatus *>(c_status), opaqueState);
                        }

                        AP_int64 userIntOr(const char* key, AP_int64 alt) {
                                return c_status->functions->getUserIntOr(reinterpret_cast<AP_EngineStatus *>(c_status), key, alt);
                        }
                        AP_float64 userFloatOr(const char* key, AP_float64 alt) {
                                return c_status->functions->getUserFloatOr(reinterpret_cast<AP_EngineStatus *>(c_status), key, alt);
                        }
                        AP_bool userBoolOr(const char* key, AP_bool alt) {
                                return c_status->functions->getUserBoolOr(reinterpret_cast<AP_EngineStatus *>(c_status), key, alt);
                        }
                        const AP_char8* userStringOr(const char* key, const AP_char8* alt) {
                                return c_status->functions->getUserStringOr(reinterpret_cast<AP_EngineStatus *>(c_status), key, alt);
                        }
                        AP_int64 userInt(const char* key) {
                                return c_status->functions->getUserInt(reinterpret_cast<AP_EngineStatus *>(c_status), key);
                        }
                        AP_float64 userFloat(const char* key) {
                                return c_status->functions->getUserFloat(reinterpret_cast<AP_EngineStatus *>(c_status), key);
                        }
                        AP_bool userBool(const char* key) {
                                return c_status->functions->getUserBool(reinterpret_cast<AP_EngineStatus *>(c_status), key);
                        }
                        const AP_char8* userString(const char* key) {
                                return c_status->functions->getUserString(reinterpret_cast<AP_EngineStatus *>(c_status), key);
                        }
                        AP_EngineStatus_API *c_status;
                };


                inline std::ostream& operator << (std::ostream& stream, const EngineStatus& obj) {
                        std::ostringstream ost;
                        ost
                        << "Uptime(ms):                     " << obj.getUptime() << std::endl
                        << "Number of contexts:             " << obj.getNumContexts() << std::endl
                        << "Number of monitors:             " << obj.getNumMonitors() << std::endl
                        << "Number of sub-monitors:         " << obj.getNumProcesses() << std::endl
                        << "Number of Java applications:    " << obj.getNumJavaApplications() << std::endl
                        << "Number of listeners:            " << obj.getNumListeners() << std::endl
                        << "Number of sub-listeners:        " << obj.getNumSubListeners() << std::endl
                        << "Number of event types:          " << obj.getNumEventTypes() << std::endl
                        << "Events on input queue:          " << obj.getNumQueuedInput() << std::endl
                        << "Events received:                " << obj.getNumReceived() << std::endl
                        << "Events processed:               " << obj.getNumProcessed() << std::endl
                        << "Events on internal queue:       " << obj.getNumQueuedFastTrack() << std::endl
                        << "Events routed internally:       " << obj.getNumFastTracked() << std::endl
                        << "Number of consumers:            " << obj.getNumConsumers() << std::endl
                        << "Events on output queue:         " << obj.getNumOutEventsQueued() << std::endl
                        << "Output events created:          " << obj.getNumOutEventsCreated() << std::endl
                        << "Output events sent:             " << obj.getNumOutEventsSent() << std::endl
                        << "Events on input context queues: " << obj.getNumInputQueuedInput() << std::endl
                        << "Slowest context name:           " << obj.getMostBackedUpInput() << std::endl
                        << "Slowest context queue size:     " << obj.getMostBackedUpQueueSize() << std::endl
                        << "Slowest receiver name:          " << obj.getSlowestReceiver() << std::endl
                        << "Slowest receiver queue size:    " << obj.getSlowestReceiverQueueSize() << std::endl;
                        stream << ost.str();
                        return stream;
                }

                inline std::ostream& operator << (std::ostream& stream, const EngineStatus* obj) {
                        stream << *obj;
                        return stream;
                }

                inline EngineStatus::StatusIterator::StatusIterator(const EngineStatus &es, bool end):
                        m_status(&es),
                        m_opaqueState(0),
                        iterPair()
                {
                        if (!end) step(); // get the first item in the map
                }

                inline EngineStatus::StatusIterator& EngineStatus::StatusIterator::operator++()
                {
                        if (m_opaqueState) step();// don't step past the end
                        return *this;
                }

                inline void EngineStatus::StatusIterator::step()
                {
                        const char *name = nullptr;
                        const char *value = nullptr;

                        /* get the next item from the library map */
                        m_status->getNext(name, value, m_opaqueState );
                        if(!name || !value) {
                                assert(!m_opaqueState);
                        } else {
                                iterPair = pair_t(name, value);
                        }
                }

                class AP_ENGINE_CLIENT_API NameInfo
                {
                public:
                        virtual const char* getName() const = 0;

                        virtual const char* getPackage() const = 0;

                        virtual const char* getFullyQualifiedName() const = 0;

                private:
                        NameInfo(const NameInfo&);
                        NameInfo& operator= (const NameInfo&);

                protected:
                        NameInfo();
                        virtual ~NameInfo();
                };

                class AP_ENGINE_CLIENT_API NamedMonitorInfo : public NameInfo
                {
                public:
                        virtual unsigned int getNumSubMonitors() const = 0;

                private:
                        NamedMonitorInfo(const NamedMonitorInfo&);
                        NamedMonitorInfo& operator= (const NamedMonitorInfo&);

                protected:
                        NamedMonitorInfo();
                        virtual ~NamedMonitorInfo();
                };

                class AP_ENGINE_CLIENT_API NamedJavaApplicationInfo : public NameInfo {

                public:
                        virtual unsigned int getNumListeners() const = 0;

                private:
                        NamedJavaApplicationInfo(const NamedJavaApplicationInfo&);
                        NamedJavaApplicationInfo& operator= (const NamedJavaApplicationInfo&);

                protected:
                        NamedJavaApplicationInfo();
                        virtual ~NamedJavaApplicationInfo();
                };
                                        
                class AP_ENGINE_CLIENT_API NamedContextInfo : public NameInfo {

                public:
                        virtual unsigned int getNumSubMonitors() const = 0;

                        virtual unsigned int getQueueSize() const = 0;

                        virtual char const *const *getChannels() const = 0;

                private:
                        NamedContextInfo(const NamedContextInfo&);
                        NamedContextInfo& operator= (const NamedContextInfo&);

                protected:
                        NamedContextInfo();
                        virtual ~NamedContextInfo();
                };


                class AP_ENGINE_CLIENT_API NamedReceiverInfo : public NameInfo {

                public:
                        virtual unsigned int getQueueSize() const = 0;

                        virtual char const *const *getChannels() const = 0;

                        virtual const AP_char8 *getAddress() const = 0;

                private:
                        NamedReceiverInfo(const NamedReceiverInfo&);
                        NamedReceiverInfo& operator= (const NamedReceiverInfo&);

                protected:
                        NamedReceiverInfo();
                        virtual ~NamedReceiverInfo();
                };


                class AP_ENGINE_CLIENT_API NamedPluginReceiverInfo : public NameInfo {

                public:
                        virtual unsigned int getQueueSize() const = 0;

                        virtual char const *const *getChannels() const = 0;

                private:
                        NamedPluginReceiverInfo(const NamedPluginReceiverInfo&);
                        NamedPluginReceiverInfo& operator= (const NamedPluginReceiverInfo&);

                protected:
                        NamedPluginReceiverInfo();
                        virtual ~NamedPluginReceiverInfo();
                };

                class AP_ENGINE_CLIENT_API NamedEventTypeInfo : public NameInfo {

                public:
                        virtual unsigned int getNumEventTemplates() const = 0;

                private:
                        NamedEventTypeInfo(const NamedEventTypeInfo&);
                        NamedEventTypeInfo& operator= (const NamedEventTypeInfo&);

                protected:
                        NamedEventTypeInfo();
                        virtual ~NamedEventTypeInfo();
                };

                class AP_ENGINE_CLIENT_API NamedTimerInfo : public NameInfo {

                public:
                        virtual unsigned int getNumTimers() const = 0;

                private:
                        NamedTimerInfo(const NamedTimerInfo&);
                        NamedTimerInfo& operator= (const NamedTimerInfo&);

                protected:
                        NamedTimerInfo();
                        virtual ~NamedTimerInfo();
                };

                class AP_ENGINE_CLIENT_API NamedAggregateInfo : public NameInfo {

                private:
                        NamedAggregateInfo(const NamedAggregateInfo&);
                        NamedAggregateInfo& operator= (const NamedAggregateInfo&);

                protected:
                        NamedAggregateInfo();
                        virtual ~NamedAggregateInfo();
                };
                        
                class AP_ENGINE_CLIENT_API EngineInfo
                {
                        friend AP_ENGINE_CLIENT_API void deleteInfo(EngineInfo* info);

                public:
                        virtual unsigned int getNumMonitors() const = 0;

                        virtual unsigned int getNumJavaApplications() const = 0;

                        virtual unsigned int getNumEventTypes() const = 0;      

                        virtual unsigned int getNumTimers() const = 0;  

                        virtual unsigned int getNumAggregates() const = 0;

                        virtual NamedMonitorInfo** getMonitors() const = 0;

                        virtual NamedJavaApplicationInfo** getJavaApplications() const = 0;

                        virtual NamedEventTypeInfo** getEventTypes() const = 0;

                        virtual NamedTimerInfo** getTimers() const = 0;

                        virtual NamedAggregateInfo** getAggregates() const = 0;

                        virtual unsigned int getNumContexts() const = 0;

                        virtual NamedContextInfo** getContexts() const = 0;

                        virtual unsigned int getNumReceivers() const = 0;

                        virtual NamedReceiverInfo **getReceivers() const = 0;

                        virtual unsigned int getNumPluginReceivers() const = 0;

                        virtual NamedPluginReceiverInfo **getPluginReceivers() const = 0;

                private:
                        EngineInfo(const EngineInfo&);
                        EngineInfo& operator= (const EngineInfo&);

                protected:
                        EngineInfo();
                        virtual ~EngineInfo();
                };

                class AP_ENGINE_CLIENT_API EngineConnection;

                class AP_ENGINE_CLIENT_API EngineManagement : public com::apama::event::EventConsumer
                {
                public:
                        enum ConnectMode {
                                CONNECT_LEGACY,
                                CONNECT_PARALLEL
                        };
                        virtual void injectMonitorScript(MonitorScript& script) = 0;

                        virtual const char* const* injectMonitorScriptWithWarnings(MonitorScript& script) = 0;

                        virtual const char* const* injectMonitorScriptWithWarningsFilename(MonitorScript& script, const char *filename) = 0;

                        virtual void deleteName(const char * name) = 0;

                        virtual void forceDeleteName(const char * name) = 0;

                        virtual void killName(const char * name) = 0;

                        virtual void deleteAll() = 0;
                                        
                        virtual void injectJava(const AP_uint8* jarbytes, AP_uint32 size) = 0;

                        virtual const char* const* injectJavaWithWarnings(const AP_uint8* jarbytes, AP_uint32 size) = 0;

                        virtual const char* const* injectJavaWithWarningsFilename(const AP_uint8* jarbytes, AP_uint32 size, const char *filename) = 0;

                                        
                        virtual void injectCDP(const AP_uint8* cdpbytes, AP_uint32 size, const char *filename=NULL) = 0;

                        virtual const char* const* injectCDPWithWarnings(const AP_uint8* cdpbytes, AP_uint32 size) = 0;

                        virtual const char* const* injectCDPWithWarningsFilename(const AP_uint8* cdpbytes, AP_uint32 size, const char *filename) = 0;

                        EngineStatus getStatus()
                        {
                                char *errmsg = nullptr;
                                AP_EngineStatus *es_api = engineManagement_getStatusOpaque(this, &errmsg);
                                if (errmsg) {
                                        com::apama::EngineException e(errmsg);
                                        free(errmsg);
                                        throw e;
                                }

                                return EngineStatus(reinterpret_cast<AP_EngineStatus_API *>(es_api));
                        }

                        virtual com::apama::event::EventSupplier* connectEventConsumer(com::apama::event::EventConsumer* consumer, const char* const* channels, bool disconnectSlow) = 0;

                        virtual com::apama::event::EventSupplier* connectEventConsumer(com::apama::event::EventConsumer* consumer, const char* const* channels) = 0;

                        virtual bool attachAsEventConsumerTo(EngineManagement* target, const char* const* channels, bool disconnectSlow = false, ConnectMode mode = CONNECT_LEGACY) = 0;

                                        
                        virtual bool attachAsEventConsumerTo(const char* host, int port, const char* const* channels, bool disconnectSlow = false, ConnectMode mode = CONNECT_LEGACY) = 0;

                                        
                        virtual void detachAsEventConsumerFrom(EngineManagement* target, const char* const* channels, ConnectMode mode = CONNECT_LEGACY) = 0;
                        
                        virtual void detachAsEventConsumerFrom(const char* host, int port, const char* const* channels, ConnectMode mode = CONNECT_LEGACY) = 0;

                        virtual void sendEvents(const com::apama::event::Event* const* events) = 0;

                        virtual void sendEventsNoBatching(const com::apama::event::Event* const* events) = 0;

                        virtual void flushEvents() = 0;
                        
                        virtual EngineInfo* inspectEngine() = 0;

                        virtual void ping() = 0;
                                        
                        virtual bool isConnected() = 0;

                        virtual void setReceiverConnections(const std::vector<com::apama::engine::EngineConnection>& connections) = 0;

                        virtual const std::vector<com::apama::engine::EngineConnection> getReceiverConnections() = 0;
                                        
                protected:
                        EngineManagement();
                        virtual ~EngineManagement();

                private:
                        EngineManagement(const EngineManagement&);
                        EngineManagement& operator= (const EngineManagement&);
                };

                class AP_ENGINE_CLIENT_API EngineConnection {
                private:
                        std::string host;
                        int port;
                        std::vector<std::string> channels;
                        bool disconnectSlow;
                        EngineManagement::ConnectMode connectMode;

                        void init(const char * host, int port, bool disconnectSlow, EngineManagement::ConnectMode connectMode, const char * const * channels) {
                                if (host == NULL || channels == NULL) {
                                        throw EngineException("EngineConnection cannot be created with null host or channels");
                                }
                                if (port < 0 || port > 65535) {
                                        throw EngineException("EngineConnection cannot be created with invalid port value");
                                }

                                this->host = std::string(host);
                                this->port = port;
                                this->disconnectSlow = disconnectSlow;
                                this->connectMode = connectMode;

                                for (const char* const* c = channels; *c != NULL; c++) {
                                        this->channels.push_back(std::string(*c));
                                }
                        }

                public:
                        EngineConnection(const char * host, int port, bool disconnectSlow, EngineManagement::ConnectMode connectMode, 
                                                                                        const char * const * channels) {
                                init(host, port, disconnectSlow, connectMode, channels);
                        }

                        EngineConnection(const char * host, int port, const char * const * channels) {
                                init(host, port, false, EngineManagement::CONNECT_LEGACY, channels);
                        }

                        virtual const std::vector<std::string>& getChannels() const {
                                return channels;
                        }

                        virtual const std::string& getHost() const {
                                return host;
                        }

                        virtual int getPort() const {
                                return port;
                        }

                        virtual bool getDisconnectSlow() const{
                                return disconnectSlow;
                        }

                        virtual EngineManagement::ConnectMode getConnectMode() const {
                                return connectMode;
                        }

                        inline friend std::ostream& operator << (std::ostream& stream, const EngineConnection& obj) {
                                std::ostringstream ost;
                                ost << "EngineConnection to " << obj.host << ":" << obj.port << (obj.disconnectSlow == true ? " diconnectSlow" : "") << " on" <<
                                        (obj.connectMode == EngineManagement::CONNECT_PARALLEL ? " parallel" : "") << " channels [";

                                if (!obj.channels.empty()) {
                                        std::copy(obj.channels.begin(), obj.channels.end() - 1, std::ostream_iterator<std::string>(ost, ", "));
                                        ost << obj.channels.back();
                                }
                                ost << "]";
                                stream << ost.str();
                                return stream;
                        }

                        inline friend std::ostream& operator << (std::ostream& stream, const EngineConnection* obj) {
                                stream << *obj;
                                return stream;
                        }

                        virtual ~EngineConnection() {
                        }
                };

                AP_ENGINE_CLIENT_API void engineInit(const char* processName = "C++ Client");


                AP_ENGINE_CLIENT_API void engineInitMessaging(const char *processName, bool initMessaging=true);

                AP_ENGINE_CLIENT_API void engineShutdown();


                AP_ENGINE_CLIENT_API EngineManagement* connectToEngine(const char* host, unsigned short port, bool disconnectSlowReceiver = false, const char *processName = nullptr);

                AP_ENGINE_CLIENT_API EngineManagement* connectToEngineReceiveOnly(const char* host, unsigned short port, const char *processName = nullptr);

                AP_ENGINE_CLIENT_API EngineManagement* connectToEngineMonitorOnly(const char* host, unsigned short port, const char *processName = nullptr);

                AP_ENGINE_CLIENT_API void disconnectFromEngine(EngineManagement* corr);

                AP_ENGINE_CLIENT_API MonitorScript* createMonitorScript(const char* monitorString);

                AP_ENGINE_CLIENT_API void deleteMonitorScript(MonitorScript* mon);

                AP_ENGINE_CLIENT_API void deleteInfo(EngineInfo* info);


                AP_ENGINE_CLIENT_API void deleteWarnings(const char* const* warnings);

                AP_ENGINE_CLIENT_API void setEngineParams(const char* params);

        } // namespace engine
                
} // namespace apama

} // namespace com


#endif // ENGINE_CLIENT_CPP_HPP