update to Jaba_r1 minimal client distribution, and resolve issues JAL-602
[jalview.git] / src / com / stevesoft / pat / patInt.java
1 //
2 // This software is now distributed according to
3 // the Lesser Gnu Public License.  Please see
4 // http://www.gnu.org/copyleft/lesser.txt for
5 // the details.
6 //    -- Happy Computing!
7 //
8 package com.stevesoft.pat;
9
10 /**
11  * This is just an integer that can have infinite value. It is used internally
12  * to implement the *, and + parts of regular expressions.
13  */
14 public class patInt
15 {
16   int i;
17
18   boolean inf;
19
20   /** Initialize to zero. */
21   public patInt()
22   {
23     i = 0;
24     inf = false;
25   }
26
27   /** Initialize to the value of init. */
28   public patInt(int init)
29   {
30     i = init;
31     inf = false;
32   }
33
34   /** Initialize to the value of p. */
35   public patInt(patInt p)
36   {
37     i = p.i;
38     inf = p.inf;
39   }
40
41   /** set this int to infinity. */
42   public void setInf(boolean b)
43   {
44     inf = b;
45     if (b)
46     {
47       i = Integer.MAX_VALUE;
48     }
49   }
50
51   /** Increment the value of this by 1. */
52   public final void inc()
53   {
54     if (!inf)
55     {
56       i++;
57     }
58   }
59
60   /** Decrement the value of this by 1. */
61   public final void dec()
62   {
63     if (!inf)
64     {
65       i--;
66     }
67   }
68
69   /** Test to see if this is less than or equal to j. */
70   public final boolean lessEq(patInt j)
71   { /*
72      * if(inf) return false; if(j.inf) return true; return i <= j.i;
73      */
74     return !inf && (j.inf || i <= j.i);
75   }
76
77   /** Test to see if two patterns are equal. */
78   public final boolean equals(patInt j)
79   {
80     return !j.inf && !inf && i == j.i;
81   }
82
83   /**
84    * Formats the pattern as a String. Contrary to what you might expect,
85    * infinity is formatted as ""
86    */
87   final public String toString()
88   {
89     if (inf)
90     {
91       return "";
92     }
93     else
94     {
95       return "" + i;
96     }
97   }
98
99   /**
100    * This would be operator+=(patInt) if I were programming in C++.
101    */
102   public final patInt pluseq(patInt p)
103   {
104     if (inf || p.inf)
105     {
106       setInf(true);
107     }
108     else
109     {
110       i += p.i;
111     }
112     return this;
113   }
114
115   /**
116    * Returns a patInt with value equal to the product of the value of p and
117    * this.
118    */
119   public final patInt mul(patInt p)
120   {
121     if (inf || p.inf)
122     {
123       return new patInf();
124     }
125     return new patInt(i * p.i);
126   }
127
128   /**
129    * If the argument p has a smaller value than this, then set this Object equal
130    * to p.
131    */
132   public final patInt mineq(patInt p)
133   {
134     if (p.inf)
135     {
136       return this;
137     }
138     if (inf)
139     {
140       i = p.i;
141     }
142     else if (p.i < i)
143     {
144       i = p.i;
145     }
146     setInf(false);
147     return this;
148   }
149
150   /**
151    * If the argument p has a greater than this, then set this object equal to p.
152    */
153   public final patInt maxeq(patInt p)
154   {
155     if (inf || p.inf)
156     {
157       setInf(true);
158       return this;
159     }
160     if (p.i > i)
161     {
162       i = p.i;
163     }
164     return this;
165   }
166
167   /** Tests to see if this represents an infinite quantity. */
168   public boolean finite()
169   {
170     return !inf;
171   }
172
173   /**
174    * Converts to a patInt to an int. Infinity is mapped Integer.MAX_VALUE;
175    */
176   public int intValue()
177   {
178     return inf ? Integer.MAX_VALUE : i;
179   }
180 };