Provided by: libur-perl_0.470+ds-1_all bug


       UR::Object::Type::AccessorWriter - Helper module for UR::Object::Type responsible for
       creating accessors for properties


       Subroutines within this module actually live in the UR::Object::Type namespace;  this
       module is just a convienent place to collect them.  The class initializer uses these
       subroutines when it's time to create accessor methods for a newly defined class.  Each
       accessor is implemented by a closure that is then assigned a name by Sub::Name and
       inserted into the defined class's namespace by Sub::Install.



           This is the entry point into the accessor writing system.  It inspects each item in
           the 'has' key of the class object's hashref, and creates methods for each property.

             $classobj->mk_rw_accessor($class_name, $accessor_name, $column_name, $property_name, $is_transient);

           Creates a mutable accessor named $accessor_name which stores its value in the
           $property_name key of the object's hashref.

             $classobj->mk_ro_accessor($class_name, $accessor_name, $column_name, $property_name);

           Creates a read-only accessor named $accessor_name which retrieves its value in the
           $property_name key of the object's hashref.  If the method is used as a mutator by
           passing in a value to the method, it will throw an exception with Carp::croak.

             $classobj->mk_id_based_object_accessor($class_name, $accessor_name, $id_by,
                                                    $r_class_name, $where);

           Creates an object accessor named $accessor_name.  It returns objects of type
           $r_class_name, id-ed by the parameters named in the $id_by arrayref.  $where is an
           optional  listref of additional filters to apply when retrieving objects.

           The behavior of the created accessor depends on the number of parameters passed to it.
           For 0 params, it retrieves the object pointed to by $r_class_name and $id_by.  For 1
           param, it looks up the ID param values of the passed-in object-parameter, and
           reassigns value stored in the $id_by properties of the acted-upon object, effectively
           acting as a mutator.

           For more than 1 param, the additional parameters are taken as properties/values to
           filter the returned objects on

             $classobj->mk_indirect_ro_accessor($class_name, $accessor_name, $via, $to, $where);

           Creates a read-only via accessor named $accessor_name.  Its value is obtained by
           calling the object accessor named $via, and then calling the method $to on that
           object.  The optional $where listref is used as additional filters when calling $via.

               $classobj->mk_indirect_rw_accessor($class_name, $accessor_name, $via, $to,
                                                  $where, $singular_name);

           Creates a via accessor named $accessor_name that is able to change the property it
           points to with $to when called as a mutator.  If the $to property on the remote object
           is an ID property of its class, it deletes the refered-to object and creates a new one
           with the appropriate properties.  Otherwise, it updates the $to property on the
           refered-to object.

               $classobj->mk_calculation_accessor($class_name, $accessor_name, $calculation_src,
                                                  $calculate_from, $params, $is_constant, $column_name);

           Creates a calculated accessor called $accessor_name.  If the $is_constant flag is
           true, then the accessor runs the calculation once, caches the result, and returns that
           result for subsequent calls to the accessor.

           $calculation_src can be one of: coderef, string containing Perl code, or the name of a
           module under UR::Object::Type::AccessorWriter which has a method called "calculate".
           If $calculation_src is empty, then $accessor_name must be the name of an already-
           existing subroutine in the class's namespace.

           These create accessors for dealing with dimension tables in OLAP-type schemas.  They
           need more documentation.

             $classobj->mk_rw_class_accessor($class_name, $accessor_name, $column_name, $is_transient, $variable_value);

           Creates a read-write accessor called $accessor_name which stores its value in a scalar
           captured by the accessor's closure.  Since the closure is inserted into the class's
           namespace, all instances of the class share the same closure (and therefore the same
           scalar), and the property effectively acts as a class-wide property.

             $classobj->mk_ro_class_accessor($class_name, $accessor_name, $column_name, $variable_value);

           Creates a read-only accessor called $accessor_name which retrieves its value from a
           scalar captured by the accessor's closure.  The value is initialized to
           $variable_value.  If called as a mutator, it throws an exception through Carp::croak


       UR::Object::Type::AccessorWriter, UR::Object::Type