[gitmo/Mouse.git] / xs-src / MouseAttribute.xs

#include "mouse.h"

static MGVTBL mouse_xa_vtbl; /* identity */

static AV*
mouse_build_xa(pTHX_ SV* const attr) {
    AV*    xa;
    MAGIC* mg;

    SV* slot;
    STRLEN len;
    const char* pv;
    U16 flags = 0x00;

    ENTER;
    SAVETMPS;

    xa = newAV();

    mg = sv_magicext(SvRV(attr), (SV*)xa, PERL_MAGIC_ext, &mouse_xa_vtbl, NULL, 0);
    SvREFCNT_dec(xa); /* refcnt++ in sv_magicext */

    av_extend(xa, MOUSE_XA_last - 1);

    slot = mcall0(attr, mouse_name);
    pv = SvPV_const(slot, len);
    av_store(xa, MOUSE_XA_SLOT, newSVpvn_share(pv, len, 0U));

    av_store(xa, MOUSE_XA_ATTRIBUTE, newSVsv(attr));

    av_store(xa, MOUSE_XA_INIT_ARG, newSVsv(mcall0s(attr, "init_arg")));

    if(predicate_calls(attr, "has_type_constraint")){
        SV* tc;
        flags |= MOUSEf_ATTR_HAS_TC;

        tc = mcall0s(attr, "type_constraint");
        av_store(xa, MOUSE_XA_TC, newSVsv(tc));

        if(predicate_calls(attr, "should_auto_deref")){
            SV* const is_a_type_of = sv_2mortal(newSVpvs_share("is_a_type_of"));

            flags |= MOUSEf_ATTR_SHOULD_AUTO_DEREF;
            if( sv_true(mcall1(tc, is_a_type_of, newSVpvs_flags("ArrayRef", SVs_TEMP))) ){
                flags |= MOUSEf_TC_IS_ARRAYREF;
            }
            else if( sv_true(mcall1(tc, is_a_type_of, newSVpvs_flags("HashRef", SVs_TEMP))) ){
                flags |= MOUSEf_TC_IS_HASHREF;
            }
            else{
                mouse_throw_error(attr, tc,
                    "Can not auto de-reference the type constraint '%"SVf"'",
                        mcall0(tc, mouse_name));
            }
        }

        if(predicate_calls(attr, "should_coerce") && predicate_calls(tc, "has_coercion")){
            flags |= MOUSEf_ATTR_SHOULD_COERCE;
        }

    }

    if(predicate_calls(attr, "has_trigger")){
        flags |= MOUSEf_ATTR_HAS_TRIGGER;
    }

    if(predicate_calls(attr, "is_lazy")){
        flags |= MOUSEf_ATTR_IS_LAZY;
    }
    if(predicate_calls(attr, "has_builder")){
        flags |= MOUSEf_ATTR_HAS_BUILDER;
    }
    else if(predicate_calls(attr, "has_default")){
        flags |= MOUSEf_ATTR_HAS_DEFAULT;
    }

    if(predicate_calls(attr, "is_weak_ref")){
        flags |= MOUSEf_ATTR_IS_WEAK_REF;
    }

    if(predicate_calls(attr, "is_required")){
        flags |= MOUSEf_ATTR_IS_REQUIRED;
    }

    av_store(xa, MOUSE_XA_FLAGS, newSVuv(flags));
    MOUSE_mg_flags(mg) = flags;

    FREETMPS;
    LEAVE;

    return xa;
}

AV*
mouse_get_xa(pTHX_ SV* const attr) {
    AV*    xa;
    MAGIC* mg;

    if(!IsObject(attr)){
        croak("Not a Mouse meta attribute");
    }

    mg = mouse_mg_find(aTHX_ SvRV(attr), &mouse_xa_vtbl, 0x00);
    if(!mg){
        xa = mouse_build_xa(aTHX_ attr);
    }
    else{
        xa = (AV*)MOUSE_mg_obj(mg);

        assert(xa);
        assert(SvTYPE(xa) == SVt_PVAV);
    }

    return xa;
}

SV*
mouse_xa_apply_type_constraint(pTHX_ AV* const xa, SV* value, U16 const flags){
    SV* const tc = MOUSE_xa_tc(xa);
    SV* tc_code;

    if(flags & MOUSEf_ATTR_SHOULD_COERCE){
          value = mcall1(tc, mouse_coerce, value);
    }

    if(!SvOK(MOUSE_xa_tc_code(xa))){
        tc_code = mcall0s(tc, "_compiled_type_constraint");
        av_store(xa, MOUSE_XA_TC_CODE, newSVsv(tc_code));

        if(!IsCodeRef(tc_code)){
            mouse_throw_error(MOUSE_xa_attribute(xa), tc, "Not a CODE reference");
        }
    }
    else{
        tc_code = MOUSE_xa_tc_code(xa);
    }

    if(!mouse_tc_check(aTHX_ tc_code, value)){
        mouse_throw_error(MOUSE_xa_attribute(xa), value,
            "Attribute (%"SVf") does not pass the type constraint because: %"SVf,
                mcall0(MOUSE_xa_attribute(xa), mouse_name),
                mcall1s(tc, "get_message", value));
    }

    return value;
}


SV*
mouse_xa_set_default(pTHX_ AV* const xa, SV* const object) {
    U16 const flags = (U16)MOUSE_xa_flags(xa);
    SV* value;

    ENTER;
    SAVETMPS;

    /* get default value by $attr->builder or $attr->default */
    if(flags & MOUSEf_ATTR_HAS_BUILDER){
        SV* const builder = mcall0s(MOUSE_xa_attribute(xa), "builder");
        value = mcall0(object, builder); /* $object->$builder() */
    }
    else {
        value = mcall0s(MOUSE_xa_attribute(xa), "default");

        if(IsCodeRef(value)){
            value = mcall0(object, value);
        }
    }

    /* apply coerce and type constraint */
    if(flags & MOUSEf_ATTR_HAS_TC){
        value = mouse_xa_apply_type_constraint(aTHX_ xa, value, flags);
    }

    /* store value to slot */
    value = set_slot(object, MOUSE_xa_slot(xa), value);
    if(flags & MOUSEf_ATTR_IS_WEAK_REF && SvROK(value)){
        weaken_slot(object, MOUSE_xa_slot(xa));
    }

    FREETMPS;
    LEAVE;

    return value;
}

/* checks $isa->does($does) */
static void
mouse_check_isa_does_does(pTHX_ SV* const klass, SV* const name, SV* const isa, SV* const does){
    STRLEN len;
    const char* const pv = SvPV_const(isa, len); /* need strigify */
    bool does_ok;
    dSP;

    ENTER;
    SAVETMPS;

    SAVESPTR(ERRSV);
    ERRSV = sv_newmortal();

    PUSHMARK(SP);
    EXTEND(SP, 2);
    mPUSHp(pv, len);
    PUSHs(does);
    PUTBACK;

    call_method("does", G_EVAL | G_SCALAR);

    SPAGAIN;
    does_ok = sv_true(POPs);
    PUTBACK;

    FREETMPS;
    LEAVE;

    if(!does_ok){
        mouse_throw_error(klass, NULL,
            "Cannot have both an isa option and a does option"
            "because '%"SVf"' does not do '%"SVf"' on attribute (%"SVf")",
            isa, does, name
        );
    }
}

MODULE = Mouse::Meta::Attribute  PACKAGE = Mouse::Meta::Attribute

PROTOTYPES: DISABLE

BOOT:
    /* readers */
    INSTALL_SIMPLE_READER(Attribute, name);
    INSTALL_SIMPLE_READER(Attribute, associated_class);
    INSTALL_SIMPLE_READER(Attribute, accessor);
    INSTALL_SIMPLE_READER(Attribute, reader);
    INSTALL_SIMPLE_READER(Attribute, writer);
    INSTALL_SIMPLE_READER(Attribute, predicate);
    INSTALL_SIMPLE_READER(Attribute, clearer);
    INSTALL_SIMPLE_READER(Attribute, handles);

    INSTALL_SIMPLE_READER_WITH_KEY(Attribute, _is_metadata, is);
    INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_required, required);
    INSTALL_SIMPLE_READER(Attribute, default);
    INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_lazy, lazy);
    INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_lazy_build, lazy_build);
    INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_weak_ref, weak_ref);
    INSTALL_SIMPLE_READER(Attribute, init_arg);
    INSTALL_SIMPLE_READER(Attribute, type_constraint);
    INSTALL_SIMPLE_READER(Attribute, trigger);
    INSTALL_SIMPLE_READER(Attribute, builder);
    INSTALL_SIMPLE_READER_WITH_KEY(Attribute, should_auto_deref, auto_deref);
    INSTALL_SIMPLE_READER_WITH_KEY(Attribute, should_coerce, coerce);
    INSTALL_SIMPLE_READER(Attribute, documentation);
    INSTALL_SIMPLE_READER(Attribute, insertion_order);

    /* predicates */
    INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_accessor, accessor);
    INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_reader, reader);
    INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_writer, writer);
    INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_predicate, predicate);
    INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_clearer, clearer);
    INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_handles, handles);

    INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_default, default);
    INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_type_constraint, type_constraint);
    INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_trigger, trigger);
    INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_builder, builder);
    INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_documentation, documentation);

    INSTALL_CLASS_HOLDER(Attribute, accessor_metaclass, "Mouse::Meta::Method::Accessor::XS");

void
_process_options(SV* klass, SV* name, HV* args)
CODE:
{
    /* TODO: initialize 'xa' here */
    SV** svp;
    SV* tc = NULL;

    /* 'required' requires eigher 'init_arg', 'builder', or 'default' */
    bool can_be_required = FALSE;
    bool has_default     = FALSE;
    bool has_builder     = FALSE;

    /* taken from Class::MOP::Attribute::new */

    must_defined(name, "an attribute name");

    svp = hv_fetchs(args, "init_arg", FALSE);
    if(!svp){
        (void)hv_stores(args, "init_arg", newSVsv(name));
        can_be_required = TRUE;
    }
    else{
        can_be_required = SvOK(*svp) ? TRUE : FALSE;
    }

    svp = hv_fetchs(args, "builder", FALSE);
    if(svp){
        if(!SvOK(*svp)){
            mouse_throw_error(klass, *svp,
                "builder must be a defined scalar value which is a method name");
        }
        can_be_required = TRUE;
        has_builder     = TRUE;
    }
    else if((svp = hv_fetchs(args, "default", FALSE))){
        if(SvROK(*svp) && SvTYPE(SvRV(*svp)) != SVt_PVCV) {
            mouse_throw_error(klass, *svp,
               "References are not allowed as default values, you must "
                "wrap the default of '%"SVf"' in a CODE reference "
                "(ex: sub { [] } and not [])", name);
        }
        can_be_required = TRUE;
        has_default     = TRUE;
    }

    svp = hv_fetchs(args, "required", FALSE);
    if( (svp && sv_true(*svp)) && !can_be_required){
        mouse_throw_error(klass, NULL,
            "You cannot have a required attribute (%"SVf") "
            "without a default, builder, or an init_arg", name);
    }

    /* taken from Mouse::Meta::Attribute->new and ->_process_args */

    svp = hv_fetchs(args, "is", FALSE);
    if(svp){
        const char* const is = SvOK(*svp) ? SvPV_nolen_const(*svp) : "undef";
        if(strEQ(is, "ro")){
            svp = hv_fetchs(args, "reader", TRUE);
            if(!sv_true(*svp)){
                sv_setsv(*svp, name);
            }
        }
        else if(strEQ(is, "rw")){
            if(hv_fetchs(args, "writer", FALSE)){
                svp = hv_fetchs(args, "reader", TRUE);
            }
            else{
                svp = hv_fetchs(args, "accessor", TRUE);
            }
            if(!SvOK(*svp)) {
                sv_setsv(*svp, name);
            }
        }
        else if(strEQ(is, "bare")){
            /* do nothing, but might complain later about missing methods */
        }
        else{
            mouse_throw_error(klass, NULL,
                "I do not understand this option (is => %s) on attribute (%"SVf")",
                is, name);
        }
    }

    svp = hv_fetchs(args, "isa", FALSE);
    if(svp){
        SPAGAIN;
        PUSHMARK(SP);
        XPUSHs(*svp);
        PUTBACK;

        call_pv("Mouse::Util::TypeConstraints::find_or_create_isa_type_constraint",
            G_SCALAR);
        SPAGAIN;
        tc = newSVsv(POPs);
        PUTBACK;
    }

    if((svp = hv_fetchs(args, "does", FALSE))){
        /* check 'isa' does 'does' */
        if(tc){
            mouse_check_isa_does_does(aTHX_ klass, name, tc, *svp);
            /* nothing to do */
        }
        else{
            SPAGAIN;
            PUSHMARK(SP);
            XPUSHs(*svp);
            PUTBACK;

            call_pv("Mouse::Util::TypeConstraints::find_or_create_does_type_constraint",
                G_SCALAR);
            SPAGAIN;
            tc = newSVsv(POPs);
            PUTBACK;
        }
    }
    if(tc){
        (void)hv_stores(args, "type_constraint", tc);
    }

    svp = hv_fetchs(args, "coerce", FALSE);
    if(svp){
        if(!tc){
            mouse_throw_error(klass, NULL,
                "You cannot have coercion without specifying a type constraint "
                "on attribute (%"SVf")", name);
        }
        svp = hv_fetchs(args, "weak_ref", FALSE);
        if(svp && sv_true(*svp)){
            mouse_throw_error(klass, NULL,
                "You cannot have a weak reference to a coerced value on "
                "attribute (%"SVf")", name);
        }
    }

    svp = hv_fetchs(args, "lazy_build", FALSE);
    if(svp){
        SV* clearer;
        SV* predicate;
        if(has_default){
            mouse_throw_error(klass, NULL,
                "You can not use lazy_build and default for the same "
                "attribute (%"SVf")", name);
        }

        svp = hv_fetchs(args, "lazy", TRUE);
        sv_setiv(*svp, TRUE);

        svp = hv_fetchs(args, "builder", TRUE);
        if(!sv_true(*svp)){
            sv_setpvf(*svp, "_build_%"SVf, name);
        }
        has_builder = TRUE;

        clearer   = *hv_fetchs(args, "clearer",   TRUE);
        predicate = *hv_fetchs(args, "predicate", TRUE);

        if(SvPV_nolen_const(name)[0] == '_'){
            if(!sv_true(clearer)){
                sv_setpvf(clearer, "_clear%"SVf, name);
            }
            if(!sv_true(predicate)){
                sv_setpvf(predicate, "_has%"SVf, name);
            }
        }
        else{
            if(!sv_true(clearer)){
                sv_setpvf(clearer, "clear_%"SVf, name);
            }
            if(!sv_true(predicate)){
                sv_setpvf(predicate, "has_%"SVf, name);
            }
        }
    }

    svp = hv_fetchs(args, "auto_deref", FALSE);
    if(svp && sv_true(*svp)){
        SV* const meth = sv_2mortal(newSVpvs_share("is_a_type_of"));
        if(!tc){
            mouse_throw_error(klass, NULL,
                "You cannot auto-dereference without specifying a type "
                "constraint on attribute (%"SVf")", name);
        }

        if(!(sv_true(mcall1(tc, meth, newSVpvs_flags("ArrayRef", SVs_TEMP)))
            || sv_true(mcall1(tc, meth, newSVpvs_flags("HashRef", SVs_TEMP))) )){
            mouse_throw_error(klass, NULL,
                "You cannot auto-dereference anything other than a ArrayRef "
                "or HashRef on attribute (%"SVf")", name);
        }
    }

    svp = hv_fetchs(args, "trigger", FALSE);
    if(svp){
        if(!IsCodeRef(*svp)){
            mouse_throw_error(klass, NULL,
                "Trigger must be a CODE ref on attribute (%"SVf")",
                name);
        }
    }


    svp = hv_fetchs(args, "lazy", FALSE);
    if(svp && sv_true(*svp)){
        if(!(has_default || has_builder)){
            mouse_throw_error(klass, NULL,
                "You cannot have a lazy attribute (%"SVf") without specifying "
                "a default value for it", name);
        }
    }
}
Commit	Line	Data
aa2d2e2c	1	#include "mouse.h"
aa2d2e2c	2
c6b8ac47	3	static MGVTBL mouse_xa_vtbl; /* identity */
0aad0266	4
c6b8ac47	5	static AV*
	6	mouse_build_xa(pTHX_ SV* const attr) {
	7	AV* xa;
0aad0266	8	MAGIC* mg;
0aad0266	9
c6b8ac47	10	SV* slot;
	11	STRLEN len;
	12	const char* pv;
	13	U16 flags = 0x00;
0aad0266	14
c6b8ac47	15	ENTER;
c6b8ac47	16	SAVETMPS;
0aad0266	17
bc97157e	18	xa = newAV();
0aad0266	19
c6b8ac47	20	mg = sv_magicext(SvRV(attr), (SV*)xa, PERL_MAGIC_ext, &mouse_xa_vtbl, NULL, 0);
c6b8ac47	21	SvREFCNT_dec(xa); /* refcnt++ in sv_magicext */
0aad0266	22
c6b8ac47	23	av_extend(xa, MOUSE_XA_last - 1);
0aad0266	24
c6b8ac47	25	slot = mcall0(attr, mouse_name);
	26	pv = SvPV_const(slot, len);
	27	av_store(xa, MOUSE_XA_SLOT, newSVpvn_share(pv, len, 0U));
0aad0266	28
c6b8ac47	29	av_store(xa, MOUSE_XA_ATTRIBUTE, newSVsv(attr));
0aad0266	30
c6b8ac47	31	av_store(xa, MOUSE_XA_INIT_ARG, newSVsv(mcall0s(attr, "init_arg")));
4e7e3250	32
c6b8ac47	33	if(predicate_calls(attr, "has_type_constraint")){
	34	SV* tc;
	35	flags \|= MOUSEf_ATTR_HAS_TC;
0aad0266	36
c6b8ac47	37	tc = mcall0s(attr, "type_constraint");
c6b8ac47	38	av_store(xa, MOUSE_XA_TC, newSVsv(tc));
0aad0266	39
c6b8ac47	40	if(predicate_calls(attr, "should_auto_deref")){
c6b8ac47	41	SV* const is_a_type_of = sv_2mortal(newSVpvs_share("is_a_type_of"));
0aad0266	42
c6b8ac47	43	flags \|= MOUSEf_ATTR_SHOULD_AUTO_DEREF;
	44	if( sv_true(mcall1(tc, is_a_type_of, newSVpvs_flags("ArrayRef", SVs_TEMP))) ){
	45	flags \|= MOUSEf_TC_IS_ARRAYREF;
0aad0266	46	}
c6b8ac47	47	else if( sv_true(mcall1(tc, is_a_type_of, newSVpvs_flags("HashRef", SVs_TEMP))) ){
	48	flags \|= MOUSEf_TC_IS_HASHREF;
	49	}
	50	else{
	51	mouse_throw_error(attr, tc,
	52	"Can not auto de-reference the type constraint '%"SVf"'",
	53	mcall0(tc, mouse_name));
0aad0266	54	}
0aad0266	55	}
0aad0266	56
de0d4152	57	if(predicate_calls(attr, "should_coerce") && predicate_calls(tc, "has_coercion")){
c6b8ac47	58	flags \|= MOUSEf_ATTR_SHOULD_COERCE;
0aad0266	59	}
0aad0266	60
c6b8ac47	61	}
0aad0266	62
c6b8ac47	63	if(predicate_calls(attr, "has_trigger")){
	64	flags \|= MOUSEf_ATTR_HAS_TRIGGER;
	65	}
0aad0266	66
c6b8ac47	67	if(predicate_calls(attr, "is_lazy")){
	68	flags \|= MOUSEf_ATTR_IS_LAZY;
	69	}
	70	if(predicate_calls(attr, "has_builder")){
	71	flags \|= MOUSEf_ATTR_HAS_BUILDER;
	72	}
	73	else if(predicate_calls(attr, "has_default")){
	74	flags \|= MOUSEf_ATTR_HAS_DEFAULT;
	75	}
	76
	77	if(predicate_calls(attr, "is_weak_ref")){
	78	flags \|= MOUSEf_ATTR_IS_WEAK_REF;
	79	}
	80
	81	if(predicate_calls(attr, "is_required")){
	82	flags \|= MOUSEf_ATTR_IS_REQUIRED;
	83	}
	84
	85	av_store(xa, MOUSE_XA_FLAGS, newSVuv(flags));
	86	MOUSE_mg_flags(mg) = flags;
	87
	88	FREETMPS;
	89	LEAVE;
	90
	91	return xa;
	92	}
	93
	94	AV*
	95	mouse_get_xa(pTHX_ SV* const attr) {
	96	AV* xa;
	97	MAGIC* mg;
0aad0266	98
c6b8ac47	99	if(!IsObject(attr)){
	100	croak("Not a Mouse meta attribute");
	101	}
0aad0266	102
c6b8ac47	103	mg = mouse_mg_find(aTHX_ SvRV(attr), &mouse_xa_vtbl, 0x00);
	104	if(!mg){
	105	xa = mouse_build_xa(aTHX_ attr);
0aad0266	106	}
0aad0266	107	else{
c6b8ac47	108	xa = (AV*)MOUSE_mg_obj(mg);
0aad0266	109
	110	assert(xa);
	111	assert(SvTYPE(xa) == SVt_PVAV);
	112	}
	113
	114	return xa;
	115	}
	116
4e7e3250	117	SV*
	118	mouse_xa_apply_type_constraint(pTHX_ AV* const xa, SV* value, U16 const flags){
	119	SV* const tc = MOUSE_xa_tc(xa);
	120	SV* tc_code;
	121
	122	if(flags & MOUSEf_ATTR_SHOULD_COERCE){
d39ac61c	123	value = mcall1(tc, mouse_coerce, value);
4e7e3250	124	}
	125
	126	if(!SvOK(MOUSE_xa_tc_code(xa))){
	127	tc_code = mcall0s(tc, "_compiled_type_constraint");
	128	av_store(xa, MOUSE_XA_TC_CODE, newSVsv(tc_code));
	129
	130	if(!IsCodeRef(tc_code)){
	131	mouse_throw_error(MOUSE_xa_attribute(xa), tc, "Not a CODE reference");
	132	}
	133	}
	134	else{
	135	tc_code = MOUSE_xa_tc_code(xa);
	136	}
	137
	138	if(!mouse_tc_check(aTHX_ tc_code, value)){
	139	mouse_throw_error(MOUSE_xa_attribute(xa), value,
	140	"Attribute (%"SVf") does not pass the type constraint because: %"SVf,
	141	mcall0(MOUSE_xa_attribute(xa), mouse_name),
	142	mcall1s(tc, "get_message", value));
	143	}
	144
	145	return value;
	146	}
	147
	148
	149	SV*
	150	mouse_xa_set_default(pTHX_ AV* const xa, SV* const object) {
	151	U16 const flags = (U16)MOUSE_xa_flags(xa);
	152	SV* value;
	153
3f2c3dc7	154	ENTER;
	155	SAVETMPS;
	156
4e7e3250	157	/* get default value by $attr->builder or $attr->default */
	158	if(flags & MOUSEf_ATTR_HAS_BUILDER){
	159	SV* const builder = mcall0s(MOUSE_xa_attribute(xa), "builder");
	160	value = mcall0(object, builder); /* $object->$builder() */
	161	}
	162	else {
	163	value = mcall0s(MOUSE_xa_attribute(xa), "default");
	164
	165	if(IsCodeRef(value)){
	166	value = mcall0(object, value);
	167	}
	168	}
	169
	170	/* apply coerce and type constraint */
	171	if(flags & MOUSEf_ATTR_HAS_TC){
	172	value = mouse_xa_apply_type_constraint(aTHX_ xa, value, flags);
	173	}
	174
	175	/* store value to slot */
	176	value = set_slot(object, MOUSE_xa_slot(xa), value);
4e7e3250	177	if(flags & MOUSEf_ATTR_IS_WEAK_REF && SvROK(value)){
	178	weaken_slot(object, MOUSE_xa_slot(xa));
	179	}
	180
3f2c3dc7	181	FREETMPS;
	182	LEAVE;
	183
4e7e3250	184	return value;
4e7e3250	185	}
0aad0266	186
fc7e5b5f	187	/* checks $isa->does($does) */
d503a4f3	188	static void
	189	mouse_check_isa_does_does(pTHX_ SV* const klass, SV* const name, SV* const isa, SV* const does){
	190	STRLEN len;
	191	const char* const pv = SvPV_const(isa, len); /* need strigify */
	192	bool does_ok;
	193	dSP;
	194
	195	ENTER;
	196	SAVETMPS;
	197
	198	SAVESPTR(ERRSV);
	199	ERRSV = sv_newmortal();
	200
	201	PUSHMARK(SP);
	202	EXTEND(SP, 2);
	203	mPUSHp(pv, len);
	204	PUSHs(does);
	205	PUTBACK;
	206
	207	call_method("does", G_EVAL \| G_SCALAR);
	208
	209	SPAGAIN;
	210	does_ok = sv_true(POPs);
	211	PUTBACK;
	212
	213	FREETMPS;
	214	LEAVE;
	215
	216	if(!does_ok){
	217	mouse_throw_error(klass, NULL,
	218	"Cannot have both an isa option and a does option"
	219	"because '%"SVf"' does not do '%"SVf"' on attribute (%"SVf")",
	220	isa, does, name
	221	);
	222	}
	223	}
	224
aa2d2e2c	225	MODULE = Mouse::Meta::Attribute PACKAGE = Mouse::Meta::Attribute
	226
	227	PROTOTYPES: DISABLE
	228
	229	BOOT:
	230	/* readers */
	231	INSTALL_SIMPLE_READER(Attribute, name);
	232	INSTALL_SIMPLE_READER(Attribute, associated_class);
	233	INSTALL_SIMPLE_READER(Attribute, accessor);
	234	INSTALL_SIMPLE_READER(Attribute, reader);
	235	INSTALL_SIMPLE_READER(Attribute, writer);
	236	INSTALL_SIMPLE_READER(Attribute, predicate);
	237	INSTALL_SIMPLE_READER(Attribute, clearer);
	238	INSTALL_SIMPLE_READER(Attribute, handles);
	239
	240	INSTALL_SIMPLE_READER_WITH_KEY(Attribute, _is_metadata, is);
	241	INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_required, required);
	242	INSTALL_SIMPLE_READER(Attribute, default);
	243	INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_lazy, lazy);
	244	INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_lazy_build, lazy_build);
	245	INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_weak_ref, weak_ref);
	246	INSTALL_SIMPLE_READER(Attribute, init_arg);
	247	INSTALL_SIMPLE_READER(Attribute, type_constraint);
	248	INSTALL_SIMPLE_READER(Attribute, trigger);
	249	INSTALL_SIMPLE_READER(Attribute, builder);
	250	INSTALL_SIMPLE_READER_WITH_KEY(Attribute, should_auto_deref, auto_deref);
	251	INSTALL_SIMPLE_READER_WITH_KEY(Attribute, should_coerce, coerce);
	252	INSTALL_SIMPLE_READER(Attribute, documentation);
beb51b30	253	INSTALL_SIMPLE_READER(Attribute, insertion_order);
aa2d2e2c	254
	255	/* predicates */
	256	INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_accessor, accessor);
	257	INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_reader, reader);
	258	INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_writer, writer);
	259	INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_predicate, predicate);
	260	INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_clearer, clearer);
	261	INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_handles, handles);
	262
	263	INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_default, default);
	264	INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_type_constraint, type_constraint);
	265	INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_trigger, trigger);
	266	INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_builder, builder);
	267	INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_documentation, documentation);
	268
787f84c2	269	INSTALL_CLASS_HOLDER(Attribute, accessor_metaclass, "Mouse::Meta::Method::Accessor::XS");
aa2d2e2c	270
ba1f50a2	271	void
	272	_process_options(SV* klass, SV* name, HV* args)
	273	CODE:
	274	{
fc7e5b5f	275	/* TODO: initialize 'xa' here */
ba1f50a2	276	SV** svp;
	277	SV* tc = NULL;
	278
	279	/* 'required' requires eigher 'init_arg', 'builder', or 'default' */
	280	bool can_be_required = FALSE;
	281	bool has_default = FALSE;
	282	bool has_builder = FALSE;
	283
	284	/* taken from Class::MOP::Attribute::new */
	285
d06d9266	286	must_defined(name, "an attribute name");
ba1f50a2	287
	288	svp = hv_fetchs(args, "init_arg", FALSE);
	289	if(!svp){
	290	(void)hv_stores(args, "init_arg", newSVsv(name));
	291	can_be_required = TRUE;
	292	}
	293	else{
	294	can_be_required = SvOK(*svp) ? TRUE : FALSE;
	295	}
	296
	297	svp = hv_fetchs(args, "builder", FALSE);
	298	if(svp){
	299	if(!SvOK(*svp)){
077f2efd	300	mouse_throw_error(klass, *svp,
ba1f50a2	301	"builder must be a defined scalar value which is a method name");
	302	}
	303	can_be_required = TRUE;
	304	has_builder = TRUE;
	305	}
	306	else if((svp = hv_fetchs(args, "default", FALSE))){
	307	if(SvROK(svp) && SvTYPE(SvRV(svp)) != SVt_PVCV) {
077f2efd	308	mouse_throw_error(klass, *svp,
ba1f50a2	309	"References are not allowed as default values, you must "
	310	"wrap the default of '%"SVf"' in a CODE reference "
	311	"(ex: sub { [] } and not [])", name);
	312	}
	313	can_be_required = TRUE;
	314	has_default = TRUE;
	315	}
	316
	317	svp = hv_fetchs(args, "required", FALSE);
	318	if( (svp && sv_true(*svp)) && !can_be_required){
	319	mouse_throw_error(klass, NULL,
	320	"You cannot have a required attribute (%"SVf") "
	321	"without a default, builder, or an init_arg", name);
	322	}
	323
bc97157e	324	/* taken from Mouse::Meta::Attribute->new and ->_process_args */
ba1f50a2	325
	326	svp = hv_fetchs(args, "is", FALSE);
	327	if(svp){
	328	const char* const is = SvOK(svp) ? SvPV_nolen_const(svp) : "undef";
	329	if(strEQ(is, "ro")){
	330	svp = hv_fetchs(args, "reader", TRUE);
	331	if(!sv_true(*svp)){
	332	sv_setsv(*svp, name);
	333	}
	334	}
	335	else if(strEQ(is, "rw")){
	336	if(hv_fetchs(args, "writer", FALSE)){
	337	svp = hv_fetchs(args, "reader", TRUE);
	338	}
	339	else{
	340	svp = hv_fetchs(args, "accessor", TRUE);
	341	}
0464d337	342	if(!SvOK(*svp)) {
	343	sv_setsv(*svp, name);
	344	}
ba1f50a2	345	}
ba1f50a2	346	else if(strEQ(is, "bare")){
bc97157e	347	/* do nothing, but might complain later about missing methods */
ba1f50a2	348	}
	349	else{
	350	mouse_throw_error(klass, NULL,
	351	"I do not understand this option (is => %s) on attribute (%"SVf")",
	352	is, name);
	353	}
	354	}
	355
	356	svp = hv_fetchs(args, "isa", FALSE);
	357	if(svp){
	358	SPAGAIN;
	359	PUSHMARK(SP);
	360	XPUSHs(*svp);
	361	PUTBACK;
	362
	363	call_pv("Mouse::Util::TypeConstraints::find_or_create_isa_type_constraint",
	364	G_SCALAR);
	365	SPAGAIN;
	366	tc = newSVsv(POPs);
	367	PUTBACK;
	368	}
ba1f50a2	369
d503a4f3	370	if((svp = hv_fetchs(args, "does", FALSE))){
	371	/* check 'isa' does 'does' */
	372	if(tc){
	373	mouse_check_isa_does_does(aTHX_ klass, name, tc, *svp);
	374	/* nothing to do */
	375	}
	376	else{
	377	SPAGAIN;
	378	PUSHMARK(SP);
	379	XPUSHs(*svp);
	380	PUTBACK;
	381
	382	call_pv("Mouse::Util::TypeConstraints::find_or_create_does_type_constraint",
	383	G_SCALAR);
	384	SPAGAIN;
	385	tc = newSVsv(POPs);
	386	PUTBACK;
	387	}
ba1f50a2	388	}
	389	if(tc){
	390	(void)hv_stores(args, "type_constraint", tc);
	391	}
	392
	393	svp = hv_fetchs(args, "coerce", FALSE);
	394	if(svp){
	395	if(!tc){
	396	mouse_throw_error(klass, NULL,
	397	"You cannot have coercion without specifying a type constraint "
	398	"on attribute (%"SVf")", name);
	399	}
	400	svp = hv_fetchs(args, "weak_ref", FALSE);
	401	if(svp && sv_true(*svp)){
	402	mouse_throw_error(klass, NULL,
	403	"You cannot have a weak reference to a coerced value on "
	404	"attribute (%"SVf")", name);
	405	}
	406	}
	407
	408	svp = hv_fetchs(args, "lazy_build", FALSE);
	409	if(svp){
	410	SV* clearer;
	411	SV* predicate;
	412	if(has_default){
	413	mouse_throw_error(klass, NULL,
	414	"You can not use lazy_build and default for the same "
	415	"attribute (%"SVf")", name);
	416	}
	417
	418	svp = hv_fetchs(args, "lazy", TRUE);
	419	sv_setiv(*svp, TRUE);
	420
	421	svp = hv_fetchs(args, "builder", TRUE);
	422	if(!sv_true(*svp)){
	423	sv_setpvf(*svp, "_build_%"SVf, name);
	424	}
	425	has_builder = TRUE;
	426
	427	clearer = *hv_fetchs(args, "clearer", TRUE);
	428	predicate = *hv_fetchs(args, "predicate", TRUE);
	429
	430	if(SvPV_nolen_const(name)[0] == '_'){
	431	if(!sv_true(clearer)){
	432	sv_setpvf(clearer, "_clear%"SVf, name);
	433	}
	434	if(!sv_true(predicate)){
	435	sv_setpvf(predicate, "_has%"SVf, name);
	436	}
	437	}
	438	else{
	439	if(!sv_true(clearer)){
	440	sv_setpvf(clearer, "clear_%"SVf, name);
	441	}
	442	if(!sv_true(predicate)){
	443	sv_setpvf(predicate, "has_%"SVf, name);
	444	}
	445	}
	446	}
	447
	448	svp = hv_fetchs(args, "auto_deref", FALSE);
	449	if(svp && sv_true(*svp)){
	450	SV* const meth = sv_2mortal(newSVpvs_share("is_a_type_of"));
	451	if(!tc){
452	mouse_throw_error(klass, NULL,
453	"You cannot auto-dereference without specifying a type "
454	"constraint on attribute (%"SVf")", name);
455	}
456
457	if(!(sv_true(mcall1(tc, meth, newSVpvs_flags("ArrayRef", SVs_TEMP)))
458	\|\| sv_true(mcall1(tc, meth, newSVpvs_flags("HashRef", SVs_TEMP))) )){
459	mouse_throw_error(klass, NULL,
460	"You cannot auto-dereference anything other than a ArrayRef "
461	"or HashRef on attribute (%"SVf")", name);
462	}
463	}
464
465	svp = hv_fetchs(args, "trigger", FALSE);
466	if(svp){
467	if(!IsCodeRef(*svp)){
468	mouse_throw_error(klass, NULL,
469	"Trigger must be a CODE ref on attribute (%"SVf")",
470	name);
471	}
472	}
473
474
475	svp = hv_fetchs(args, "lazy", FALSE);
476	if(svp && sv_true(*svp)){
477	if(!(has_default \|\| has_builder)){
478	mouse_throw_error(klass, NULL,
2c689df4	479	"You cannot have a lazy attribute (%"SVf") without specifying "
ba1f50a2	480	"a default value for it", name);
	481	}
	482	}
	483	}