RMethodUtils             package:methods             R Documentation

_R_M_e_t_h_o_d_U_t_i_l_s

_D_e_s_c_r_i_p_t_i_o_n:

     Utility functions to support the definition and use of formal
     methods.  Most of these functions will not normally be called
     directly by the user.

_U_s_a_g_e:

     getGeneric(f, mustFind=FALSE, where)

     getGroup(fdef, recursive, where)

     getMethodsMetaData(f, where)
     assignMethodsMetaData (f, value, fdef, where, deflt)
     mlistMetaName (name, package)

     makeGeneric(f, fdef, fdefault, group=list(), valueClass=character(),
                 package, signature = NULL, genericFunction = NULL)

     makeStandardGeneric(f, fdef)

     generic.skeleton(name, fdef, fdefault)

     defaultDumpName(generic, signature)

     getAllMethods(f, fdef, where)

     doPrimitiveMethod(name, def, call= sys.call(-1), ev= sys.frame(sys.parent(2)))

     conformMethod(signature, mnames, fnames, f)

     matchSignature(signature, fun, where)

     removeMethodsObject(f, where)

     findUnique(what, message, where)

     MethodAddCoerce(method, argName, thisClass, methodClass)

     is.primitive(fdef)

     cacheMetaData(where, attach = TRUE, searchWhere)

     cacheGenericsMetaData(f, fdef, attach = TRUE, where, package, methods)

     setPrimitiveMethods(f, fdef, code, generic, mlist)

     missingArg(symbol, envir = parent.frame(), eval)

     balanceMethodsList(mlist, args, check = TRUE)

     sigToEnv(signature, genericSig)

     rematchDefinition(definition, generic, mnames, fnames, signature)
     unRematchDefinition(definition)

     asMethodDefinition(def, signature, sealed = FALSE)

     addNextMethod(method, f, mlist, optional, envir)

_S_u_m_m_a_r_y _o_f _F_u_n_c_t_i_o_n_s:


     '_g_e_t_G_e_n_e_r_i_c': return the definition of the function named 'f' as a
          generic.

          If no definition is found, throws an error or returns 'NULL'
          according to the value of 'mustFind'.  By default, searches
          in the top-level environment (normally the global
          environment, but adjusted to work correctly when package code
          is evaluated from the function 'library'.

          Primitive functions are dealt with specially, since there is
          never a formal generic definition for them.  The value
          returned is the formal definition used for assigning methods
          to this primitive. Not all primitives can have methods; if
          this one can't, then 'getGeneric' returns 'NULL' or throws an
          error.


     '_g_e_t_G_r_o_u_p': return the groups to which this generic belongs,
          searching from environment 'where' (the global environment
          normally by default).

          If 'recursive=TRUE', also all the group(s) of these groups.


     '_g_e_t_M_e_t_h_o_d_s_M_e_t_a_D_a_t_a', '_a_s_s_i_g_n_M_e_t_h_o_d_s_M_e_t_a_D_a_t_a', '_m_l_i_s_t_M_e_t_a_N_a_m_e': Ut
          ilities to get ('getMethodsMetaData') and assign 
          ('assignMethodsMetaData') the metadata object recording the
          methods defined in a particular package, or to return the
          mangled name for that object  ('mlistMetaName').

          The assign function should not be used directly.  The get
          function may be useful if you want explicitly only the
          outcome of the methods assigned in this package.  Otherwise,
          use 'getMethods'.


     '_m_a_t_c_h_S_i_g_n_a_t_u_r_e': Matches the signature object (a partially or
          completely named subset of the signature arguments of the
          generic function object 'fun'), and return a vector of all
          the classes in the order specified by 'fun@signature'.  The
          classes not specified by 'signature' will be '"ANY"' in the
          value, but extra trailing '"ANY"''s are removed.  When the
          input signature is empty, the returned signature is a single
          '"ANY"' matching the first formal argument (so the returned
          value is always non-empty).

          Generates an error if any of the supplied signature names are
          not legal; that is, not in the signature slot of the generic
          function.

          If argument 'where' is supplied, a warning will be issued if
          any of the classes does not have a formal definition visible
          from 'where'.


     '_M_e_t_h_o_d_A_d_d_C_o_e_r_c_e': Possibly modify one or more methods to
          explicitly coerce this argument to 'methodClass', the class
          for which the method is explicitly defined.  Only modifies
          the method if an explicit coerce is required to coerce from
          'thisClass' to 'methodClass'.


     '_i_s._p_r_i_m_i_t_i_v_e': Is this object a primitive function (either a
          builtin or special)?


     '_r_e_m_o_v_e_M_e_t_h_o_d_s_O_b_j_e_c_t': remove the metadata object containing
          methods for 'f'.


     '_f_i_n_d_U_n_i_q_u_e': Return the list of environments (or equivalent)
          having an object named 'what', using environment 'where' and
          its parent environments.  If more than one is found, a
          warning message is generated, using 'message' to identify
          what was being searched for, unless 'message' is the empty
          string.


     '_c_a_c_h_e_M_e_t_a_D_a_t_a', '_c_a_c_h_e_G_e_n_e_r_i_c_s_M_e_t_a_D_a_t_a', '_s_e_t_P_r_i_m_i_t_i_v_e_M_e_t_h_o_d_s': U
          tilities for ensuring that the internal information about
          class and method definitions is up to date.  Should normally
          be called automatically whenever needed (for example, when a
          method or class definition changes, or when a package is
          attached or detached).  Required primarily because primitive
          functions are dispatched in C code, rather than by the
          official model.

          The 'setPrimitiveMethods' function resets the caching
          information for a particular primitive function.  Don't call
          it directly.


     '_m_i_s_s_i_n_g_A_r_g': Returns 'TRUE' if the symbol supplied is missing
          _from the call_ corresponding to the environment supplied (by
          default, environment of the call to 'missingArg').  If 'eval'
          is true, the argument is evaluated to get the name of the
          symbol to test.  Note that 'missingArg' is closer to the
          "blue-book" sense of the 'missing' function, not that of the
          current R base package implementation.  But beware that it
          works reliably only if no assignment has yet been made to the
          argument.  (For method dispatch this is fine, because
          computations are done at the begining of the call.)


     '_b_a_l_a_n_c_e_M_e_t_h_o_d_s_L_i_s_t': Called from 'setMethod' to ensure that all
          nodes in the list have the same depth (i.e., the same number
          of levels of arguments).  Balance is needed to ensure that
          all necessary arguments are examined when inherited methods
          are being found and added to the 'allMethods' slot.  No
          actual recomputation is needed usually except when a new
          method uses a longer signature than has appeared before.

          Balance requires that _all_ methods be added to the generic
          via 'setMethod' (how else could you do it?) or by the initial
          'setGeneric' call converting the ordinary function.


     '_s_i_g_T_o_E_n_v': Turn the signature (a named vector of classes) into an
          environment with the classes assigned to the names.  The
          environment is then suitable for calling 'MethodsListSelect',
          with 'evalArgs=FALSE', to select a method corresponding to
          the signature.  Usually not called directly: see
          'selectMethod'.


     '._s_a_v_e_I_m_a_g_e': Flag, used in dynamically initializing the methods
          package from '.First.lib'


     '_r_e_m_a_t_c_h_D_e_f_i_n_i_t_i_o_n', '_u_n_R_e_m_a_t_c_h_D_e_f_i_n_i_t_i_o_n': If the specified
          method in a call to 'setMethod' specializes the argument list
          (by replacing ...), then 'rematchDefinition' constructs the
          actual method stored. Using knowledge of how
          'rematchDefinition' works, 'unRematchDefinition' reverses the
          procedure; if given a function or method definition that does
          not correspond to this form, it just returns its argument.


     '_a_s_M_e_t_h_o_d_D_e_f_i_n_i_t_i_o_n': Turn a function definition into a
          'MethodDefinition-class' object, corresponding to the given
          'signature' (by default generates a default method with empty
          signature).  The definition is sealed according to the
          'sealed' argument.


     '_a_d_d_N_e_x_t_M_e_t_h_o_d': A generic function that finds the next method in
          'mlist' corresponding the method definition 'method'  and
          adds the method to the methods list, which it then returns. 
          It uses methods defined suitably for ordinary methods and for
          methods with calls to 'callNextMethod'.


'_m_a_k_e_G_e_n_e_r_i_c': Makes a generic function object corresponding to the
     given function name, optional definition and optional default
     method. Other arguments supply optional elements for the slots of
     'genericFunction-class'.


'_m_a_k_e_S_t_a_n_d_a_r_d_G_e_n_e_r_i_c': a utility function that makes a valid function
     calling 'standardGeneric' for name 'f'.  Works (more or less) even
     if the actual definition, 'fdef', is not a proper function, that
     is, it's a primitive or internal.


'_c_o_n_f_o_r_m_M_e_t_h_o_d': If the formal arguments, 'mnames', are not identical
     to the formal arguments to the function, 'fnames', 'conformMethod'
     determines whether the signature and the two sets of arguments
     conform, and returns the signature, possibly extended.  The
     function name, 'f' is supplied for error messages.

     The method assignment conforms if either method and function have
     identical formal argument lists.  It can also conform if the
     method omits some of the formal arguments of the function but: (1)
     the non-omitted arguments are a subset of the function arguments,
     appearing in the same order; (2) there are no arguments to the
     method that are not arguments to the function; and (3) the omitted
     formal arguments do not appear as explicit classes in the
     signature.


'_d_e_f_a_u_l_t_D_u_m_p_N_a_m_e': the default name to be used for dumping a method.


'_g_e_t_A_l_l_M_e_t_h_o_d_s': A generic function (with methods) representing the
     merge of all the methods defined for this generic starting from
     environment 'where', including all parent environments.  By
     default, uses the global environment (and therefore all packages
     on the search list).  This function exists largely to re-compute
     the full set of methods when a change to the available methods
     occurs.  Since all such recomputations are supposed to be
     automatic, direct calls to 'getAllMethods' should not be needed.

     If the generic 'f' has a group generic, methods for this group
     generic (and further generations of group generics, if any) are
     also merged.

     The merging rule is as follows: each generic is merged across
     packages, and the group generics are then merged, finally adding
     the directly defined methods of 'f'.

     The effect of the merging rule is that any method directly defined
     for 'f' on any included package overrides a method for the same
     signature defined for the group generic; similarly for the group
     generic and its group, if any, etc.

     For 'f' or for a specific group generic, methods override in the
     order of the packages being searched.  A method for a particular
     signature on a particular package overrides any methods for the
     same signature on packages later on in the list of packages being
     searched.

     The slot '"allMethods"' of the merged methods list is set to a
     copy of the methods slot; this is the slot where inherited methods
     are stored.


'_d_o_P_r_i_m_i_t_i_v_e_M_e_t_h_o_d': do a primitive call to builtin function 'name' the
     definition and call provided, and carried out in the environment
     'ev'.

     A call to 'doPrimitiveMethod' is used when the actual method is a
     .Primitive.  (Because primitives don't behave correctly as
     ordinary functions, not having either formal arguments nor a
     function body). 

