Recommendation for C++ wrapper for cross platform in-process dynamic library bindings (i.e. a lightweight, high performance COM or CORBA) -


We are developing an application that will have a plug-in "architecture" Ownership algorithm (We will basically take a set of parsers and allow third parties to provide them with themselves)

Domain space requires a lot of performance, so out-of-process Binding is not going to work and we 'force That leave heavy things such as Corba and COM.

In fact, we are searching for a simple cross-platform cover:

  • Load Library with a relative path
  • some configuration / name <
  • Provide mapping of special DLL
  • Make some initializations and check the library to make sure it provides the necessary functionality

I think that this is actually just a loading wraplibrary () and method call export. We can write it ourselves, but we want to use the existing code because there is enough in our plate.

Again, throughput and performance are very important

There are similar questions:

- It is very close, but we only want in-process There is no need to be out of the process and our needs are a little "light weight".

This is for unmanaged C ++ - we can not use .NET

Edit - what we got

We've found that works great for us needs to be done. Commented on the status of C ++ development and language direction as a bonus is the much appreciated comment ...

It was a simple cross-wrapping wrapping, which we needed to provide poco. There really is not much for this, but still saves us time and testing. No additional overhead during run time.

The library is a wrapper for interesting library loading in which the work is cross platform. If you want more comfort from simple loadlibrary then look at the ACE ORB is to use Corba with TAO is extremely executable and most likely dismantles any self-designed plug-in infrastructure, especially if you are in the process call If used, TAO optimizes them.

To use the dynamic library cross platform wrapper usage, it provides the most basic cross platform cover around the loadlibrary () you mentioned.

The ACE between using ACDML and TAO, which allows you to dynamically load objects. After loading, you can get the upstream pointer to the loaded object that you have implemented and call any method on the loaded object.

The code will look like this:

  four constellation = cpc_myClass = ACE_DYNAMIC_SERVICE_DIRECTIVE ("myclass", "dllname", "_make_MyClass", ""); Results = ACE_Service_Config :: process_directive (cpc_myClass); MyClass * p_obj = ACE_Dynamic_Service & lt; MyClass & gt; :: Example ("myclass"); P_obj- & gt; CallAnyMethodYouLike ();  

It is explained that TAO knows two types of colonization optimization (Thru_Pawah and Direct):

When direct tactics are used, then On the collated objects, the method invoices become direct, calls the servant without checking the position of the PO.

You might be surprised that what the effective TAO might be, I suggest making a simple proof of the concept and measuring.


Comments

Popular posts from this blog

c# - How to capture HTTP packet with SharpPcap -

php - Multiple Select with Explode: only returns the word "Array" -

php - jQuery AJAX Post not working -