« Core/Handler/CommandHandler/InvokeGlobalFunctionHandler.pm
↑ Summary
Core/Handler/CommandHandler/InvokeInstanceMethodHandler.pm »
| 1 | package Javonet::Sdk::Core::PerlCommand; | ||
| 2 | use strict; | ||
| 3 | use warnings; | ||
| 4 | use lib 'lib'; | ||
| 5 | use Moose; | ||
| 6 | use Scalar::Util; | ||
| 7 | |||
| 8 | use aliased 'Javonet::Sdk::Core::PerlCommandType' => 'PerlCommandType'; | ||
| 9 | |||
| 10 | has 'runtime' => ( | ||
| 11 | is => 'ro', | ||
| 12 | isa => 'Int', | ||
| 13 | required => 1, | ||
| 14 | reader => '_get_runtime' | ||
| 15 | ); | ||
| 16 | |||
| 17 | has 'command_type' => ( | ||
| 18 | is => 'ro', | ||
| 19 | isa => 'Int', | ||
| 20 | required => 1, | ||
| 21 | reader => '_get_command_type' | ||
| 22 | ); | ||
| 23 | |||
| 24 | has 'payload' => ( | ||
| 25 | is => 'ro', | ||
| 26 | isa => 'ArrayRef', | ||
| 27 | default => sub {[]}, | ||
| 28 | reader => '_get_payload' | ||
| 29 | ); | ||
| 30 | |||
| 31 | # Constructor with params object[] (list of objects) | ||
| 32 | sub new { | ||
| 33 | my ($class, %args) = @_; | ||
| 34 | my $runtime = $args{runtime}; | ||
| 35 | my $command_type = $args{command_type}; | ||
| 36 | my $payload = $args{payload}; | ||
| 37 | |||
| 38 | # If payload is not provided or is undef, use empty array | ||
| 39 | if (!defined $payload) { | ||
| 40 | $payload = []; | ||
| 41 | } | ||
| 42 | # If payload is already an array reference, use it directly | ||
| 43 | elsif (ref $payload eq 'ARRAY') { | ||
| 44 | # Reuse array reference directly - no conversion overhead | ||
| 45 | $payload = $payload; | ||
| 46 | } | ||
| 47 | # If payload is a list (not a reference), convert to array reference | ||
| 48 | else { | ||
| 49 | # This handles the case where payload might be passed as a list | ||
| 50 | # Convert to array reference | ||
| 51 | my @payload_array = ref $payload ? @$payload : ($payload); | ||
| 52 | $payload = \@payload_array; | ||
| 53 | } | ||
| 54 | |||
| 55 | my $self = { | ||
| 56 | runtime => $runtime, | ||
| 57 | command_type => $command_type, | ||
| 58 | payload => $payload | ||
| 59 | }; | ||
| 60 | |||
| 61 | bless $self, $class; | ||
| 62 | return $self; | ||
| 63 | } | ||
| 64 | |||
| 65 | # Static factory method: CreateResponse | ||
| 66 | sub CreateResponse { | ||
| 67 | my ($class, $response, $runtime_name) = @_; | ||
| 68 | return $class->new( | ||
| 69 | runtime => $runtime_name, | ||
| 70 | command_type => PerlCommandType->get_command_type('Value'), | ||
| 71 | payload => [$response] | ||
| 72 | ); | ||
| 73 | } | ||
| 74 | |||
| 75 | # Static factory method: CreateReference | ||
| 76 | sub CreateReference { | ||
| 77 | my ($class, $guid, $runtime_name) = @_; | ||
| 78 | return $class->new( | ||
| 79 | runtime => $runtime_name, | ||
| 80 | command_type => PerlCommandType->get_command_type('Reference'), | ||
| 81 | payload => [$guid] | ||
| 82 | ); | ||
| 83 | } | ||
| 84 | |||
| 85 | # Static factory method: CreateArrayResponse | ||
| 86 | sub CreateArrayResponse { | ||
| 87 | my ($class, $array, $runtime_name) = @_; | ||
| 88 | # Convert array to array reference if needed | ||
| 89 | my $payload = ref $array eq 'ARRAY' ? $array : [$array]; | ||
| 90 | return $class->new( | ||
| 91 | runtime => $runtime_name, | ||
| 92 | command_type => PerlCommandType->get_command_type('Array'), | ||
| 93 | payload => $payload | ||
| 94 | ); | ||
| 95 | } | ||
| 96 | |||
| 97 | # DropFirstPayloadArg - matches C# DropFirstPayloadArg | ||
| 98 | sub DropFirstPayloadArg { | ||
| 99 | my ($self) = @_; | ||
| 100 | my $class = ref($self) || $self; | ||
| 101 | my $current_payload_ref = $self->{payload}; | ||
| 102 | my @cur_payload = @$current_payload_ref; | ||
| 103 | my $payload_length = @cur_payload; | ||
| 104 | |||
| 105 | if ($payload_length <= 1) { | ||
| 106 | return $class->new( | ||
| 107 | runtime => $self->{runtime}, | ||
| 108 | command_type => $self->{command_type}, | ||
| 109 | payload => [] | ||
| 110 | ); | ||
| 111 | } | ||
| 112 | |||
| 113 | my $new_length = $payload_length - 1; | ||
| 114 | my @new_payload = @cur_payload[1 .. $#cur_payload]; | ||
| 115 | |||
| 116 | return $class->new( | ||
| 117 | runtime => $self->{runtime}, | ||
| 118 | command_type => $self->{command_type}, | ||
| 119 | payload => \@new_payload | ||
| 120 | ); | ||
| 121 | } | ||
| 122 | |||
| 123 | # AddArgToPayload - matches C# AddArgToPayload | ||
| 124 | sub AddArgToPayload { | ||
| 125 | my ($self, $arg) = @_; | ||
| 126 | my $class = ref($self) || $self; | ||
| 127 | my $current_payload_ref = $self->{payload}; | ||
| 128 | my @cur_payload = @$current_payload_ref; | ||
| 129 | my $old_length = @cur_payload; | ||
| 130 | my @new_payload = (@cur_payload, $arg); | ||
| 131 | |||
| 132 | return $class->new( | ||
| 133 | runtime => $self->{runtime}, | ||
| 134 | command_type => $self->{command_type}, | ||
| 135 | payload => \@new_payload | ||
| 136 | ); | ||
| 137 | } | ||
| 138 | |||
| 139 | # PrependArgToPayload - matches C# PrependArgToPayload | ||
| 140 | sub PrependArgToPayload { | ||
| 141 | my ($self, $arg_command) = @_; | ||
| 142 | |||
| 143 | if (!defined $arg_command) { | ||
| 144 | return $self; | ||
| 145 | } | ||
| 146 | |||
| 147 | my $class = ref($self) || $self; | ||
| 148 | my $current_payload_ref = $self->{payload}; | ||
| 149 | my @cur_payload = @$current_payload_ref; | ||
| 150 | my $old_length = @cur_payload; | ||
| 151 | my @new_payload = ($arg_command, @cur_payload); | ||
| 152 | |||
| 153 | return $class->new( | ||
| 154 | runtime => $self->{runtime}, | ||
| 155 | command_type => $self->{command_type}, | ||
| 156 | payload => \@new_payload | ||
| 157 | ); | ||
| 158 | } | ||
| 159 | |||
| 160 | # Legacy method name for backward compatibility | ||
| 161 | sub addArgumentToPayload { | ||
| 162 | my ($self, $payload_ref) = @_; | ||
| 163 | my @payload_array = ref $payload_ref eq 'ARRAY' ? @$payload_ref : ($payload_ref); | ||
| 164 | return $self->AddArgToPayload($payload_array[0]) if @payload_array == 1; | ||
| 165 | # For multiple items, add them one by one | ||
| 166 | my $result = $self; | ||
| 167 | for my $item (@payload_array) { | ||
| 168 | $result = $result->AddArgToPayload($item); | ||
| 169 | } | ||
| 170 | return $result; | ||
| 171 | } | ||
| 172 | |||
| 173 | # Legacy method name for backward compatibility | ||
| 174 | sub drop_first_payload_argument { | ||
| 175 | return $_[0]->DropFirstPayloadArg(); | ||
| 176 | } | ||
| 177 | |||
| 178 | # Legacy method name for backward compatibility | ||
| 179 | sub prepend_arg_to_payload { | ||
| 180 | return $_[0]->PrependArgToPayload($_[1]); | ||
| 181 | } | ||
| 182 | |||
| 183 | # ToString method - matches C# ToString | ||
| 184 | sub ToString { | ||
| 185 | my ($self) = @_; | ||
| 186 | eval { | ||
| 187 | my $result = "RuntimeName " . $self->{runtime} . " "; | ||
| 188 | $result .= "CommandType " . $self->{command_type} . " "; | ||
| 189 | $result .= "Payload "; | ||
| 190 | |||
| 191 | my $payload_ref = $self->{payload}; | ||
| 192 | my @payload = @$payload_ref; | ||
| 193 | my $len = @payload; | ||
| 194 | |||
| 195 | for (my $i = 0; $i < $len; $i++) { | ||
| 196 | my $item = $payload[$i]; | ||
| 197 | $result .= defined $item ? $item : "null"; | ||
| 198 | |||
| 199 | if ($i < $len - 1) { | ||
| 200 | $result .= " "; | ||
| 201 | } | ||
| 202 | } | ||
| 203 | |||
| 204 | return $result; | ||
| 205 | }; | ||
| 206 | if ($@) { | ||
| 207 | return "Error while converting command to string: " . $@; | ||
| 208 | } | ||
| 209 | } | ||
| 210 | |||
| 211 | no Moose; | ||
| 212 | |||
| 213 | 1; |