File Coverage

blib/lib/CXC/Types/Astro/Coords.pm

Criterion	Covered	Total	%
statement	48	48	100.0
branch	1	2	50.0
condition			n/a
subroutine	15	15	100.0
pod	1	1	100.0
total	65	66	98.4

package CXC::Types::Astro::Coords;

# ABSTRACT: type definitions for Coordinates

use v5.28;    # for POSIX::copysign

use strict;
use warnings;

use experimental 'signatures', 'postderef', 'declared_refs';

our $VERSION = '0.12';

use CXC::Types::Astro::Coords::Util 'mkSexagesimal';

use Type::Library
  -base,
  -declare => qw(
  Degrees

  LatitudeArray
  LatitudeDegrees
  LatitudeSexagesimal

  LongitudeArray
  LongitudeDegrees
  LongitudeSexagesimal

  RightAscensionArray
  RightAscensionDegrees
  RightAscensionSexagesimal

  DeclinationArray
  DeclinationDegrees
  DeclinationSexagesimal

  SexagesimalArray
  SexagesimalDegrees
  SexagesimalHMS
  SexagesimalDMS
  );

use Types::Standard        qw( Any Int Num StrMatch Tuple );
use Types::Common::Numeric qw( IntRange NumRange );
use Types::Common::String  qw( NonEmptyStr );
use Regexp::Common;
use Type::Utils -all;
use POSIX qw( fmod copysign );

my sub croak {
    require Carp;
    goto \&Carp::croak;
}














BEGIN {
    my @parameters = qw[ -any -optws -optsep -optunits -trim ];
    my %default    = mkSexagesimal( @parameters )->%*;

    sub methods ( %attr ) {
        return {
            ## no critic (BuiltinFunctions::ProhibitComplexMappings)
            map {
                my $value = $attr{$_};
                $_ => sub { $value },
              }
              keys %attr,
        };
    }

    __PACKAGE__->meta->add_type(
        name                 => 'Sexagesimal',
        constraint_generator => sub ( @args ) {
            croak( 'Sexagesimal requires parameters' )
              unless @args;
            my %parameterized = mkSexagesimal( @args )->%*;
            return Type::Tiny->new(
                display_name => 'Sexagesimal[' . join( q{,}, sort @args ) . ']',
                constraint   => $parameterized{constraint},
                parameters   => [@args],
                parent => Any,   # required to avoid an oops; see https://github.com/tobyink/p5-type-tiny/issues/151
                my_methods => methods( %parameterized ),
            );
        },
        constraint => $default{constraint},
        my_methods => methods( %default ),
    );
}













declare SexagesimalArray, as Tuple [ Int, IntRange [ 0, 59 ], NumRange [ 0, 60, 0, 1 ] ];









declare SexagesimalDegrees, as Num;

coerce SexagesimalArray,   from NonEmptyStr,      Sexagesimal->my_Str_toArrayRef;
coerce SexagesimalDegrees, from NonEmptyStr,      Sexagesimal->my_Str_toDegrees;
coerce SexagesimalDegrees, from SexagesimalArray, Sexagesimal->my_ArrayRef_toDegrees;







declare Degrees, as NumRange [ 0, 360, 0, 1 ];
coerce Degrees, from Num, q{  POSIX::fmod( 360 + POSIX::fmod( $_, 360 ), 360 ) };













declare LongitudeArray,
  as Tuple [ IntRange [ 0, 359 ], IntRange [ 0, 59 ], NumRange [ 0, 60, 0, 1 ] ];










declare LongitudeDegrees, as NumRange [ 0, 360, 0, 1 ];































declare LongitudeSexagesimal, as Sexagesimal [ -long, -trim, -optws, -optunits, -optsep ];

coerce LongitudeArray,   from NonEmptyStr,    LongitudeSexagesimal->my_Str_toArrayRef;
coerce LongitudeDegrees, from NonEmptyStr,    LongitudeSexagesimal->my_Str_toDegrees;
coerce LongitudeDegrees, from LongitudeArray, LongitudeSexagesimal->my_ArrayRef_toDegrees;



















declare LatitudeArray,
  as Tuple [ IntRange [ -90, 90 ], IntRange [ 0, 59 ], NumRange [ 0, 60, 0, 1 ] ], where sub {
    abs( $_->[0] ) + $_->[1] / 60 + $_->[2] / 3600 <= 90;
  }, inline_as {
    my $V = $_[1];
    return ( undef, qq{abs( $V\->[0] ) + $V\->[1] / 60 + $V\->[2] / 3600 <= 90} );
  };










declare LatitudeDegrees, as NumRange [ -90, 90 ];


































declare LatitudeSexagesimal, as Sexagesimal [ -lat, -trim, -optws, -optunits, -optsep ];
coerce LatitudeArray,   from NonEmptyStr,   LatitudeSexagesimal->my_Str_toArrayRef;
coerce LatitudeDegrees, from NonEmptyStr,   LatitudeSexagesimal->my_Str_toDegrees;
coerce LatitudeDegrees, from LatitudeArray, LatitudeSexagesimal->my_ArrayRef_toDegrees;













declare RightAscensionArray,
  as Tuple [ IntRange [ 0, 23 ], IntRange [ 0, 59 ], NumRange [ 0, 60, 0, 1 ] ];










declare RightAscensionDegrees, as NumRange [ 0, 360 ];






























declare RightAscensionSexagesimal, as Sexagesimal [ -ra, -trim, -optws, -optunits, -optsep ];
coerce RightAscensionArray,   from NonEmptyStr, RightAscensionSexagesimal->my_Str_toArrayRef;
coerce RightAscensionDegrees, from NonEmptyStr, RightAscensionSexagesimal->my_Str_toDegrees;
coerce RightAscensionDegrees, from RightAscensionArray,
  RightAscensionSexagesimal->my_ArrayRef_toDegrees;

















declare DeclinationArray, as LatitudeArray, coercion => 1;









declare DeclinationDegrees, as LatitudeDegrees, coercion => 1;


































declare DeclinationSexagesimal, as LatitudeSexagesimal, coercible => 1;

coerce DeclinationArray,   from NonEmptyStr,      DeclinationSexagesimal->my_Str_toArrayRef;
coerce DeclinationDegrees, from NonEmptyStr,      DeclinationSexagesimal->my_Str_toDegrees;
coerce DeclinationDegrees, from DeclinationArray, DeclinationSexagesimal->my_ArrayRef_toDegrees;















declare SexagesimalHMS, as Sexagesimal [ -ra, -trim, -optws, -units ];
















declare SexagesimalDMS, as Sexagesimal [ -deg, -trim, -optws, -units ];

1;

#
# This file is part of CXC-Types-Astro-Coords
#
# This software is Copyright (c) 2018 by Smithsonian Astrophysical Observatory.
#
# This is free software, licensed under:
#
#   The GNU General Public License, Version 3, June 2007
#

__END__