instancehandle.hpp

Go to the documentation of this file.

/*
  INSTANCEHANDLE.hpp  -  automatically handling interface lifecycle

  Copyright (C)         Lumiera.org
    2008,               Hermann Vosseler <Ichthyostega@web.de>

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of
  the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#ifndef LUMIERA_INSTANCEHANDLE_H
#define LUMIERA_INSTANCEHANDLE_H


#include "include/logging.h"
#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "lib/depend-inject.hpp"

extern "C" {
#include "common/interface.h"
#include "common/interfaceregistry.h"
}

#include <string>



namespace lumiera {
  
  using std::string;
  
  template<class I, class FA>
  class InstanceHandle;
  
  
  namespace { // implementation details
    
    void
    throwIfError()
    {
      if (lumiera_error_peek())
        throw lumiera::error::Config("failed to open interface or plugin.",lumiera_error());
    }
    
    LumieraInterface
    register_and_open (LumieraInterface descriptor)
    {
      if (!descriptor) return NULL;
      lumiera_interfaceregistry_register_interface (descriptor, NULL);
      throwIfError();
      return lumiera_interface_open (descriptor->interface,
                                     descriptor->version,
                                     descriptor->size,
                                     descriptor->name);
    }
    
    bool
    verify_validity (LumieraInterface ifa)
    {
      REQUIRE (ifa);
      return (ifa == lumiera_interfaceregistry_interface_find (ifa->interface,
                                                               ifa->version,
                                                               ifa->name));
    }
    
  } // (End) impl details
  
  
  
  
  namespace facade {

    template<class IHA>
    class Proxy;
    
    template<class I, class FA>
    using ServiceHandle = typename lib::DependInject<FA>::template ServiceInstance<Proxy<InstanceHandle<I,FA>>>;
    
    
    template<class I, class FA>
    struct Link
      : ServiceHandle<I,FA>
      {
        using IH = InstanceHandle<I,FA>;
        
        Link (IH const& iha);
       ~Link ();
        
        FA* operator->()  const;
      };
    
    
    template<class I>
    struct Link<I,I>
      : util::NonCopyable
      {
        using IH = InstanceHandle<I,I>;
        IH& ih_;
        
        Link (IH& ih)
          : ih_{ih}
        { }
        
        I*
        operator->()  const
          {
            return & ih_.get();
          }
      };
    
  } // namespace facade (impl details)
  
  
  
  
  
  template< class I         
          , class FA = I    
          >
  class InstanceHandle
    : util::NonCopyable
    {
      LumieraInterface desc_;
      I*                instance_;
      facade::Link<I,FA> facadeLink_;
      
    public:
      InstanceHandle (string const& iName, uint version, size_t minminor, string const& impName)
        : desc_(0)
        , instance_(reinterpret_cast<I*>
              (lumiera_interface_open (iName.c_str(), version, minminor, impName.c_str())))
        , facadeLink_(*this)
        {
          throwIfError();
        }
      
      InstanceHandle (LumieraInterface descriptor)
        : desc_(descriptor)
        , instance_(reinterpret_cast<I*> (register_and_open (desc_)))
        , facadeLink_(*this)
        {
          throwIfError();
        }
      
      ~InstanceHandle ()
        {
          lumiera_interface_close (&instance_->interface_header_);
          if (desc_)
            lumiera_interfaceregistry_remove_interface (desc_);
        }
      
      
      
      FA*
      operator-> ()  const
        {
          return facadeLink_.operator ->();
        }
      
      I&
      get ()  const
        {
          ENSURE(instance_);
          return *instance_;
        }
      
      
      explicit
      operator bool()  const
        {
          return isValid();
        }
      bool
      operator!() const
        {
          return not isValid();
        }
      
      
    private:
      bool
      isValid()  const
        {
          return instance_
              && verify_validity (&instance_->interface_header_);
        }
    };
  
  
} // namespace lumiera

#endif