cli_proxy.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#ifndef INCLUDED_CLI_URE_SOURCE_UNO_BRIDGE_CLI_PROXY_H
#define INCLUDED_CLI_URE_SOURCE_UNO_BRIDGE_CLI_PROXY_H
 
#include "uno/environment.hxx"
#include "uno/mapping.hxx"
#include "uno/dispatcher.h"
#include "cli_bridge.h"
#include "cli_environment.h"
 
#using <cli_ure.dll>
 
namespace srrp = System::Runtime::Remoting::Proxies;
namespace srrm = System::Runtime::Remoting::Messaging;
namespace srr = System::Runtime::Remoting;
namespace sr = System::Reflection;
namespace sc = System::Collections;
using namespace uno;
 
namespace cli_uno
{
 
public ref class UnoInterfaceInfo
{
public:
    UnoInterfaceInfo(Bridge const * bridge, uno_Interface* unoI,
                     typelib_InterfaceTypeDescription* td);
    ~UnoInterfaceInfo();
    !UnoInterfaceInfo();
 
    uno_Interface * m_unoI; // wrapped interface
    System::Type ^ m_type;
    typelib_InterfaceTypeDescription* m_typeDesc;
 
    Bridge const* m_bridge;
};
 
public ref class  UnoInterfaceProxy: public srrp::RealProxy,
                                      public srr::IRemotingTypeInfo
{
    System::String^ m_sTypeName;
    sc::ArrayList^ m_listIfaces;
    int m_numUnoIfaces;
    sc::ArrayList^ m_listAdditionalProxies;
    int m_nlistAdditionalProxies;
 
    UnoInterfaceInfo ^ findInfo( ::System::Type ^ type );
 
    Bridge const* m_bridge;
     System::String^ m_oid;
 
#if OSL_DEBUG_LEVEL >= 2
     rtl_uString * _sInterfaces;
//     /** Count of interfaces. Used in conjunction with _sInterfaces.
//      */
    int _numInterfaces;
#endif
 
public:
 
    static System::Object^ create(Bridge * bridge,
                                  uno_Interface * pUnoI,
                                  typelib_InterfaceTypeDescription* pTd,
                                  const OUString& oid);
 
    virtual srrm::IMessage^ Invoke(srrm::IMessage^ msg) override;
 
    void addUnoInterface(uno_Interface* pUnoI,
                         typelib_InterfaceTypeDescription* pTd);
    ~UnoInterfaceProxy();
    !UnoInterfaceProxy();
 
    inline System::String ^ getOid()
        { return m_oid; }
 
    //IRemotingTypeInfo ----------------------------------------------
    virtual bool CanCastTo(System::Type^ fromType, System::Object^ o);
 
    virtual property System::String^ TypeName
    {
        System::String^ get()
        {
            return m_sTypeName;
        };
        void set(System::String^ name)
        {
            m_sTypeName = name;
        };
    }
 
 
private:
    UnoInterfaceProxy(
        Bridge * bridge,
        uno_Interface * pUnoI,
        typelib_InterfaceTypeDescription* pTD,
        const OUString& oid );
 
    static srrm::IMessage^ constructReturnMessage(System::Object^ retVal,
                           array<System::Object^>^ outArgs,
                           typelib_InterfaceMethodTypeDescription* mtd,
                           srrm::IMessage^ msg, System::Object^ exc);
 
    static System::String^ m_methodNameString =
                           gcnew System::String("__MethodName");
    static System::String^ m_typeNameString = gcnew System::String("__TypeName");
    static System::String^ m_ArgsString = gcnew System::String("__Args");
    static System::String^ m_CallContextString =
                           gcnew System::String("__CallContext");
    static System::String^ m_system_Object_String =
                           gcnew System::String("System.Object");
    static System::String^ m_methodSignatureString =
                           gcnew System::String("__MethodSignature");
    static System::String^ m_Equals_String =  gcnew System::String("Equals");
    static System::String^ m_GetHashCode_String =
                           gcnew System::String("GetHashCode");
    static System::String^ m_GetType_String = gcnew System::String("GetType");
    static System::String^ m_ToString_String = gcnew System::String("ToString");
 
protected:
     srrm::IMessage^ invokeObject(sc::IDictionary^ properties,
                                  srrm::LogicalCallContext^ context,
                                  srrm::IMethodCallMessage^ mcm);
};
 
 
//Cannot make this __gc because a managed type cannot derive from unmanaged type
struct CliProxy: public uno_Interface
{
    mutable oslInterlockedCount m_ref;
    const Bridge* m_bridge;
    const gcroot<System::Object^> m_cliI;
    gcroot<System::Type^> m_type;
    const css::uno::TypeDescription m_unoType;
    const gcroot<System::String^> m_oid;
    const OUString m_usOid;
 
    enum MethodKind {MK_METHOD = 0, MK_SET, MK_GET};
    gcroot<array<sr::MethodInfo^>^> m_arMethodInfos;
 
    gcroot<array<sr::MethodInfo^>^> m_arInterfaceMethodInfos;
 
    gcroot<array<System::Int32>^> m_arUnoPosToCliPos;
 
    int m_nInheritedInterfaces;
    gcroot<array<System::Int32^>^> m_arInterfaceMethodCount;
 
    CliProxy( Bridge const* bridge, System::Object^ cliI,
                 typelib_TypeDescription const* pTD,
                 const OUString& usOid);
    ~CliProxy();
 
    static uno_Interface* create(Bridge const * bridge,
                                 System::Object^ cliI,
                                 typelib_TypeDescription const * TD,
                                 OUString const & usOid );
 
    void makeMethodInfos();
 
    sr::MethodInfo^ getMethodInfo(int nUnoFunctionPos,
                                  const OUString & usMethodName,
                                  MethodKind mk);
 
    void SAL_CALL uno_DispatchMethod(
        struct _uno_Interface * pUnoI,
        const struct _typelib_TypeDescription * pMemberType,
        void * pReturn,
        void * pArgs[],
        uno_Any ** ppException );
 
    inline void acquire() const;
    inline void release() const;
};
}
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */