RCOMTypeLibraryInterfaceDefinition-classpackage:SWinTypeLibsR Documentation

_C_l_a_s_s _t_o _r_e_p_r_e_s_e_n_t _R _i_n_t_e_r_f_a_c_e _t_o _a _T_y_p_e _L_i_b_r_a_r_y

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

     This class is used to represent all the information  gathered in
     processing the contents of a DCOM-related type library to define
     an R interface to all the classes, enumeration elements, event
     handlers, etc. in that type library. This is created by a call to
     'generateInterface' and the result is an object that contains
     information about the necessary class definitions, property and
     method accessor functions, event handler constructors, and
     enumeration definitions. These can then be written to a connection
     for use in future R sessions via 'writeCode'.   Some incomplete
     code allows it to be used directly in the current session, or
     "just in time", via the 'define' function.

_O_b_j_e_c_t_s _f_r_o_m _t_h_e _C_l_a_s_s:

     Objects are typically created using  the function
     'generateInterface'.

_S_l_o_t_s:


     '_t_y_p_e_s': Object of class '"list"' a collection of objects
          describing an R-level interface to the corresponding DCOM
          type in the type library. These elements are of class
          'RCOMDispatchInterfaceDefinition-class'.

     '_e_n_u_m_s': Object of class '"list"' a collection of objects
          describing an enumeration definition in the type library.
          Each object is merely the named integer vector giving the
          symbolic names and the   corresponding value. 

     '_e_v_e_n_t_s': Object of class '"list"' a collection of objects
          describing the interface to an event source for responding to
           its event announcements or triggers. Each element is an
          object of class 'RCOMEventInterfaceDefinition-class'.

     '_e_x_t_e_r_n_a_l_C_l_a_s_s_e_s': Object of class '"list"'. This is used to store
          a collection of 'RCOMTypeLibraryInterfaceDefinition' objects.
           There is one for each of the libraries and their types that
          are referenced within the original top-level library. This
          happens when we process a type library to create an R
          interface to it (via 'generateInterface') and encounter types
          for parameters and return values of methods and properties
          that are not actually defined in the original type library,
          but rather in secondary libraries. We can generate interfaces
          to these types in those libraries in the same way we do for
          the original top-level/initial library and we store these
          interfaces in this slot.

_M_e_t_h_o_d_s:


     _w_r_i_t_e_C_o_d_e 'signature(def = "RCOMTypeLibraryInterfaceDefinition",
          file = "character")': write the R code contained in this
          interface definition  to a directory or file.  This is
          responsible for creating the necessary connections to the
          files and then writing the code.

     _w_r_i_t_e_C_o_d_e 'signature(def = "RCOMTypeLibraryInterfaceDefinition",
          file = "ANY")': write this code to the specified connection.

_A_u_t_h_o_r(_s):

     Duncan Temple Lang <duncan@wald.ucdavis.edu>

_R_e_f_e_r_e_n_c_e_s:

     <URL: http://msdn.microsoft.com/library> <URL:
     http://www.omegahat.org/RWinTypeLibs>

_S_e_e _A_l_s_o:

     'generateInterface' 'writeCode'

     It may be useful to look at non-exported functions in 'generate.S'
     and 'referencedClasses.S' to see how the entire thing works and
     how it can be changed.  This interface is not cast in stone.  We
     want others to be able to explore alternatives, ideally by
     extending or parameterizing the mechanism rather than presenting
     an entirely parallel but similar mechanism.

