class Puppet::Pops::Types::PIntegerType

adjacent?(o) click to toggle source

Checks if this range is adjacent to the given range

@param o [PIntegerType] the range to compare with @return [Boolean] `true` if this range is adjacent to the other range @api public

     # File lib/puppet/pops/types/types.rb
1035 def adjacent?(o)
1036   o.is_a?(PIntegerType) &&  (@to + 1 == o.from || o.to + 1 == @from)
1037 end

assert_radix(radix) click to toggle source

     # File lib/puppet/pops/types/types.rb
1178 def assert_radix(radix)
1179   case radix
1180   when 2, 8, 10, 16
1181   else
1182     raise ArgumentError.new(_("Illegal radix: %{radix}, expected 2, 8, 10, 16, or default") % { radix: radix })
1183   end
1184   radix
1185 end

each(&block) click to toggle source

Returns Enumerator if no block is given Returns nil if size is infinity (does not yield)

     # File lib/puppet/pops/types/types.rb
1078 def each(&block)
1079   r = Iterable.on(self)
1080   block_given? ? r.each(&block) : r
1081 end

finite_range?() click to toggle source

Will respond `true` for any range that is bounded at both ends.

@return [Boolean] `true` if the type describes a finite range.

     # File lib/puppet/pops/types/types.rb
1018 def finite_range?
1019   @from != -Float::INFINITY && @to != Float::INFINITY
1020 end

from_args(from, radix = :default, abs = false) click to toggle source

     # File lib/puppet/pops/types/types.rb
1118 def from_args(from, radix = :default, abs = false)
1119   result = from_convertible(from, radix)
1120   abs ? result.abs : result
1121 end

from_convertible(from, radix) click to toggle source

     # File lib/puppet/pops/types/types.rb
1127 def from_convertible(from, radix)
1128   case from
1129   when Float, Time::TimeData
1130     from.to_i
1131   when Integer
1132     from
1133   when TrueClass
1134     1
1135   when FalseClass
1136     0
1137   else
1138     begin
1139       radix == :default ? Integer(from) : Integer(from, radix)
1140     rescue TypeError => e
1141       raise TypeConversionError.new(e.message)
1142     rescue ArgumentError => e
1143       # Test for special case where there is whitespace between sign and number
1144       match = Patterns::WS_BETWEEN_SIGN_AND_NUMBER.match(from)
1145       if match
1146         begin
1147           # Try again, this time with whitespace removed
1148           return from_args(match[1] + match[2], radix)
1149         rescue TypeConversionError
1150           # Ignored to retain original error
1151         end
1152       end
1153       raise TypeConversionError.new(e.message)
1154     end
1155   end
1156 end

from_hash(args_hash) click to toggle source

     # File lib/puppet/pops/types/types.rb
1123 def from_hash(args_hash)
1124   from_args(args_hash['from'], args_hash['radix'] || :default, args_hash['abs'] || false)
1125 end

generalize() click to toggle source

     # File lib/puppet/pops/types/types.rb
1022 def generalize
1023   DEFAULT
1024 end

instance?(o, guard = nil) click to toggle source

     # File lib/puppet/pops/types/types.rb
1026 def instance?(o, guard = nil)
1027   o.is_a?(Integer) && o >= numeric_from && o <= numeric_to
1028 end

iterable?(guard = nil) click to toggle source

     # File lib/puppet/pops/types/types.rb
1055 def iterable?(guard = nil)
1056   true
1057 end

iterable_type(guard = nil) click to toggle source

     # File lib/puppet/pops/types/types.rb
1059 def iterable_type(guard = nil)
1060   # It's unknown if the iterable will be a range (min, max) or a "times" (0, max)
1061   PIterableType.new(PIntegerType::DEFAULT)
1062 end

merge(o) click to toggle source

Concatenates this range with another range provided that the ranges intersect or are adjacent. When that's not the case, this method will return `nil`

@param o [PIntegerType] the range to concatenate with this range @return [PIntegerType,nil] the concatenated range or `nil` when the ranges were apart @api public

     # File lib/puppet/pops/types/types.rb
1045 def merge(o)
1046   if intersect?(o) || adjacent?(o)
1047     min = @from <= o.numeric_from ? @from : o.numeric_from
1048     max = @to >= o.numeric_to ? @to : o.numeric_to
1049     PIntegerType.new(min, max)
1050   else
1051     nil
1052   end
1053 end

new_function() click to toggle source

     # File lib/puppet/pops/types/types.rb
1090 def new_function
1091   @@new_function ||= Puppet::Functions.create_loaded_function(:new, loader) do
1092     local_types do
1093       type 'Radix       = Variant[Default, Integer[2,2], Integer[8,8], Integer[10,10], Integer[16,16]]'
1094       type "Convertible = Variant[Numeric, Boolean, Pattern[/#{INTEGER_PATTERN_LENIENT}/], Timespan, Timestamp]"
1095       type 'NamedArgs   = Struct[{from => Convertible, Optional[radix] => Radix, Optional[abs] => Boolean}]'
1096     end
1097 
1098     dispatch :from_args do
1099       param          'Convertible',  :from
1100       optional_param 'Radix',   :radix
1101       optional_param 'Boolean', :abs
1102     end
1103 
1104     dispatch :from_hash do
1105       param          'NamedArgs',  :hash_args
1106     end
1107 
1108     argument_mismatch :on_error_hash do
1109       param          'Hash',  :hash_args
1110     end
1111 
1112     argument_mismatch :on_error do
1113       param          'Any',     :from
1114       optional_param 'Integer', :radix
1115       optional_param 'Boolean', :abs
1116     end
1117 
1118     def from_args(from, radix = :default, abs = false)
1119       result = from_convertible(from, radix)
1120       abs ? result.abs : result
1121     end
1122 
1123     def from_hash(args_hash)
1124       from_args(args_hash['from'], args_hash['radix'] || :default, args_hash['abs'] || false)
1125     end
1126 
1127     def from_convertible(from, radix)
1128       case from
1129       when Float, Time::TimeData
1130         from.to_i
1131       when Integer
1132         from
1133       when TrueClass
1134         1
1135       when FalseClass
1136         0
1137       else
1138         begin
1139           radix == :default ? Integer(from) : Integer(from, radix)
1140         rescue TypeError => e
1141           raise TypeConversionError.new(e.message)
1142         rescue ArgumentError => e
1143           # Test for special case where there is whitespace between sign and number
1144           match = Patterns::WS_BETWEEN_SIGN_AND_NUMBER.match(from)
1145           if match
1146             begin
1147               # Try again, this time with whitespace removed
1148               return from_args(match[1] + match[2], radix)
1149             rescue TypeConversionError
1150               # Ignored to retain original error
1151             end
1152           end
1153           raise TypeConversionError.new(e.message)
1154         end
1155       end
1156     end
1157 
1158     def on_error_hash(args_hash)
1159       if args_hash.include?('from')
1160         from = args_hash['from']
1161         return on_error(from) unless loader.load(:type, 'convertible').instance?(from)
1162       end
1163       radix = args_hash['radix']
1164       assert_radix(radix) unless radix.nil? || radix == :default
1165       TypeAsserter.assert_instance_of('Integer.new', loader.load(:type, 'namedargs'), args_hash)
1166     end
1167 
1168     def on_error(from, radix = :default, abs = nil)
1169       assert_radix(radix) unless radix == :default
1170       if from.is_a?(String)
1171         _("The string '%{str}' cannot be converted to Integer") % { str: from }
1172       else
1173         t = TypeCalculator.singleton.infer(from).generalize
1174         _("Value of type %{type} cannot be converted to Integer") % { type: t }
1175       end
1176     end
1177 
1178     def assert_radix(radix)
1179       case radix
1180       when 2, 8, 10, 16
1181       else
1182         raise ArgumentError.new(_("Illegal radix: %{radix}, expected 2, 8, 10, 16, or default") % { radix: radix })
1183       end
1184       radix
1185     end
1186 
1187   end
1188 end

on_error(from, radix = :default, abs = nil) click to toggle source

     # File lib/puppet/pops/types/types.rb
1168 def on_error(from, radix = :default, abs = nil)
1169   assert_radix(radix) unless radix == :default
1170   if from.is_a?(String)
1171     _("The string '%{str}' cannot be converted to Integer") % { str: from }
1172   else
1173     t = TypeCalculator.singleton.infer(from).generalize
1174     _("Value of type %{type} cannot be converted to Integer") % { type: t }
1175   end
1176 end

on_error_hash(args_hash) click to toggle source

     # File lib/puppet/pops/types/types.rb
1158 def on_error_hash(args_hash)
1159   if args_hash.include?('from')
1160     from = args_hash['from']
1161     return on_error(from) unless loader.load(:type, 'convertible').instance?(from)
1162   end
1163   radix = args_hash['radix']
1164   assert_radix(radix) unless radix.nil? || radix == :default
1165   TypeAsserter.assert_instance_of('Integer.new', loader.load(:type, 'namedargs'), args_hash)
1166 end

range() click to toggle source

Returns the range as an array ordered so the smaller number is always first. The number may be Infinity or -Infinity.

     # File lib/puppet/pops/types/types.rb
1072 def range
1073   [@from, @to]
1074 end

size() click to toggle source

Returns Float.Infinity if one end of the range is unbound

     # File lib/puppet/pops/types/types.rb
1065 def size
1066   return Float::INFINITY if @from == -Float::INFINITY || @to == Float::INFINITY
1067   1+(to-from).abs
1068 end

to_size() click to toggle source

Returns a range where both to and from are positive numbers. Negative numbers are converted to zero @return [PIntegerType] a positive range

     # File lib/puppet/pops/types/types.rb
1086 def to_size
1087   @from >= 0 ? self : PIntegerType.new(0, @to < 0 ? 0 : @to)
1088 end

Constants

Public Class Methods

Public Instance Methods