title: C++ / Djinni Error Field type is an abstract class
body: <p>I'm making an app in React-native that uses Djinni from dropbox to bridge between C++ and Javascript. Calling from Javascript to C++ works well but now I'm implementing Call from C++ to Java/ObjC, my C++ skills are so and so. So I'm stuck on initialising class method.
  I'm basing this on the example provided with Djinni.
  AnotherClassMain is the access point from Javascript to C++.</p>
  
  <p>I want to call runAProcess method from processAImpl inside anotherClassMain.</p>
  
  <p>But I get the error
  Field type 'aEditing::ProcessAImpl' is an abstract class
  On the line ProcesAImpl  processA; in anotherClassMain.hpp</p>
  
  <p>How can I access this initiate the class processAImpl and call the runAProcess from anotherClassMain ??</p>
  
  <p>// processA.hpp created by djinni</p>
  
  <pre><code>#pragma once
  #include &lt;string&gt;
  
  namespace aEditing {
  class ProcessA {
  public:
      virtual ~ProcessA() {}
      virtual bool runThisProcess(const std::string &amp; str) = 0;
  };
  } 
  </code></pre>
  
  <p>//processAImpl.hpp</p>
  
  <pre><code>#pragma once
  #include "processA.hpp"
  
  namespace aEditing {
  class ProcessAImpl : public ProcessA {
  
  public:
      ProcessAImpl(const std::shared_ptr&lt;ProcessA&gt; &amp; listener);
      void runAProcess(const std::string aCommand);
  
  private:
      std::shared_ptr&lt;ProcessA&gt; aProcess;
  };
  }
  </code></pre>
  
  <p>//processAImpl.cpp</p>
  
  <pre><code>#include "procesAImpl.hpp"
  namespace aEditing {
  
  ProcessAImpl::ProcessAImpl (const std::shared_ptr&lt;ProcessA&gt; &amp; listener) {
      this-&gt;aProcess = listener;
  }
  
  void ProcessAImpl::runAProcess(const std::string aCommand) {
      this-&gt;aProcess-&gt;runThisProcess(aCommand);
  }
  }
  </code></pre>
  
  <p>//anotherClassMain.hpp</p>
  
  <pre><code>#pragma once
  #include "includes.hpp"
  #include "processAImpl.hpp"
  
  namespace anotherProcessing {
  
    class AnotherProcessingMain: public anotherProcessing::AnotherProcessing {
      public:
        AnotherProcessingMain();
        string anotherProcessing(const std::string &amp;Input, const std::string &amp;output) override;
      private:
          ProcesAImpl  processA;
    };
  }
  </code></pre>
  
  <p>//anotherClassMain.cpp</p>
  
  <pre><code>#include "anotherClassMain.hpp"
  
  namespace anotherProcessing {
    shared_ptr&lt;AnotherProcessing&gt; AnotherProcessing::create() {
      return make_shared&lt;AnotherProcessingMain&gt;();
    }
  
    AnotherProcessingMain::AnotherProcessingMain() {}
  
    string AnotherProcessingMain::anotherProcessing(const std::string &amp;Input, const std::string &amp;output){
  
      processA.runAProcess("testCommand");  //Trying to access this!
  
      return "yeah";
    }
  </code></pre>