view release on metacpan or  search on metacpan

lib/AtteanX/Functions/CompositeLists.pm  view on Meta::CPAN

					my $rewritten	= AtteanX::Functions::CompositeLists::rewrite_lexical($literal, $bnode_map, $parse_id);
					my ($t)	= $rewritten->sparql_tokens->elements;
					my $i	= Attean::ListIterator->new( values => [$t], item_type => 'AtteanX::SPARQL::Token' );
					my $str	= decode_utf8($s->serialize_iter_to_bytes($i));
					chomp($str);
					push(@rewritten, $str);
					$j++;
					next;
				}
				push(@rewritten, blessed($t) ? $t->token_as_string() : "null");
				$j++;
			}
			my $rewritten	= join('', @rewritten);
			Attean::Literal->new(value => $rewritten, datatype => $term->datatype);
		};
		warn $@ if ($@);
		return $r || $term;
	}

=item C<< register() >>

=cut
	sub register {
		Attean->register_datatype_role(
			"${CDT_BASE}List"	=> 'AtteanX::Functions::CompositeLists::ListLiteral'
		);
		
		Attean->register_global_functional_form(
			"${CDT_BASE}List" => \&listCreate,
			"${CDT_BASE}listCreate" => \&listCreate,
		);
		Attean->register_global_function(
			"${CDT_BASE}get" => \&ctGet,
			"${CDT_BASE}listGet" => \&listGet,
			"${CDT_BASE}subseq" => \&listSubseq,
			"${CDT_BASE}size" => \&ctSize,
			"${CDT_BASE}listSize" => \&listSize,
			"${CDT_BASE}reverse" => \&listReverse,
			"${CDT_BASE}head" => \&listHead,
			"${CDT_BASE}tail" => \&listTail,
			"${CDT_BASE}contains" => \&listContains,
			"${CDT_BASE}concat" => \&listConcat,
			"${CDT_BASE}containsTerm" => \&listContainsTerm,
			"${CDT_BASE}sequence" => \&sequence,
			"${CDT_BASE}zip" => \&zip,
			"${CDT_BASE}split" => \&stringSplit,
			"${CDT_BASE}list_from_head" => \&list_from_head,
		);

		Attean->register_global_aggregate(
			"${CDT_BASE}listAgg" => {
				start		=> \&listCreate_agg_start,
				process		=> \&listCreate_agg_process,
				finalize	=> \&listCreate_agg_finalize,
			},
		);
	}
}

package AtteanX::Functions::CompositeLists::ListLiteral {
	use Scalar::Util qw(blessed looks_like_number);

	use Moo::Role;
	use List::Util qw(min);

	sub equals {
		my $lhs	= shift;
		my $rhs	= shift;
# 		warn "LIST EQUALS?";
# 		warn "- " . $lhs->as_string . "\n";
# 		warn "- " . $rhs->as_string . "\n";
		return 0 unless ($rhs->does('Attean::API::Literal') and $rhs->datatype->value eq $AtteanX::Functions::CompositeLists::LIST_TYPE_IRI);
		my $lhs_size	= eval { AtteanX::Functions::CompositeLists::listSize(undef, undef, $lhs)->value };
		return 0 if ($@);
 		my $rhs_size	= eval { AtteanX::Functions::CompositeLists::listSize(undef, undef, $rhs)->value };
		return 0 if ($@);
		return 0 unless ($lhs_size == $rhs_size);
		
		my $seen_error	= 0;
		foreach my $i (0 .. $lhs_size-1) {
			my $li	= AtteanX::Functions::CompositeLists::listGet(undef, undef, $lhs, Attean::Literal->integer($i+1));
			my $ri	= AtteanX::Functions::CompositeLists::listGet(undef, undef, $rhs, Attean::Literal->integer($i+1));
			if (not blessed($li) and not blessed($ri)) {
				# both null
				next;
			} elsif (not blessed($li) or not blessed($ri)) {
				return 0;
			}

			if ($li->does('Attean::API::Blank') and $ri->does('Attean::API::Blank')) {
				if ($li->value eq $ri->value) {
					next;
				} else {
					$seen_error++;
					next;
				}
			}
			return 0 unless ($li->equals($ri));
		}
		if ($seen_error) {
			die 'TypeError: Cannot compare cdt:List values with blank nodes';
		}
		return 1;
	}
	
	sub order {
		my $self	= shift;
		return _compare('order', $self, @_);
	}
	
	sub compare {
		my $self	= shift;
		return _compare('compare', $self, @_);
	}
	
	sub _compare {
		my $cmp_method	= shift;
		my $lhs	= shift;
		my $rhs	= shift;
# 		warn "LIST-LESS-THAN?";
# 		warn "- " . $lhs->as_string . "\n";