File Coverage

blib/lib/Tangence/Meta/Property.pm
Criterion Covered Total %
statement 29 32 90.6
branch 5 6 83.3
condition 7 9 77.7
subroutine 10 11 90.9
pod 6 7 85.7
total 57 65 87.6


line stmt bran cond sub pod time code
1             # You may distribute under the terms of either the GNU General Public License
2             # or the Artistic License (the same terms as Perl itself)
3             #
4             # (C) Paul Evans, 2011-2022 -- leonerd@leonerd.org.uk
5              
6 15     15   194 use v5.26;
  15         56  
7 15     15   79 use Object::Pad 0.66 ':experimental(init_expr)';
  15         172  
  15         76  
8              
9             package Tangence::Meta::Property 0.30;
10             class Tangence::Meta::Property :strict(params);
11              
12 15     15   6822 use Syntax::Keyword::Match;
  15         2583  
  15         99  
13              
14 15     15   990 use Tangence::Constants;
  15         34  
  15         17403  
15              
16             =head1 NAME
17              
18             C - structure representing one C property
19              
20             =head1 DESCRIPTION
21              
22             This data structure object stores information about one L class
23             property. Once constructed, such objects are immutable.
24              
25             =cut
26              
27             =head1 CONSTRUCTOR
28              
29             =cut
30              
31             =head2 new
32              
33             $property = Tangence::Meta::Property->new( %args )
34              
35             Returns a new instance initialised by the given arguments.
36              
37             =over 8
38              
39             =item class => Tangence::Meta::Class
40              
41             Reference to the containing class
42              
43             =item name => STRING
44              
45             Name of the property
46              
47             =item dimension => INT
48              
49             Dimension of the property, as one of the C constants from
50             L.
51              
52             =item type => STRING
53              
54             The element type as a L reference.
55              
56             =item smashed => BOOL
57              
58             Optional. If true, marks that the property is smashed.
59              
60             =back
61              
62             =cut
63              
64 1     1 1 502 field $class :param :weak :reader;
  1         5  
65 124     124 1 2136 field $name :param :reader;
  124         370  
66 480     480 1 893 field $dimension :param :reader;
  480         1441  
67 272     272 1 556 field $type :param :reader;
  272         899  
68 192     192 1 352 field $smashed :param :reader { 0 };
  192         541  
69              
70             =head1 ACCESSORS
71              
72             =cut
73              
74             =head2 class
75              
76             $class = $property->class
77              
78             Returns the class the property is a member of
79              
80             =cut
81              
82             =head2 name
83              
84             $name = $property->name
85              
86             Returns the name of the class
87              
88             =cut
89              
90             =head2 dimension
91              
92             $dimension = $property->dimension
93              
94             Returns the dimension as one of the C constants.
95              
96             =cut
97              
98             =head2 type
99              
100             $type = $property->type
101              
102             Returns the element type as a L reference.
103              
104             =cut
105              
106             =head2 overall_type
107              
108             $type = $property->overall_type
109              
110             Returns the type of the entire collection as a L
111             reference. For scalar types this will be the element type. For dict types this
112             will be a hash of the array type. For array, queue and objset types this will
113             a list of the element type.
114              
115             =cut
116              
117             field $_overall_type;
118              
119             method overall_type
120 90     90 1 220 {
121 90   66     297 return $_overall_type ||= do {
122 61         184 my $type = $self->type;
123 61         145 my $dim = $self->dimension;
124             match( $dim : == ) {
125             case( DIM_SCALAR ) {
126 30         167 $type;
127             }
128             case( DIM_HASH ) {
129 4         23 $self->make_type( dict => $type );
130             }
131             case( DIM_ARRAY ), case( DIM_QUEUE ), case( DIM_OBJSET ) {
132 27         104 $self->make_type( list => $type );
133             }
134 61 100 100     313 default {
    100 66        
    50          
135 0           die "Unrecognised dimension $dim for ->overall_type";
136             }
137             }
138             }
139             }
140              
141             =head2 smashed
142              
143             $smashed = $property->smashed
144              
145             Returns true if the property is smashed.
146              
147             =cut
148              
149             # For subclasses to override if required
150             method make_type
151 0     0 0   {
152 0           return Tangence::Meta::Type->make( @_ );
153             }
154              
155             =head1 AUTHOR
156              
157             Paul Evans
158              
159             =cut
160              
161             0x55AA;
162