xs-src/MouseAttribute.xs

   1 #include "mouse.h"
   2
   3
   4 AV*
   5 mouse_get_xa(pTHX_ SV* const attr) {
   6     static MGVTBL mouse_xa_vtbl; /* identity */
   7
   8     AV* xa;
   9     MAGIC* mg;
  10
  11     if(!IsObject(attr)){
  12         croak("Not a Mouse meta attribute");
  13     }
  14
  15     mg = mouse_mg_find(aTHX_ SvRV(attr), &mouse_xa_vtbl, 0x00);
  16     if(!mg){
  17         SV* slot;
  18         STRLEN len;
  19         const char* pv;
  20         U16 flags = 0x00;
  21
  22         ENTER;
  23         SAVETMPS;
  24
  25         xa    = newAV();
  26
  27         mg = sv_magicext(SvRV(attr), (SV*)xa, PERL_MAGIC_ext, &mouse_xa_vtbl,NULL, 0);
  28         SvREFCNT_dec(xa); /* refcnt++ in sv_magicext */
  29
  30         av_extend(xa, MOUSE_XA_last - 1);
  31
  32         slot = mcall0(attr, mouse_name);
  33         pv = SvPV_const(slot, len);
  34         av_store(xa, MOUSE_XA_SLOT, newSVpvn_share(pv, len, 0U));
  35
  36         av_store(xa, MOUSE_XA_ATTRIBUTE, newSVsv(attr));
  37
  38         av_store(xa, MOUSE_XA_INIT_ARG, newSVsv(mcall0s(attr, "init_arg")));
  39
  40         if(predicate_calls(attr, "has_type_constraint")){
  41             SV* tc;
  42             flags |= MOUSEf_ATTR_HAS_TC;
  43
  44             tc = mcall0s(attr, "type_constraint");
  45             av_store(xa, MOUSE_XA_TC, newSVsv(tc));
  46
  47             if(predicate_calls(attr, "should_auto_deref")){
  48                 SV* const is_a_type_of = sv_2mortal(newSVpvs_share("is_a_type_of"));
  49
  50                 flags |= MOUSEf_ATTR_SHOULD_AUTO_DEREF;
  51                 if( SvTRUEx(mcall1(tc, is_a_type_of, newSVpvs_flags("ArrayRef", SVs_TEMP))) ){
  52                     flags |= MOUSEf_TC_IS_ARRAYREF;
  53                 }
  54                 else if( SvTRUEx(mcall1(tc, is_a_type_of, newSVpvs_flags("HashRef", SVs_TEMP))) ){
  55                     flags |= MOUSEf_TC_IS_HASHREF;
  56                 }
  57                 else{
  58                     mouse_throw_error(attr, tc,
  59                         "Can not auto de-reference the type constraint '%"SVf"'",
  60                             mcall0(tc, mouse_name));
  61                 }
  62             }
  63
  64             if(predicate_calls(attr, "should_coerce")){
  65                 flags |= MOUSEf_ATTR_SHOULD_COERCE;
  66             }
  67
  68         }
  69
  70         if(predicate_calls(attr, "has_trigger")){
  71             flags |= MOUSEf_ATTR_HAS_TRIGGER;
  72         }
  73
  74         if(predicate_calls(attr, "is_lazy")){
  75             flags |= MOUSEf_ATTR_IS_LAZY;
  76         }
  77         if(predicate_calls(attr, "has_builder")){
  78             flags |= MOUSEf_ATTR_HAS_BUILDER;
  79         }
  80         else if(predicate_calls(attr, "has_default")){
  81             flags |= MOUSEf_ATTR_HAS_DEFAULT;
  82         }
  83
  84         if(predicate_calls(attr, "is_weak_ref")){
  85             flags |= MOUSEf_ATTR_IS_WEAK_REF;
  86         }
  87
  88         if(predicate_calls(attr, "is_required")){
  89             flags |= MOUSEf_ATTR_IS_REQUIRED;
  90         }
  91
  92         av_store(xa, MOUSE_XA_FLAGS, newSVuv(flags));
  93         MOUSE_mg_flags(mg) = flags;
  94
  95         FREETMPS;
  96         LEAVE;
  97     }
  98     else{
  99         xa    = (AV*)MOUSE_mg_obj(mg);
 100
 101         assert(xa);
 102         assert(SvTYPE(xa) == SVt_PVAV);
 103     }
 104
 105     return xa;
 106 }
 107
 108 SV*
 109 mouse_xa_apply_type_constraint(pTHX_ AV* const xa, SV* value, U16 const flags){
 110     SV* const tc = MOUSE_xa_tc(xa);
 111     SV* tc_code;
 112
 113     if(flags & MOUSEf_ATTR_SHOULD_COERCE){
 114           value = mcall1s(tc, "coerce", value);
 115     }
 116
 117     if(!SvOK(MOUSE_xa_tc_code(xa))){
 118         tc_code = mcall0s(tc, "_compiled_type_constraint");
 119         av_store(xa, MOUSE_XA_TC_CODE, newSVsv(tc_code));
 120
 121         if(!IsCodeRef(tc_code)){
 122             mouse_throw_error(MOUSE_xa_attribute(xa), tc, "Not a CODE reference");
 123         }
 124     }
 125     else{
 126         tc_code = MOUSE_xa_tc_code(xa);
 127     }
 128
 129     if(!mouse_tc_check(aTHX_ tc_code, value)){
 130         mouse_throw_error(MOUSE_xa_attribute(xa), value,
 131             "Attribute (%"SVf") does not pass the type constraint because: %"SVf,
 132                 mcall0(MOUSE_xa_attribute(xa), mouse_name),
 133                 mcall1s(tc, "get_message", value));
 134     }
 135
 136     return value;
 137 }
 138
 139
 140 SV*
 141 mouse_xa_set_default(pTHX_ AV* const xa, SV* const object) {
 142     U16 const flags = (U16)MOUSE_xa_flags(xa);
 143     SV* value;
 144
 145     ENTER;
 146     SAVETMPS;
 147
 148     /* get default value by $attr->builder or $attr->default */
 149     if(flags & MOUSEf_ATTR_HAS_BUILDER){
 150         SV* const builder = mcall0s(MOUSE_xa_attribute(xa), "builder");
 151         value = mcall0(object, builder); /* $object->$builder() */
 152     }
 153     else {
 154         value = mcall0s(MOUSE_xa_attribute(xa), "default");
 155
 156         if(IsCodeRef(value)){
 157             value = mcall0(object, value);
 158         }
 159     }
 160
 161     /* apply coerce and type constraint */
 162     if(flags & MOUSEf_ATTR_HAS_TC){
 163         value = mouse_xa_apply_type_constraint(aTHX_ xa, value, flags);
 164     }
 165
 166     /* store value to slot */
 167     value = set_slot(object, MOUSE_xa_slot(xa), value);
 168     if(flags & MOUSEf_ATTR_IS_WEAK_REF && SvROK(value)){
 169         weaken_slot(object, MOUSE_xa_slot(xa));
 170     }
 171
 172     FREETMPS;
 173     LEAVE;
 174
 175     return value;
 176 }
 177
 178 MODULE = Mouse::Meta::Attribute  PACKAGE = Mouse::Meta::Attribute
 179
 180 PROTOTYPES: DISABLE
 181
 182 BOOT:
 183     /* readers */
 184     INSTALL_SIMPLE_READER(Attribute, name);
 185     INSTALL_SIMPLE_READER(Attribute, associated_class);
 186     INSTALL_SIMPLE_READER(Attribute, accessor);
 187     INSTALL_SIMPLE_READER(Attribute, reader);
 188     INSTALL_SIMPLE_READER(Attribute, writer);
 189     INSTALL_SIMPLE_READER(Attribute, predicate);
 190     INSTALL_SIMPLE_READER(Attribute, clearer);
 191     INSTALL_SIMPLE_READER(Attribute, handles);
 192
 193     INSTALL_SIMPLE_READER_WITH_KEY(Attribute, _is_metadata, is);
 194     INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_required, required);
 195     INSTALL_SIMPLE_READER(Attribute, default);
 196     INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_lazy, lazy);
 197     INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_lazy_build, lazy_build);
 198     INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_weak_ref, weak_ref);
 199     INSTALL_SIMPLE_READER(Attribute, init_arg);
 200     INSTALL_SIMPLE_READER(Attribute, type_constraint);
 201     INSTALL_SIMPLE_READER(Attribute, trigger);
 202     INSTALL_SIMPLE_READER(Attribute, builder);
 203     INSTALL_SIMPLE_READER_WITH_KEY(Attribute, should_auto_deref, auto_deref);
 204     INSTALL_SIMPLE_READER_WITH_KEY(Attribute, should_coerce, coerce);
 205     INSTALL_SIMPLE_READER(Attribute, documentation);
 206
 207     /* predicates */
 208     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_accessor, accessor);
 209     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_reader, reader);
 210     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_writer, writer);
 211     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_predicate, predicate);
 212     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_clearer, clearer);
 213     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_handles, handles);
 214
 215     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_default, default);
 216     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_type_constraint, type_constraint);
 217     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_trigger, trigger);
 218     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_builder, builder);
 219     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_documentation, documentation);
 220
 221     INSTALL_CLASS_HOLDER(Attribute, accessor_metaclass, "Mouse::Meta::Method::Accessor::XS");
 222