/[eiffelstudio]/FreeELKS/trunk/library/kernel/string_8.e
ViewVC logotype

Diff of /FreeELKS/trunk/library/kernel/string_8.e

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

FreeELKS/trunk/library/kernel/string.e revision 91475 by ericb, Fri Mar 3 10:19:32 2006 UTC FreeELKS/trunk/library/kernel/string_8.e revision 91477 by ericb, Sun Jan 14 09:47:13 2007 UTC
# Line 1  Line 1 
1  indexing  indexing
2          description: "[          description: "[
3                  Sequences of characters, accessible through integer indices                  Sequences of characters, accessible through integer indices
4                  in a contiguous range.                  in a contiguous range.
5                  ]"                  ]"
6          library: "Free implementation of ELKS library"          library: "Free implementation of ELKS library"
# Line 10  indexing Line 10  indexing
10          revision: "$Revision$"          revision: "$Revision$"
11    
12  class  class
13          STRING          STRING_8
14    
15  inherit  inherit
16            STRING_GENERAL
17                    rename
18                            append as append_string_general
19                    redefine
20                            copy, is_equal, out, append_string_general
21                    end
22    
23          INDEXABLE [CHARACTER, INTEGER]          INDEXABLE [CHARACTER, INTEGER]
24                  rename                  rename
25                          item as item                          item as item
# Line 27  inherit Line 34  inherit
34                          changeable_comparison_criterion                          changeable_comparison_criterion
35                  end                  end
36    
         HASHABLE  
                 redefine  
                         copy, is_equal, out  
                 end  
   
         COMPARABLE  
                 redefine  
                         copy, is_equal, out  
                 end  
   
37          TO_SPECIAL [CHARACTER]          TO_SPECIAL [CHARACTER]
38                  rename                  rename
39                          item as item                          item as item
# Line 45  inherit Line 42  inherit
42                          item, infix "@", put, valid_index                          item, infix "@", put, valid_index
43                  end                  end
44    
         STRING_HANDLER  
                 redefine  
                         copy, is_equal, out  
                 end  
   
45          MISMATCH_CORRECTOR          MISMATCH_CORRECTOR
46                  redefine                  redefine
47                          copy, is_equal, out, correct_mismatch                          copy, is_equal, out, correct_mismatch
# Line 65  create Line 57  create
57    
58  convert  convert
59          to_cil: {SYSTEM_STRING},          to_cil: {SYSTEM_STRING},
60            as_string_32: {STRING_32},
61          make_from_cil ({SYSTEM_STRING})          make_from_cil ({SYSTEM_STRING})
62    
63  feature -- Initialization  feature -- Initialization
# Line 153  feature -- Initialization Line 146  feature -- Initialization
146                                  make_area (l_count + 1)                                  make_area (l_count + 1)
147                                  count := l_count                                  count := l_count
148                                  internal_hash_code := 0                                  internal_hash_code := 0
149                                  a_system_string.copy_to (0, area.native_array, 0, l_count)                                  dotnet_convertor.read_system_string_into (a_system_string, Current)
150                          else                          else
151                                  make (0)                                  make (0)
152                          end                          end
# Line 237  feature -- Access Line 230  feature -- Access
230                          Result := area.item (i - 1)                          Result := area.item (i - 1)
231                  end                  end
232    
233    
234            code (i: INTEGER): NATURAL_32 is
235                            -- Numeric code of character at position `i'
236                    do
237                            Result := area.item (i - 1).code.to_natural_32
238                    end
239    
240          item_code (i: INTEGER): INTEGER is          item_code (i: INTEGER): INTEGER is
241                          -- Numeric code of character at position `i'                          -- Numeric code of character at position `i'
242                  require                  require
# Line 361  feature -- Access Line 361  feature -- Access
361                          --      not substring (x, x+other.count -1).is_equal (other)                          --      not substring (x, x+other.count -1).is_equal (other)
362                  end                  end
363    
364          string: STRING is          string: STRING_8 is
365                          -- New STRING having same character sequence as `Current'.                          -- New STRING having same character sequence as `Current'.
366                  do                  do
367                          create Result.make (count)                          create Result.make (count)
368                          Result.append (Current)                          Result.append (Current)
369                  ensure                  ensure
370                          string_not_void: Result /= Void                          string_not_void: Result /= Void
371                          string_type: Result.same_type ("")                          string_type: Result.same_type (create {STRING_8}.make_empty)
372                            first_item: count > 0 implies Result.item (1) = item (1)
373                            recurse: count > 1 implies Result.substring (2, count).is_equal (
374                                    substring (2, count).string)
375                    end
376    
377            string_representation: STRING_8 is
378                            -- Similar to `string' but only create a new object if `Current' is not of dynamic type {STRING_8}
379                    do
380                            if same_type (create {STRING_8}.make_empty) then
381                                    Result := Current
382                            else
383                                    Result := string
384                            end
385                    ensure
386                            Result_not_void: Result /= Void
387                            correct_type: Result.same_type (create {STRING_8}.make_empty)
388                          first_item: count > 0 implies Result.item (1) = item (1)                          first_item: count > 0 implies Result.item (1) = item (1)
389                          recurse: count > 1 implies Result.substring (2, count).is_equal (                          recurse: count > 1 implies Result.substring (2, count).is_equal (
390                                  substring (2, count).string)                                  substring (2, count).string)
# Line 576  feature -- Comparison Line 592  feature -- Comparison
592    
593  feature -- Status report  feature -- Status report
594    
595            is_string_8: BOOLEAN is True
596                            -- Current is not a STRING_8 instance
597    
598            is_string_32: BOOLEAN is False
599                            -- Current is a STRING_32 instance
600    
601            is_valid_as_string_8: BOOLEAN is True
602                            -- Is `Current' convertible to STRING_8 without information loss?
603    
604          has (c: CHARACTER): BOOLEAN is          has (c: CHARACTER): BOOLEAN is
605                          -- Does string include `c'?                          -- Does string include `c'?
606                  local                  local
# Line 634  feature -- Status report Line 659  feature -- Status report
659                          Result := (i > 0) and (i <= count)                          Result := (i > 0) and (i <= count)
660                  end                  end
661    
662            valid_code (v: NATURAL_32): BOOLEAN is
663                            -- Is `v' a valid code for a CHARACTER_32?
664                    do
665                            Result := v <= {CHARACTER}.max_value.to_natural_32
666                    end
667    
668          changeable_comparison_criterion: BOOLEAN is False          changeable_comparison_criterion: BOOLEAN is False
669    
670          is_number_sequence: BOOLEAN is          is_number_sequence: BOOLEAN is
# Line 1209  feature -- Element change Line 1240  feature -- Element change
1240                          stable_after_i: elks_checking implies substring (i + 1, count).is_equal (old substring (i + 1, count))                          stable_after_i: elks_checking implies substring (i + 1, count).is_equal (old substring (i + 1, count))
1241                  end                  end
1242    
1243            put_code (v: NATURAL_32; i: INTEGER) is
1244                            -- Replace character at position `i' by character of code `v'.
1245                    do
1246                            area.put (v.to_character_8, i - 1)
1247                            internal_hash_code := 0
1248                    end
1249    
1250          precede, prepend_character (c: CHARACTER) is          precede, prepend_character (c: CHARACTER) is
1251                          -- Add `c' at front.                          -- Add `c' at front.
1252                  local                  local
# Line 1269  feature -- Element change Line 1307  feature -- Element change
1307                          end                          end
1308                  end                  end
1309    
1310            append_string_general (s: STRING_GENERAL) is
1311                            -- Append a copy of `s' at end.
1312                    local
1313                            l_s8: STRING
1314                    do
1315                            if same_type (s) then
1316                                    l_s8 ?= s
1317                                    append (l_s8)
1318                            else
1319                                    Precursor {STRING_GENERAL} (s)
1320                            end
1321                    end
1322    
1323          append (s: STRING) is          append (s: STRING) is
1324                          -- Append a copy of `s' at end.                          -- Append a copy of `s' at end.
1325                  require                  require
# Line 1336  feature -- Element change Line 1387  feature -- Element change
1387                                          if i < 0 then                                          if i < 0 then
1388                                                  append_character ('-')                                                  append_character ('-')
1389                                                  l_starting_index := l_starting_index + 1                                                  l_starting_index := l_starting_index + 1
                                                 l_value := -i  
1390                                                          -- Special case for minimum integer value as negating it                                                          -- Special case for minimum integer value as negating it
1391                                                          -- as no effect.                                                          -- as no effect.
1392                                                  if l_value = {INTEGER_REF}.Min_value then                                                  if i = {INTEGER}.Min_value then
1393                                                          append_character ((-(l_value \\ 10) + 48).to_character)                                                          append_character ('8')
1394                                                          l_value := -(l_value // 10)                                                          l_value := -(i // 10)
1395                                                    else
1396                                                            l_value := -i
1397                                                  end                                                  end
1398                                          else                                          else
1399                                                  l_value := i                                                  l_value := i
# Line 1349  feature -- Element change Line 1401  feature -- Element change
1401                                  until                                  until
1402                                          l_value = 0                                          l_value = 0
1403                                  loop                                  loop
1404                                          append_character (((l_value \\ 10)+ 48).to_character)                                          append_character (((l_value \\ 10)+ 48).to_character_8)
1405                                          l_value := l_value // 10                                          l_value := l_value // 10
1406                                  end                                  end
1407    
# Line 1386  feature -- Element change Line 1438  feature -- Element change
1438                                          if i < 0 then                                          if i < 0 then
1439                                                  append_character ('-')                                                  append_character ('-')
1440                                                  l_starting_index := l_starting_index + 1                                                  l_starting_index := l_starting_index + 1
                                                 l_value := -i  
1441                                                          -- Special case for minimum integer value as negating it                                                          -- Special case for minimum integer value as negating it
1442                                                          -- as no effect.                                                          -- as no effect.
1443                                                  if l_value = feature {INTEGER_8_REF}.Min_value then                                                  if i = {INTEGER_8}.Min_value then
1444                                                          append_character ((-(l_value \\ 10) + 48).to_character)                                                          append_character ('8')
1445                                                          l_value := -(l_value // 10)                                                          l_value := -(i // 10)
1446                                                    else
1447                                                            l_value := -i
1448                                                  end                                                  end
1449                                          else                                          else
1450                                                  l_value := i                                                  l_value := i
# Line 1399  feature -- Element change Line 1452  feature -- Element change
1452                                  until                                  until
1453                                          l_value = 0                                          l_value = 0
1454                                  loop                                  loop
1455                                          append_character (((l_value \\ 10)+ 48).to_character)                                          append_character (((l_value \\ 10)+ 48).to_character_8)
1456                                          l_value := l_value // 10                                          l_value := l_value // 10
1457                                  end                                  end
1458    
# Line 1436  feature -- Element change Line 1489  feature -- Element change
1489                                          if i < 0 then                                          if i < 0 then
1490                                                  append_character ('-')                                                  append_character ('-')
1491                                                  l_starting_index := l_starting_index + 1                                                  l_starting_index := l_starting_index + 1
                                                 l_value := -i  
1492                                                          -- Special case for minimum integer value as negating it                                                          -- Special case for minimum integer value as negating it
1493                                                          -- as no effect.                                                          -- as no effect.
1494                                                  if l_value = feature {INTEGER_16_REF}.Min_value then                                                  if i = {INTEGER_16}.Min_value then
1495                                                          append_character ((-(l_value \\ 10) + 48).to_character)                                                          append_character ('8')
1496                                                          l_value := -(l_value // 10)                                                          l_value := -(i // 10)
1497                                                    else
1498                                                            l_value := -i
1499                                                  end                                                  end
1500                                          else                                          else
1501                                                  l_value := i                                                  l_value := i
# Line 1449  feature -- Element change Line 1503  feature -- Element change
1503                                  until                                  until
1504                                          l_value = 0                                          l_value = 0
1505                                  loop                                  loop
1506                                          append_character (((l_value \\ 10)+ 48).to_character)                                          append_character (((l_value \\ 10)+ 48).to_character_8)
1507                                          l_value := l_value // 10                                          l_value := l_value // 10
1508                                  end                                  end
1509    
# Line 1486  feature -- Element change Line 1540  feature -- Element change
1540                                          if i < 0 then                                          if i < 0 then
1541                                                  append_character ('-')                                                  append_character ('-')
1542                                                  l_starting_index := l_starting_index + 1                                                  l_starting_index := l_starting_index + 1
                                                 l_value := -i  
1543                                                          -- Special case for minimum integer value as negating it                                                          -- Special case for minimum integer value as negating it
1544                                                          -- as no effect.                                                          -- as no effect.
1545                                                  if l_value = feature {INTEGER_64_REF}.Min_value then                                                  if i = {INTEGER_64}.Min_value then
1546                                                          append_character ((-(l_value \\ 10) + 48).to_character)                                                          append_character ('8')
1547                                                          l_value := -(l_value // 10)                                                          l_value := -(i // 10)
1548                                                    else
1549                                                            l_value := -i
1550                                                  end                                                  end
1551                                          else                                          else
1552                                                  l_value := i                                                  l_value := i
# Line 1499  feature -- Element change Line 1554  feature -- Element change
1554                                  until                                  until
1555                                          l_value = 0                                          l_value = 0
1556                                  loop                                  loop
1557                                          append_character (((l_value \\ 10)+ 48).to_character)                                          append_character (((l_value \\ 10)+ 48).to_character_8)
1558                                          l_value := l_value // 10                                          l_value := l_value // 10
1559                                  end                                  end
1560    
# Line 1537  feature -- Element change Line 1592  feature -- Element change
1592                                  until                                  until
1593                                          l_value = 0                                          l_value = 0
1594                                  loop                                  loop
1595                                          append_character (((l_value \\ 10)+ 48).to_character)                                          append_character (((l_value \\ 10)+ 48).to_character_8)
1596                                          l_value := l_value // 10                                          l_value := l_value // 10
1597                                  end                                  end
1598    
# Line 1575  feature -- Element change Line 1630  feature -- Element change
1630                                  until                                  until
1631                                          l_value = 0                                          l_value = 0
1632                                  loop                                  loop
1633                                          append_character (((l_value \\ 10)+ 48).to_character)                                          append_character (((l_value \\ 10)+ 48).to_character_8)
1634                                          l_value := l_value // 10                                          l_value := l_value // 10
1635                                  end                                  end
1636    
# Line 1613  feature -- Element change Line 1668  feature -- Element change
1668                                  until                                  until
1669                                          l_value = 0                                          l_value = 0
1670                                  loop                                  loop
1671                                          append_character (((l_value \\ 10)+ 48).to_character)                                          append_character (((l_value \\ 10)+ 48).to_character_8)
1672                                          l_value := l_value // 10                                          l_value := l_value // 10
1673                                  end                                  end
1674    
# Line 1651  feature -- Element change Line 1706  feature -- Element change
1706                                  until                                  until
1707                                          l_value = 0                                          l_value = 0
1708                                  loop                                  loop
1709                                          append_character (((l_value \\ 10)+ 48).to_character)                                          append_character (((l_value \\ 10)+ 48).to_character_8)
1710                                          l_value := l_value // 10                                          l_value := l_value // 10
1711                                  end                                  end
1712    
# Line 1798  feature -- Removal Line 1853  feature -- Removal
1853    
1854          remove (i: INTEGER) is          remove (i: INTEGER) is
1855                          -- Remove `i'-th character.                          -- Remove `i'-th character.
                 require  
                         index_small_enough: i <= count  
                         index_large_enough: i > 0  
1856                  local                  local
1857                          l_count: INTEGER                          l_count: INTEGER
1858                  do                  do
# Line 1810  feature -- Removal Line 1862  feature -- Removal
1862                                  -- Update content.                                  -- Update content.
1863                          count := l_count - 1                          count := l_count - 1
1864                          internal_hash_code := 0                          internal_hash_code := 0
                 ensure  
                         new_count: count = old count - 1  
                         removed: elks_checking implies is_equal (old substring (1, i - 1) + old substring (i + 1, count))  
1865                  end                  end
1866    
1867          remove_head (n: INTEGER) is          remove_head (n: INTEGER) is
# Line 1976  feature -- Resizing Line 2025  feature -- Resizing
2025                          -- Rearrange string so that it can accommodate                          -- Rearrange string so that it can accommodate
2026                          -- at least `newsize' characters.                          -- at least `newsize' characters.
2027                          -- Do not lose any previously entered character.                          -- Do not lose any previously entered character.
                 require  
                         new_size_non_negative: newsize >= 0  
2028                  local                  local
2029                          area_count: INTEGER                          area_count: INTEGER
2030                  do                  do
# Line 2407  feature -- Conversion Line 2454  feature -- Conversion
2454                          Result := l_area                          Result := l_area
2455                  end                  end
2456    
         frozen to_cil: SYSTEM_STRING is  
                         -- Create an instance of SYSTEM_STRING using characters  
                         -- of Current between indices `1' and `count'.  
                 require  
                         is_dotnet: {PLATFORM}.is_dotnet  
                 do  
                         create Result.make (area.native_array, 0, count)  
                 ensure  
                         to_cil_not_void: Result /= Void  
                 end  
   
2457          mirrored: like Current is          mirrored: like Current is
2458                          -- Mirror image of string;                          -- Mirror image of string;
2459                          -- Result for "Hello world" is "dlrow olleH".                          -- Result for "Hello world" is "dlrow olleH".
# Line 2472  feature -- Duplication Line 2508  feature -- Duplication
2508                          else                          else
2509                                  Result := new_string (0)                                  Result := new_string (0)
2510                          end                          end
2511                  ensure                  ensure then
                         substring_not_void: Result /= Void  
                         substring_count: Result.count = end_index - start_index + 1 or Result.count = 0  
2512                          first_item: Result.count > 0 implies Result.item (1) = item (start_index)                          first_item: Result.count > 0 implies Result.item (1) = item (start_index)
2513                          recurse: Result.count > 0 implies                          recurse: Result.count > 0 implies
2514                                  Result.substring (2, Result.count).is_equal (substring (start_index + 1, end_index))                                  Result.substring (2, Result.count).is_equal (substring (start_index + 1, end_index))
# Line 2517  feature {STRING_HANDLER} -- Implementati Line 2551  feature {STRING_HANDLER} -- Implementati
2551    
2552          frozen set_count (number: INTEGER) is          frozen set_count (number: INTEGER) is
2553                          -- Set `count' to `number' of characters.                          -- Set `count' to `number' of characters.
                 require  
                         valid_count: 0 <= number and number <= capacity  
2554                  do                  do
2555                          count := number                          count := number
2556                          internal_hash_code := 0                          internal_hash_code := 0
                 ensure  
                         new_count: count = number  
2557                  end                  end
2558    
2559  feature {NONE} -- Empty string implementation  feature {NONE} -- Empty string implementation
2560    
         elks_checking: BOOLEAN is False  
                         -- Are ELKS checkings verified? Must be True when changing implementation of STRING or descendant.  
   
2561          internal_hash_code: INTEGER          internal_hash_code: INTEGER
2562                          -- Computed hash-code.                          -- Computed hash-code.
2563    
2564          frozen set_internal_hash_code (v: like internal_hash_code) is          frozen set_internal_hash_code (v: like internal_hash_code) is
2565                          -- Set `internal_hash_code' with `v'.                          -- Set `internal_hash_code' with `v'.
                 require  
                         v_nonnegative: v >= 0  
2566                  do                  do
2567                          internal_hash_code := v                          internal_hash_code := v
                 ensure  
                         internal_hash_code_set: internal_hash_code = v  
2568                  end                  end
2569    
2570  feature {NONE} -- Implementation  feature {NONE} -- Implementation
# Line 2604  feature {NONE} -- Implementation Line 2627  feature {NONE} -- Implementation
2627                          end                          end
2628                  end                  end
2629    
         string_searcher: STRING_SEARCHER is  
                         -- Facilities to search string in another string.  
                 once  
                         create Result.make  
                 ensure  
                         string_searcher_not_void: Result /= Void  
                 end  
   
         c_string_provider: C_STRING is  
                         -- To create Eiffel strings from C string.  
                 once  
                         create Result.make_empty (0)  
                 ensure  
                         c_string_provider_not_void: Result /= Void  
                 end  
   
2630          empty_area: SPECIAL [CHARACTER] is          empty_area: SPECIAL [CHARACTER] is
2631                          -- Empty `area' to avoid useless creation of empty areas when wiping out a STRING.                          -- Empty `area' to avoid useless creation of empty areas when wiping out a STRING.
2632                  obsolete                  obsolete
# Line 2630  feature {NONE} -- Implementation Line 2637  feature {NONE} -- Implementation
2637                          empty_area_not_void: Result /= Void                          empty_area_not_void: Result /= Void
2638                  end                  end
2639    
         ctoi_convertor: STRING_TO_INTEGER_CONVERTOR is  
                         -- Convertor used to convert string to integer or natural  
                 once  
                         create Result.make  
                         Result.set_leading_separators (" ")  
                         Result.set_trailing_separators (" ")  
                         Result.set_leading_separators_acceptable (True)  
                         Result.set_trailing_separators_acceptable (True)  
                 end  
   
         ctor_convertor: STRING_TO_REAL_CONVERTOR is  
                         -- Convertor used to convert string to real or double  
                 once  
                         create Result.make  
                         Result.set_leading_separators (" ")  
                         Result.set_trailing_separators (" ")  
                         Result.set_leading_separators_acceptable (True)  
                         Result.set_trailing_separators_acceptable (True)  
                 end  
   
2640  invariant  invariant
2641          extendible: extendible          extendible: extendible
2642          compare_character: not object_comparison          compare_character: not object_comparison

Legend:
Removed from v.91475  
changed lines
  Added in v.91477

  ViewVC Help
Powered by ViewVC 1.1.23