view release on metacpan or  search on metacpan

lib/Mongoose/Engine.pm  view on Meta::CPAN

385
386
387
388
389
390
391
392
393
394
395
    }
 
    return undef;
}
 
#sub delete_cascade {
#   my ($self, $args )=@_;
#   #TODO delete related collections
#}
 
sub db {

 view release on metacpan or  search on metacpan

lib/Monitoring/GLPlugin/SNMP/MibsAndOids/EMDMIB.pm  view on Meta::CPAN

47
48
49
50
51
52
53
54
55
56
57
deviceInetIPAddress => '1.3.6.1.4.1.13742.8.1.1.1.10',
deviceInetNetmask => '1.3.6.1.4.1.13742.8.1.1.1.11',
deviceInetGateway => '1.3.6.1.4.1.13742.8.1.1.1.12',
serverCount => '1.3.6.1.4.1.13742.8.1.1.1.13',
model => '1.3.6.1.4.1.13742.8.1.1.1.14',
cascadedDeviceConnected => '1.3.6.1.4.1.13742.8.1.1.1.15',
logConfiguration => '1.3.6.1.4.1.13742.8.1.1.2',
dataLogging => '1.3.6.1.4.1.13742.8.1.1.2.1',
measurementPeriod => '1.3.6.1.4.1.13742.8.1.1.2.2',
measurementsPerLogEntry => '1.3.6.1.4.1.13742.8.1.1.2.3',
logSize => '1.3.6.1.4.1.13742.8.1.1.2.4',

 view release on metacpan or  search on metacpan

t/20-complex_filter.t  view on Meta::CPAN

40
41
42
43
44
45
46
47
48
49
50
    "Filter: state = 1",
    "Or: 2",
    "Filter: group >= linux",
],
 
# cascaded query
[
    -and => [
        -or => [
          state => { '='  => 0 },
          state => { '='  => 1 },

 view release on metacpan or  search on metacpan

t/20-complex_filter.t  view on Meta::CPAN

40
41
42
43
44
45
46
47
48
49
50
    "Filter: state = 1",
    "Or: 2",
    "Filter: group >= linux",
],
 
# cascaded query
[
    -and => [
        -or => [
          state => { '='  => 0 },
          state => { '='  => 1 },

 view release on metacpan or  search on metacpan

lib/MooX/PluginKit/Consumer.pm  view on Meta::CPAN

97
98
99
100
101
102
103
104
105
106
107
    has_pluggable_object foo_bar => (
        class => 'Foo::Bar',
    );
 
This function acts like L<Moo/has> but adds a bunch of functionality,
making it easy to cascade the creation of objects which automatically
have applicable plugins applied to them, at run-time.
 
In the above C<foo_bar> example, the user of your class can then specify
the C<foo_bar> argument as a hashref.  This hashref will be used to
create an object of the C<Foo::Bar> class, but not until after any

 view release on metacpan or  search on metacpan

lib/MooseX/CascadeClearing.pm  view on Meta::CPAN

150
151
152
153
154
155
156
157
158
159
160
    }
 
=head1 DESCRIPTION
 
MooseX::CascadeClearing does the necessary metaclass fiddling to allow an
clearing one attribute to be cascaded through to other attributes as well,
calling their clear accessors.
 
The intended purpose of this is to assist in situations where the value of one
attribute is derived from the value of another attribute -- say a situation
where the secondary value is expensive to derive and is thus lazily built.  A

lib/MooseX/CascadeClearing.pm  view on Meta::CPAN

166
167
168
169
170
171
172
173
174
175
 
=for Pod::Coverage init_meta
 
=head1 CAVEAT
 
We don't yet trigger a cascade clear on a master attribute's value being set
through a setter/accessor accessor.  This will likely be available as an
option in the not-too-distant-future.
 
=head1 ATTRIBUTE OPTIONS

lib/MooseX/CascadeClearing.pm  view on Meta::CPAN

194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
 
=back
 
=head1 SOURCE
 
The development version is on github at L<http://github.com/RsrchBoy/moosex-cascadeclearing>
and may be cloned from L<git://github.com/RsrchBoy/moosex-cascadeclearing.git>
 
=head1 BUGS
 
Please report any bugs or feature requests on the bugtracker website
https://github.com/RsrchBoy/moosex-cascadeclearing/issues
 
When submitting a bug or request, please include a test-file or a
patch to an existing test-file that illustrates the bug or desired
feature.

 view release on metacpan or  search on metacpan

lib/MooseX/ConfigCascade.pm  view on Meta::CPAN

3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
our $VERSION = '0.02';
 
use Moose::Role;
use MooseX::ConfigCascade::Util;
 
has cascade_util => (is => 'ro', lazy => 1, isa => 'MooseX::ConfigCascade::Util', default => sub{
    MooseX::ConfigCascade::Util->new(
        _to_set => $_[0],
        _role_name => __PACKAGE__
    );
});
 
 
sub BUILD{}
after BUILD => sub{
    my ($self,$args) = @_;
    my $util = $self->cascade_util;
    foreach my $k (keys %$args){ $util->_args->{$k} = 1 }
    $util->_parse_atts;
};

lib/MooseX/ConfigCascade.pm  view on Meta::CPAN

497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
 
    with 'https://metacpan.org/pod/MooseX::ConfigCascade">MooseX::ConfigCascade';
 
When you do this, a single new attribute is added to your class:
 
=head2 cascade_util
 
This is a L<MooseX::ConfigCascade::Util> object, which has 3 utility methods. So once you added the L<MooseX::ConfigCascade> role to your package, you can do:
 
    my $object = My::Package->new;
 
    $object->cascade_util->conf;     # access the config hash directly
    $object->cascade_util->path;     # the path to the config file (if any)
    $object->cascade_util->parser;   # the code ref to the subroutine which parses your config file
 
Note C<conf>, C<path> and C<parser> are all B<class attributes> of L<MooseX::ConfigCascade::Util>. That means it is intended that you generally set them by calling the class directly:
 
    MooseX::ConfigCascade::Util->path( '/path/to/config.yaml' );
 
    # etc ...
 
so you may not ever need to use C<cascade_util> at all. However, you may find it useful that you can access the full config from anywhere in your project:
 
    $whatever_object->cascade_util->conf;
 
See the documentation for L<MooseX::ConfigCascade::Util> for information about these methods.
 
 
=head1 SEE ALSO

 view release on metacpan or  search on metacpan

lib/Multi/Dispatch.pm  view on Meta::CPAN

2707
2708
2709
2710
2711
2712
2713
2714
2715
2716
2717
    }
 
This code uses a single multisub with a signature, to ensure that it receives
the correct kind of argument. But then it unpacks the contents of that argument
"manually", and determines what action to take by explicitly deciphering the
structure of the argument in a cascaded S<C<if>-C<elsif>> sequence...all in that
single variant.
 
Avoiding that kind of all-in-one hand-coded infrastructure is the entire
reason for having multiple dispatch, so it won't come as much of a surprise
that Multi::Dispatch offers a much cleaner way of achieving the same goal:

lib/Multi/Dispatch.pm  view on Meta::CPAN

2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858
    }
 
While this is a arguably little cleaner than the array-based version,
and certainly a lot safer I<(are you B<sure> all the array indexes
were correct in the array-based version???)>, it still suffers from
the "all-in-one-cascade" problem.
 
Fortunately, Multi::Dispatch can also destructure hashref parameters,
allowing them to be specified as destructuring anonymous hashes:
 
    multi handle( { cmd=>'delete', ID=>$ID }                    ) {...}

 view release on metacpan or  search on metacpan

lib/MyCPAN/Indexer/Interface/Tk.pm  view on Meta::CPAN

254
255
256
257
258
259
260
261
262
263
{
my $menubar = shift;
my $title   = shift;
my $items   = shift;
 
my $menu = $menubar->cascade(
        -label     => $title,
        -menuitems => $items,
        -tearoff   => 0,
         );

 view release on metacpan or  search on metacpan

htdocs/src-min/mode-mysql.js  view on Meta::CPAN

1
define("ace/mode/doc_comment_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"],function(e,t,n){"use strict";var r=e("../lib/oop"),i=e("./text_highlight_rules").TextHighlightRules,s=function(){this.$rules={s...

 view release on metacpan or  search on metacpan

lib/MySQL/Workbench/Parser/MySQLParser.pm  view on Meta::CPAN

519
520
521
522
523
524
525
526
527
528
    |
    /on update/i reference_option
    { $item[2] }
 
reference_option: /restrict/i |
    /cascade/i   |
    /set null/i  |
    /no action/i |
    /set default/i
    { $item[1] }

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

18
19
20
21
22
23
24
25
26
27
0.003 Wed Aug 23 14:31:56 EST 2006
        . fix bug in handling US style dates (Don Collins)
        . allow use 'Mar 20006' (to select an arbitrary month) in constructor
        . add some tests of the named Month facility (t/st_et.t)
    . refactor the __DEFAULT__ handler of the %stime_etime despatch table to use
      ternary (what C calls 'conditional') statements instead of cascaded if-then-else
    . allow time selectors to have an optional argument of a datetime. This allows
      tests to be pre-genned with known dates rather than having to dynamically cope with
      whatever time the test is called at (see gen_tests, which generates t/st_et_2.t).
        . modify examples/host_down_report to accept named Months as time option.

 view release on metacpan or  search on metacpan

Roadmap.org  view on Meta::CPAN

32
33
34
35
36
37
38
39
40
 
 
 
* rename ?
 
  - 'cascade copy' was probably a bad idea
 
  - GRID-Copy ?
    - google finds 21,200 for "grid copy"

 view release on metacpan or  search on metacpan

lib/Net/IMP/Cascade.pm  view on Meta::CPAN

120
121
122
123
124
125
126
127
128
129
130
    $new_parts[$i] = $np; # got new factory for part
}
 
return $factory if ! @new_parts; # interface supported by original factory
 
# some parts changed, create new factory for this cascade
for(my $i=0;$i<@$parts;$i++) {
    $new_parts[$i] ||= $parts->[$i]; # copy parts which did not change
}
 
return ref($factory)->new_factory( parts => \@new_parts );

lib/Net/IMP/Cascade.pm  view on Meta::CPAN

156
157
158
159
160
161
162
163
164
165
166
167
        end     => 0,  # end of buf relativ to part
        data    => '', # data or undef for replace_later
        dtype   => 0,  # data type
        rtype   => IMP_PASS,  # IMP_PASS < IMP_PREPASS < IMP_REPLACE
        gap     => 0,  # size of gap before buf?
        gstart  => 0,  # start of buf relativ to cascade
        gend    => 0,  # end of buf relativ to cascade
        eof     => 0   # flag if last buf in this direction
    });
    %$buf = ( %$buf, @_ ) if @_;
    return $buf;
};

lib/Net/IMP/Cascade.pm  view on Meta::CPAN

444
445
446
447
448
449
450
451
452
453
454
    $buf->{end} = $buf->{start} + length($buf->{data});
    $DEBUG && debug(
        "fwd_next[$dir][$pi>$npi] ".$dump_bufs->([$buf]));
    $part_in->($npi,$dir,$buf);
} else {
    # output from cascade
    my $cb = $fwd_up->($dir,$buf) or next;
    $DEBUG && debug(
        "fwd_up[$dir][$pi>>] ".$dump_bufs->([$buf]));
    $wself->run_callback($cb);
}

lib/Net/IMP/Cascade.pm  view on Meta::CPAN

855
856
857
858
859
860
861
862
863
864
865
 
__END__
 
=head1 NAME
 
Net::IMP::Cascade - manages cascade of IMP filters
 
=head1 SYNOPSIS
 
    use Net::IMP::Cascade;
    use Net::IMP::Pattern;

lib/Net/IMP/Cascade.pm  view on Meta::CPAN

870
871
872
873
874
875
876
877
878
879
880
        Net::IMP::SessionLog->new_factory..,
    ]);
 
=head1 DESCRIPTION
 
C<Net::IMP::Cascade> puts multiple IMP analyzers into a cascade.
Data get analyzed starting with part#0, then part#1... etc for direction 0
(client to server), while for direction 1 (server to client) the data get
analyzed the opposite way, ending in part#0.
 
The only argument special to C<new_factory> is C<parts>, which is an array

 view release on metacpan or  search on metacpan

lib/Net/LCDproc/Screen.pm  view on Meta::CPAN

99
100
101
102
103
104
105
106
107
108
109
    $widget->screen($self);
    push @{$self->widgets}, $widget;
    return 1;
}
 
# removes screen from N::L, deletes from server, then cascades and kills its widgets (optionally not)
sub remove {
    my ($self, $keep_widgets) = @_;
 
    if (!defined $keep_widgets) {
        foreach my $widget (@{$self->widgets}) {

 view release on metacpan or  search on metacpan

extras/oui-20151113.txt  view on Meta::CPAN

56691
56692
56693
56694
56695
56696
56697
56698
56699
56700
56701
56702
0CD996     (base 16)            Cisco Systems, Inc
                                80 West Tasman Drive
                                San Jose  CA  94568
                                US
 
D8-2D-E1   (hex)                Tricascade Inc.
D82DE1     (base 16)            Tricascade Inc.
                                5020 Campus Drv.
                                Newport Beach  CA  92660
                                US
 
C4-38-D3   (hex)                TAGATEC CO.,LTD

 view release on metacpan or  search on metacpan

lib/Net/OAuth2/Scheme.pm  view on Meta::CPAN

37
38
39
40
41
42
43
44
45
46
47
    $factory_class = $Factory_Class;
}
eval "require $factory_class" or die $@;
my $factory = $factory_class->new(@_);
 
# start the cascade of methods being implemented
$factory->uses('root');
 
# build the object, make sure the method definitions are there
my $tag =
  pop @{$free_tags{$class} ||= []}

 view release on metacpan or  search on metacpan

lib/Net/OnlineCode/Bones.pm  view on Meta::CPAN

402
403
404
405
406
407
408
409
410
411
412
When matched, the propagation rule solves one extra node somewhere to
the left of the starting node. In the algebraic interpretation, I
talked about substituting a newly-solved variable into all other
equations where the variable appeared. There is an analogous procedure
in the graph-based implementation, which is implemenented in the
cascade() routine.
 
For the sake of discussion, let's assume that the message block M was
solved by the propagation rule and that it had the solution:
 
 M <- A xor C

lib/Net/OnlineCode/Bones.pm  view on Meta::CPAN

417
418
419
420
421
422
423
424
425
426
427
one rightward edge in the graph from that node for each equation the
left node appears in, this effectively reaches all equations that
could could become solvable.
 
In the case where the left node which has become solved is an
auxiliary block, the cascade() routine also queues up the auxiliary
node itself for checking the propagation rule.
 
=head2 Special handling for auxiliary nodes
 
Although in theory the propagation rule could be applied to unsolved

lib/Net/OnlineCode/Bones.pm  view on Meta::CPAN

443
444
445
446
447
448
449
450
451
452
453
    x       i          j
 
When the last unsolved message block on the right becomes solved then
this equation has no more unknowns apart from the aux block
itself. Therefore, it can be marked as solved (with the above
solution) and we can cascade up from that aux block to see if it
solves any more equations.
 
=head2 Optimising by tracking counts of unsolved left nodes
 
When aux or check nodes are created, the number of unknown/unsolved

 view release on metacpan or  search on metacpan

lib/Net/SSLeay.pod  view on Meta::CPAN

11114
11115
11116
11117
11118
11119
11120
11121
11122
11123
11124
 
=item msg 123: 1 - error:140770F8:SSL routines:SSL23_GET_SERVER_HELLO:unknown proto
 
SSLeay error string. The first number (123) is the PID, the second number
(1) indicates the position of the error message in SSLeay error stack.
You often see a pile of these messages as errors cascade.
 
=item msg 123: 1 - error:02001002::lib(2) :func(1) :reason(2)
 
The same as above, but you didn't call load_error_strings() so SSLeay
couldn't verbosely explain the error. You can still find out what it

 view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN

41
42
43
44
45
46
47
48
49
50
51
t/fam/sprites/accept.png
t/fam/sprites/add.png
t/fam/sprites/anchor.png
t/fam/sprites/application.png
t/fam/sprites/application_add.png
t/fam/sprites/application_cascade.png
t/fam/sprites/application_delete.png
t/fam/sprites/application_double.png
t/fam/sprites/application_edit.png
t/fam/sprites/application_error.png
t/fam/sprites/application_form.png

 view release on metacpan or  search on metacpan

t/data/out_I_A_thaliana.obo  view on Meta::CPAN

958
959
960
961
962
963
964
965
966
967
968
relationship: part_of APO:P0000104 ! meiosis I
 
[Term]
id: APO:P0000055
name: DNA damage response, signal transduction by p53 class mediator resulting in cell cycle arrest
def: "A cascade of processes induced by the cell cycle regulator phosphoprotein p53, or an equivalent protein, in response to the detection of DNA damage and resulting in the stopping or reduction in rate of the cell cycle." [GOC:go_curators]
xref: GO:0006977
is_a: APO:P0000158 ! G1 DNA damage checkpoint
 
[Term]
id: APO:P0000056

 view release on metacpan or  search on metacpan

lib/OOP/Perlish/Class.pm  view on Meta::CPAN

672
673
674
675
676
677
678
679
680
681
682
sub ____inherit_accessors(@)
{
    my ($self) = @_;
 
    ### Protect overloaded accessors by identifying those in our top-level namespace
    ### This cascaded up through the inheritance tree
    my %top_accessors = ();
    if( scalar( keys %{ $self->____OOP_PERLISH_CLASS_ACCESSORS() } ) ) {
        # XXX: Hash slice assignment
        @top_accessors{ keys %{ $self->____OOP_PERLISH_CLASS_ACCESSORS() } } =
          ( (1) x ( ( scalar keys %{ $self->____OOP_PERLISH_CLASS_ACCESSORS() } ) ) );

lib/OOP/Perlish/Class.pm  view on Meta::CPAN

746
747
748
749
750
751
752
753
754
755
756
757
while( my ( $name, $field ) = each %{ $self->____OOP_PERLISH_CLASS_ACCESSORS() } ) {
    $required_fields{$name} = $name if( $field->required() );
}
 
# FIXME: Does not cascade beyond @ISA, should traverse inheritance tree and ensure that all required fields are
# provided for any hiararchy. ... does cascade via new, but only to ancesters who conform with us. unsure how to fix
#for my $parent_class ( @{ $self->{____CLASS_ISA} } ) {
for my $parent_class ( $self->_all_isa() ) {
    if( bless( {}, $parent_class )->can('____OOP_PERLISH_CLASS_REQUIRED_FIELDS') ) {
        @required_fields{ @{ $parent_class->____OOP_PERLISH_CLASS_REQUIRED_FIELDS() } } =
          @{ $parent_class->____OOP_PERLISH_CLASS_REQUIRED_FIELDS() };

lib/OOP/Perlish/Class.pm  view on Meta::CPAN

793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
my %opts =
  map { ( $_ => $self->{____oop_perlish_class_opts}->{$_} ) }
  grep { !exists( $required_fields_lut{$_} ) } keys %{ $self->{____oop_perlish_class_opts} };
 
# prepopulate accessors so that calls that cascade will have values assigned
# Set everything by accessor that we ->can()
while( my ( $method, $value ) = each %opts ) {
    $self->$method($value) if( $self->can($method) );
}
 
$self->____validate_defaults();
 
# reset all accessors for actually set values, re-running cascades where applicable...
# there must be a better way, but this works
while( my ( $method, $value ) = each %opts ) {
    $self->$method($value) if( $self->can($method) );
}
return;

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

192
193
194
195
196
197
198
199
200
201
202
        - Allow ->load calls for multiple-columns primary keys
        - All connections now explicitly RaiseError => 1 for correctness
        - All connections now explicitly PrintError => 0 to avoid spewing
          stuff to STDOUT/STDERR unexpectedly in embedded scenarios.
        - Remove most explicit error handling and allow the native DBI
          errors to cascade upwards instead.
 
1.29_01   2009-09-28
        - Adding first experimental implementation of ->load
 
1.28      2009-09-25

 view release on metacpan or  search on metacpan

ObjectivePerl.pm  view on Meta::CPAN

350
351
352
353
354
355
356
357
358
359
360
invoke those methods using obj-c style messages.  However,
there are often times when you need to call older perl code that
does not list its arguments in its signature, or perhaps you wish
to invoke a method across the PerlObjCBridge in OSX.  To do
this transparently, the ObjectivePerl runtime uses a method lookup
cascade that works as follows:
 
    1. It tries to find the correctly-defined method
       for the invocation using ObjectivePerl syntax
    2. (NEW in 0.03 for CamelBones Compatibility) 
       It tries to find a method whose name corresponds

 view release on metacpan or  search on metacpan

xs/SceneNode.xs  view on Meta::CPAN

177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
 
SceneNode *
SceneNode::getParentSceneNode()
 
void
SceneNode::setVisible(bool enabled, bool cascade=true)
 
void
SceneNode::flipVisibility(bool cascade=true)
 
void
SceneNode::setDebugDisplayEnabled(bool enabled, bool cascade=true)
 
 
## static void  queueNeedUpdate (Node *n)
## static void  processQueuedUpdates (void)

 view release on metacpan or  search on metacpan

lib/OpenGL/Sandbox/VertexArray.pm  view on Meta::CPAN

249
250
251
252
253
254
255
256
257
258
259
 
=head2 bind
 
  $vertex_array->bind($program, $buffer);
 
Make the configuration of this vertex array active for drawing.  This might cause a cascade of
effects, like binding buffers, loading buffers, binding the vertex array object, looking up
program attributes, and enabling and configuring the attributes.  Steps which don't need
repeated won't be.
 
If C<$program> is not given, the current one will be used for any attribute-index lookups.

 view release on metacpan or  search on metacpan

OpenIndex.pm  view on Meta::CPAN

2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
            $new{options_del} = ($parent->{options_del} | $current->{options_del}) ;
            $new{options} = $parent->{options} & ~NO_OPTIONS;
        } else {                        # not all incremental, so no inheritance
            $new{options} = $current->{options};
        }
# Collect cascaded options
        $new{options} |= $new{options_add};
        $new{options} &= ~ $new{options_del};
    }
    $new{userdir}     = $current->{userdir}     || $parent->{userdir};
    $new{usersite}    = $current->{usersite}    || $parent->{usersite};

 view release on metacpan or  search on metacpan

lib/OpusVL/AppKit/Schema/AppKitAuthDB/Result/Aclfeature.pm  view on Meta::CPAN

27
28
29
30
31
32
33
34
35
36
37
 
__PACKAGE__->has_many(
  "aclfeature_roles",
  "OpusVL::AppKit::Schema::AppKitAuthDB::Result::AclfeatureRole",
  { "foreign.aclfeature_id" => "self.id" },
  { cascade_copy => 0, cascade_delete => 0 },
);
 
 
# Created by DBIx::Class::Schema::Loader v0.07010 @ 2011-03-14 12:26:54
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:kXm7NSea55lahdQ68Z/l9A

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
  Two new tables have been added to support this facility.  The need to be added to your
  appkit auth schema.
 
  CREATE TABLE roles_allowed 
  (
      role integer not null references role(id) on delete cascade, 
      role_allowed integer not null references role(id) on delete cascade, 
      primary key (role, role_allowed)
  );
  CREATE TABLE role_admin
  (
      role_id integer not null references role(id) on delete cascade, 
      primary key(role_id)
  );
 
 
0.18

 view release on metacpan or  search on metacpan

lib/OpusVL/Preferences/Schema/Result/PrfPreference.pm  view on Meta::CPAN

63
64
65
66
67
68
69
70
71
    { 
      "foreign.prf_owner_type_id"   => "self.prf_owner_type_id", 
      "foreign.name"                => "self.name", 
      "foreign.value_id"            => "self.prf_preference_id"
    },
  { is_foreign_key_constraint => 0, cascade_delete => 1 });
 
 
return 1;