---

more/lang/location.h

Go to the documentation of this file.

//  Copyright (C) 2001  Petter Urkedal (petter.urkedal@matfys.lth.se)
//
//  This file 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 file 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.
//
//  $Id: location.h,v 1.1 2002/05/30 18:01:37 petter_urkedal Exp $

//  !! THIS INTERFACE IS NOT STABILIZED !!


#ifndef MORE_LANG_LOCATION_H
#define MORE_LANG_LOCATION_H

#include <more/lang/fwd.h>
#include <more/gen/utility.h>
#include <stdexcept>

namespace more {
namespace lang {

  /** \class cx_resolver package.h more/lang/package.h
   **
   ** The interface for handling lazy resoltion of value addresses. */
  struct resolver
  {
      resolver();
      virtual ~resolver();

      /** Return the type of the object returned by resolve. */
      virtual ct_type const* resolve_type_of() const = 0;

      /** If m_ptr == 0, this function shall return a pointer to the
          object.  It may optionally also set m_ptr to speed up later
          calls to get().  If the binding can not be resolved, return
          0. */
      virtual void* resolve() = 0;

#if 0
      /** Provide a pointer to type \a t or 0 if not possible.  The
          default implementation returns the properly translated \c
          location::get() if \a t match the \a rtt argument of the
          ctor or is inherited from in, and 0 otherwise. */
      virtual void* resolve(ct_type const* t);
#endif

      /** If m_ptr == 0 and type_of() is an ct_proto, this function
          shall call the function represented by this value.  The
          default implementation calls the function returned by
          this->resolve() using ct_proto::call. */
      virtual void resolve_call(void* ret, void** args);

      /** Return true if equal to \a rhs. */
      virtual bool equal_to(resolver* rhs) = 0;

      /** Return the location which uses this resolver. */
      location* client() { return m_client; }

    private:
      location*         m_client;

      friend class location;
  };

  inline bool
  equal(resolver* h0, resolver* h1)
  {
      return h0->equal_to(h1);
  }


  /** \class location package.h more/lang/package.h
   **
   ** A lazily resolved value.  This has low space overhead (two
   ** pointers) most stuff goes into the handler.  Lookup is fast
   ** after the value is resolved, but resolving the value may be
   ** slow. */
  struct location : gen::noncopyable
  {
      /** Construct an undefined location.  The only valid methods for
          an undefined location are \c is_defined(), \c set(void*) and
          \c set_resolver(). */
      location()
          : m_ptr(0), m_resolver(0) {}

      /** Construct a location handled by \a handler or containing \a
          ptr.  If \a ptr is non-zero, \a handler will not be used by
          \c location, so it is safe to set it to 0 as long as \c set
          is not invoked with a 0 argument. */
      explicit location(resolver* handler, void* ptr = 0);

      ~location();

      /** True if the location is fixed or if a resolver is provided. */
      bool is_defined() const { return m_ptr != 0 || m_resolver != 0; }

      /** Set the handler. */
      void set_resolver(resolver* h) { m_resolver = h; h->m_client = this; }

      /** Return the handler of this location. */
      resolver* get_resolver() const { return m_resolver; }

      /** Return the type of the data at this location.
          \pre A resolver is provided. */
      ct_type const* type_of() const
      {
#ifndef MORE_LANG_NDEBUG
          if (!m_resolver)
              throw std::logic_error("more::lang::location::type_of(): "
                                     "The location is not resolvable.");
#endif
          return m_resolver->resolve_type_of();
      }

      /** Returns a pointer to the object of the binding.  The \c
          cx_package_variable resovler will invalidate the returned
          pointer upon re-linking, which may be caused by another call
          to this method.
          \pre Either the location is fixed or a resolver is provided. */
      void* get() const
      {
          if (m_ptr)
              return m_ptr;
#ifndef MORE_LANG_NDEBUG
          if (!m_resolver)
              throw std::logic_error("more::lang::location::get(): "
                                     "The location is not resolvable.");
#endif
          return m_resolver->resolve();
      }

#if 0
      /** Return a pointer to the object of the binding projected to \a t.
          \pre A resolver is provided. */
      void* get(ct_type const* t) const
      {
#ifndef MORE_LANG_NDEBUG
          if (!m_resolver)
              throw std::logic_error("more::lang::location::"
                                     "get(ct_type const*): "
                                     "The location is not resolvable.");
#endif
          return m_resolver->resolve(t);
      }
#endif

      /** Returns a pointer to the object if it no computaiton is
          needed. */
      void* get_if_ready() const { return m_ptr; }

      /** If the value is a function, call it, otherwise screw up the
          process.  In some frameworks this may be equivalent to using
          \c ct_proto::call on \c this->get().  This method is
          provided in order to allow an interpreted code. */
      void call(void* ret, void** args);

      /** To be called from reslove() to set to pointer to the
          object. */
      void set(void* ptr) { m_ptr = ptr; }

    private:
      // A pointer to the object or 0 for undefined or delayed
      // binding.
      mutable void*     m_ptr;

      // A hander to resolve m_ptr.
      mutable resolver* m_resolver;
  };

  inline bool
  equal(location* locn0, location* locn1)
  {
      if (locn0->get_if_ready() && locn1->get_if_ready())
          return locn0->get_if_ready() == locn1->get_if_ready();
      else
          return equal(locn0->get_resolver(), locn1->get_resolver());
  }

}}

#endif

---