cOleFlashCall.h

Go to the documentation of this file.

//
//
#ifndef _INC_cOleFlashCall_H
#define _INC_cOleFlashCall_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "../WinAPI/WinTypes.h"
#include "GrayCore/include/StrT.h"
#include "GrayCore/include/cArray.h"
#include "GrayCore/include/cString.h"
#include "GrayCore/include/cNonCopyable.h"
#include "GrayCore/include/StrArg.h"
 
#define USE_FLASH
#if defined(_WIN32) && defined(_MSC_VER) && defined(USE_FLASH)
 
namespace GrayLib
{
        class cOleFlashArg
        {
        
        public:
                enum ARG_TYPE
                {
                        ARG_NONE = 0,
                        ARG_NUMBER,
                        ARG_BOOLEAN,
                        ARG_STRING
                };
                static const cOleFlashArg k_Null;       // ARG_NONE
 
        private:
                ARG_TYPE m_eType;
                cString m_sArg;
 
        public:
                cOleFlashArg() noexcept
                        : m_eType(ARG_NONE)
                {
                }
                cOleFlashArg(ARG_TYPE eType, cString sArg = "")
                        : m_eType(eType)
                        , m_sArg(sArg)
                {
                }
                cOleFlashArg(const char* sVal)
                        : m_eType(ARG_STRING)
                        , m_sArg(sVal)
                {
                }
                cOleFlashArg(cString sVal)
                        : m_eType(ARG_STRING)
                        , m_sArg(sVal)
                {
                }
                cOleFlashArg(bool bVal)
                        : m_eType(ARG_BOOLEAN)
                        , m_sArg(bVal ? "true" : "false")
                {
                }
                cOleFlashArg(int iVal)
                        : m_eType(ARG_NUMBER)
                {
                        m_sArg = StrArg<GChar_t>(iVal);
                }
                cOleFlashArg(unsigned int uVal)
                        : m_eType(ARG_NUMBER)
                {
                        m_sArg = StrArg<GChar_t>(uVal);
                }
                cOleFlashArg(unsigned long ulVal)
                        : m_eType(ARG_NUMBER)
                {
                        m_sArg = StrArg<GChar_t>((UINT64)ulVal);
                }
                cOleFlashArg(float fVal)
                        : m_eType(ARG_NUMBER)
                {
                        char szBuffer[256];
                        StrT::DtoA(double(fVal), szBuffer, _countof(szBuffer));
                        m_sArg = (const char*)(szBuffer);
                }
 
                void put_ArgType(ARG_TYPE eType)
                {
                        m_eType = eType;
                }
                ARG_TYPE get_ArgType() const
                {
                        return m_eType;
                }
                const char* get_ArgTypeName() const;
 
                const cString& get_String() const
                {
                        // ARG_STRING
                        return m_sArg;
                }
                int     get_Number() const;
                float get_Float() const;
                bool get_Boolean() const;
 
                void AppendString(const cString& sArg2)
                {
                        m_sArg += sArg2;
                }
        };
 
        class GRAYLIB_LINK cOleFlashCall : public cNonCopyable
        {
 
                friend class cOleFlashParser;
 
        private:
                cString m_sName;                // <invoke name="x"> of the function to invoke.
                cArrayStruct<cOleFlashArg> m_aArgs;     // <arguments>
                cString m_sReturnType;  // <invoke returntype="xml">
                cString m_sReturnVal;
 
        public:
                cOleFlashCall(const char* xmlStream);
                cOleFlashCall(const char* pszFunctionName, const char* pszArgs);        // parse a string as args.
 
                cOleFlashCall(const char* pszFunctionName, cOleFlashArg& arg1)
                        : m_sName(pszFunctionName)
                {
                        AddArg(arg1);
                }
                cOleFlashCall(const char* pszFunctionName, cOleFlashArg& arg1, cOleFlashArg& arg2)
                        : m_sName(pszFunctionName)
                {
                        AddArg(arg1); AddArg(arg2);
                }
                cOleFlashCall(const char* pszFunctionName, cOleFlashArg& arg1, cOleFlashArg& arg2, cOleFlashArg& arg3)
                        : m_sName(pszFunctionName)
                {
                        AddArg(arg1); AddArg(arg2); AddArg(arg3);
                }
                cOleFlashCall(const char* pszFunctionName, cOleFlashArg& arg1, cOleFlashArg& arg2, cOleFlashArg& arg3, cOleFlashArg& arg4)
                        : m_sName(pszFunctionName)
                {
                        AddArg(arg1); AddArg(arg2); AddArg(arg3); AddArg(arg4);
                }
                cOleFlashCall(const char* pszFunctionName, cOleFlashArg& arg1, cOleFlashArg& arg2, cOleFlashArg& arg3, cOleFlashArg& arg4, cOleFlashArg& arg5)
                        : m_sName(pszFunctionName)
                {
                        AddArg(arg1); AddArg(arg2); AddArg(arg3); AddArg(arg4); AddArg(arg5);
                }
                cOleFlashCall(const char* pszFunctionName, cOleFlashArg& arg1, cOleFlashArg& arg2, cOleFlashArg& arg3, cOleFlashArg& arg4, cOleFlashArg& arg5, cOleFlashArg& arg6)
                        : m_sName(pszFunctionName)
                {
                        AddArg(arg1); AddArg(arg2); AddArg(arg3); AddArg(arg4); AddArg(arg5); AddArg(arg6);
                }
                cOleFlashCall(const char* pszFunctionName, cOleFlashArg& arg1, cOleFlashArg& arg2, cOleFlashArg& arg3, cOleFlashArg& arg4, cOleFlashArg& arg5, cOleFlashArg& arg6, cOleFlashArg& arg7, cOleFlashArg& arg8)
                        : m_sName(pszFunctionName)
                {
                        AddArg(arg1); AddArg(arg2); AddArg(arg3); AddArg(arg4); AddArg(arg5); AddArg(arg6); AddArg(arg7); AddArg(arg8);
                }
                cOleFlashCall(const char* pszFunctionName, cOleFlashArg& arg1, cOleFlashArg& arg2, cOleFlashArg& arg3, cOleFlashArg& arg4, cOleFlashArg& arg5, cOleFlashArg& arg6, cOleFlashArg& arg7, cOleFlashArg& arg8, cOleFlashArg& arg9)
                        : m_sName(pszFunctionName)
                {
                        AddArg(arg1); AddArg(arg2); AddArg(arg3); AddArg(arg4); AddArg(arg5); AddArg(arg6); AddArg(arg7); AddArg(arg8); AddArg(arg9);
                }
 
                ~cOleFlashCall();
 
                const cString& get_FuncName() const
                {
                        return m_sName; // name of the function invoked.
                }
                bool hasArgs() const
                {
                        return m_aArgs.GetSize() != 0;
                }
                ITERATE_t get_ArgCount() const
                {
                        return m_aArgs.GetSize();
                }
                const cOleFlashArg& GetArg(ITERATE_t i) const
                {
                        if (!m_aArgs.IsValidIndex(i))
                                return cOleFlashArg::k_Null;
                        return m_aArgs[i];
                }
                void AddArg(cOleFlashArg& arg)
                {
                        m_aArgs.Add(arg);
                }
 
                bool hasReturnType() const
                {
                        return !m_sReturnType.IsEmpty();
                }
                void put_ReturnTypeXML();
                cString& ref_ReturnVal2()
                {
                        return m_sReturnVal;
                }
                cString& ref_ReturnVal()        // a string ref i may change. XML format.
                {
                        put_ReturnTypeXML();    // i am settings a XML return.
                        return ref_ReturnVal2();
                }
                const cString get_ReturnVal() const
                {
                        return m_sReturnVal;
                }
 
                cString get_InvokeStr() const;
                cString get_DebugStr() const;
        };
}
 
#endif
#endif