created mirror

Java/media/Span.java

@@ -0,0 +1,178 @@
+/*   
+Span.java
+ *    
+ *    Copyright (c) 1999, Ted Nelson and Tuomas Lukka
+ *
+ *    You may use and distribute under the terms of either the GNU Lesser
+ *    General Public License, either version 2 of the license or,
+ *    at your choice, any later version. Alternatively, you may use and
+ *    distribute under the terms of the XPL.
+ *
+ *    See the LICENSE.lgpl and LICENSE.xpl files for the specific terms of 
+ *    the licenses.
+ *
+ *    This software is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the README
+ *    file for more details.
+ *
+ */
+/*
+ * Written by Tuomas Lukka
+ */
+
+package org.gzigzag;
+import java.util.*;
+
+/** An address span in the stable media streams.
+ * Currently just a silly pointer but will be later extended
+ * to include full tumblers.
+ * <p>
+ * Spans are immutable, just like Strings: all the verb-like method
+ * like join and split return new Span objects.
+ */
+
+public class Span {
+public static final String rcsid = "$Id: Span.java,v 1.9 2001/03/11 19:14:38 veparkki Exp $";
+    public static final boolean dbg = false;
+    static final void p(String s) { if(dbg) System.out.println(s); }
+    Address a1; 
+    Address a2;
+
+    public Address getStart() { return a1; }
+    public Address getEnd() { return a2; }
+    public long getStartOffs() { return a1.offset; }
+    public long getEndOffs() { return a2.offset; }
+
+    public static Span parse(String str) {
+	    StringTokenizer st = new StringTokenizer(str, ":");
+	    if(st.countTokens() != 2) 
+		    throw new ZZError("Wrong number of ':' toks in '"+str+"'");
+	    Span s = new Span();
+	    s.a1 = Address.parse(st.nextToken());
+	    s.a2 = Address.parse(st.nextToken());
+	    if(!s.a1.getStream().equals(s.a2.getStream()))
+		    throw new ZZError("Must be same stream for now '" + str
+			    +"' '"+s.a1.getStream()+"' '"+s.a2.getStream()+"'");
+	    return s;
+    }
+
+    public static Span create(Address i1, Address i2) {
+	    Span s = new Span();
+	    s.a1 = i1; s.a2 = i2;
+	    return s;
+    }
+
+    public String toString() {
+	    return a1+":"+a2;
+    }
+
+    public boolean overlaps(Span s) {
+	if(a2.lessThan(s.a1) || s.a2.lessThan(a1)) return false;
+	return true;
+    }
+
+    /** The string pointed to by the span.
+     */
+    public String getString(ZZCell c)  {
+	Scroll scr //= c.getSpace().getStringScroll(a1.getStream());
+	    = Scroll.obtain((c==null?null:c.getSpace()), 
+			    a1.getStream());
+	    p("Scroll: "+scr);
+	    if(scr instanceof StringScroll) {
+		StringScroll s = (StringScroll) scr;
+		int o1 = (int)a1.getOffs();
+		int o2 = (int)a2.getOffs();
+		if(o1 > o2) {
+		    // This is allowed
+		    if(o1-o2 == 1) return "";
+		    // This is not
+		    throw new ZZError("Too negative span "+ this);
+		}
+		return s.getString(a1.getOffs(), 
+			(int)(o2-o1)+1);
+	    } if(scr instanceof ByteScroll) {
+		    ByteScroll s = (ByteScroll)scr;
+		    return s.getString(a1.getOffs(), 
+			    (int)(a2.getOffs()-a1.getOffs())+1);
+	    }
+	    if(scr instanceof CharScroll) {
+		    CharScroll s = (CharScroll)scr;
+		    return s.getString(a1.getOffs(), 
+			    (int)(a2.getOffs()-a1.getOffs())+1);
+	    }
+	    if(scr instanceof SoundScroll) {
+		    return "SND " + toString();
+	    }
+	    return "???";
+    }
+
+    public Span adjustEdge(int edge, long units) {
+	Address adj = (edge==0?a1:a2);
+	adj = Address.streamOffs(adj.getStream(), adj.getOffs()+units);
+	Address x = (edge==0?adj:a1);
+	Address y = (edge==1?adj:a2);
+	return create(x,y);
+    }
+    public Span[] adjustEdgeLocked(long units, Span other, long allowfudge) {
+	Address adj = a2;
+	adj = Address.streamOffs(adj.getStream(), adj.getOffs()+units);
+	long d = adj.getOffs() - other.a1.getOffs();
+	if(d<0) d = -d;
+	if(d>allowfudge)
+	    return new Span[] {
+		create(a1, adj), other
+	    };
+    	return new Span[] {
+	    	create(a1, adj),
+		create(Address.streamOffs(adj.getStream(), adj.getOffs()+1),
+		             other.a2)
+	};
+	
+    }
+    public Span[] splitInHalf() {
+	long off = (a1.getOffs() + a2.getOffs()) / 2;
+	return new Span[] {
+	    create(a1, Address.streamOffs(a1.getStream(), off-1)),
+	    create(Address.streamOffs(a1.getStream(), off), a2),
+	};
+    }
+    public Span join(Span next, long allowfudge) {
+	if(! a2.getStream().equals(next.a1.getStream()))
+		return null;
+	long diff = a2.getOffs() - next.a1.getOffs();
+	if(diff<0) diff = -diff;
+	if(diff > allowfudge) 
+	    return null;
+	return create(a1, next.a2);
+    }
+
+    /** Does exactly what substring does to String.
+     * This is in opposition to the other span routines 
+     * in which the last address is given, not one beyond!
+     */
+    public Span subSpan(int o1, int o2) {
+	return create(a1.addOffs(o1), a1.addOffs(o2-1));
+    }
+    public Span subSpan(int o1) {
+	return create(a1.addOffs(o1), a2);
+    }
+
+    /** Whether this span can be joined with the other span.
+     */
+    public boolean isAppendable(Span s) {
+	return a2.getStream().equals(s.a1.getStream())
+	    && a2.getOffs() == s.a1.getOffs()-1;
+    }
+
+    // XXX Check?
+    public Span append(Span s) {
+	return create(a1, s.a2);
+    }
+    
+
+    public long length() {
+	return a2.getOffs() - a1.getOffs() + 1;
+    }
+
+}