modules/swfutils/src/java/flash/swf/types/ActionList.java - flex-sdk - Git at Google

 /*
  *
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  *
  */

 package flash.swf.types;

 import java.util.Arrays;

 import flash.swf.Action;
 import flash.swf.ActionHandler;

 /**
  * This class represents an array of AS2 byte codes.
  */
 public class ActionList extends ActionHandler
 {
 	// start numbering internal opcodes at 256 to make sure we wont
 	// collide with a real player opcode.  player opcodes are 8-bit.
 	public static final int sactionLabel = 256;
 	public static final int sactionLineRecord = 257;
 	public static final int sactionRegisterRecord = 258;

 	public ActionList()
 	{
         this(false);
 	}

     public ActionList(int capacity)
     {
         this(false, capacity);
     }

     public ActionList(boolean keepOffsets)
     {
         this(keepOffsets, 10);
     }

     public ActionList(boolean keepOffsets, int capacity)
     {
         if (keepOffsets)
             offsets = new int[capacity];
         actions = new Action[capacity];
         size = 0;
     }

 	private int[] offsets;
 	private Action[] actions;
 	private int size;

     public boolean equals(Object object)
     {
         boolean isEqual = false;

         if (object instanceof ActionList)
         {
             ActionList actionList = (ActionList) object;

             if ( Arrays.equals(actionList.actions, this.actions) )
             {
                 isEqual = true;
             }
         }

         return isEqual;
     }

 	public void visitAll(ActionHandler handler)
 	{
 		visit(handler, 0, size-1);
     }

 	public void visit(ActionHandler handler, int startIndex, int endIndex)
 	{
 		endIndex = (endIndex < 0) ? size-1 : endIndex;
 		for (int j=startIndex; j <= endIndex; j++)
 		{
 			Action a = actions[j];
 			if (a.code != sactionLabel && a.code != sactionLineRecord)
 			{
 				// don't call this for labels
                 if (offsets != null)
     				handler.setActionOffset(offsets[j], a);
                 else
                     handler.setActionOffset(j, a);
 			}
 			a.visit(handler);
 		}
     }

     public void setActionOffset(int offset, Action a)
     {
 		insert(offset, a);
     }

 	public void grow(int capacity)
 	{
         if (offsets != null)
         {
             int[] newoffsets = new int[capacity];
             System.arraycopy(offsets,0,newoffsets,0,size);
             offsets = newoffsets;
         }

 		Action[] newactions = new Action[capacity];
 		System.arraycopy(actions,0,newactions,0,size);
 		actions = newactions;
 	}

 	public int size()
 	{
 		return size;
 	}

 	public Action getAction(int i)
 	{
 		return actions[i];
 	}

 	public int getOffset(int i)
 	{
 		return offsets[i];
 	}

 	public void remove(int i)
 	{
         if (offsets != null)
     		System.arraycopy(offsets, i+1, offsets, i, size-i-1);
 		System.arraycopy(actions, i+1, actions, i, size-i-1);
 		size--;
 	}

 	/**
 	 * perform a binary search to find the requested offset.
 	 * @param k
 	 * @return the index where that offset is found, or -(ins+1) if
 	 * the key is not found, and ins is the insertion index.
 	 *
 	 */
 	private int find(int k)
 	{
         if (offsets != null)
         {
             int lo = 0;
             int hi = size-1;

             while (lo <= hi)
             {
                 int i = (lo + hi)/2;
                 int m = offsets[i];
                 if (k > m)
                     lo = i + 1;
                 else if (k < m)
                     hi = i - 1;
                 else
                     return i; // key found
             }
             return -(lo + 1);  // key not found, lo is the insertion point
         }
         else
         {
             return k;
         }
 	}

 	public void insert(int offset, Action a)
 	{
 		if (size==actions.length)
 			grow(size*2);
 		int i;
 		if (size == 0 || offsets == null && offset == size || offsets != null && offset > offsets[size-1])
 		{
 			// appending.
 			i = size;
 		}
 		else
 		{
 			i = find(offset);
 			if (i < 0)
 			{
 				// offset not used yet.  compute insertion point
 				i = -i - 1;
 			}
 			else
 			{
 				// offset already used.  if we are inserting a real action, make it be last
 				if (a.code < 256)
 				{
 					// this is a real action, we want it to be last at this offset
 					while (i < size && offsets[i] == offset)
 						i++;
 				}
 			}
             if (offsets != null)
     			System.arraycopy(offsets, i, offsets, i+1, size-i);
 			System.arraycopy(actions, i, actions, i+1, size-i);
 		}
         if (offsets != null)
     		offsets[i] = offset;
 		actions[i] = a;
 		size++;
 	}

     public void append(Action a)
     {
         int i=size;
         if (i == actions.length)
             grow(size*2);
         actions[i] = a;
         size = i+1;
     }

     public String toString()
     {
         StringBuilder stringBuffer = new StringBuilder();

         stringBuffer.append("ActionList: count = " + actions.length);
         stringBuffer.append(", actions = ");

         for (int i = 0; i < size; i++)
         {
             stringBuffer.append(actions[i]);
         }

         return stringBuffer.toString();
     }

 	/**
 	 * Return the index within this action list of the first
 	 * occurence of the specified actionCode, searching foward
 	 * starting at the given index
 	 */
 	public int indexOf(int actionCode, int startAt)
 	{
 		int at = -1;
 		for(int i=startAt; at<0 && i<actions.length; i++)
 		{
 			Action a = getAction(i);
 			if (a != null && a.code == actionCode)
 				at = i;
 		}
 		return at;
 	}

 	/**
 	 * Return the index within this action list of the first
 	 * occurence of the specified actionCode, searching backward
 	 * starting at the given index
 	 */
 	public int lastIndexOf(int actionCode, int startAt)
 	{
 		int at = -1;
 		for(int i=startAt; at<0 && i>=0; i--)
 		{
 			Action a = getAction(i);
 			if (a != null && a.code == actionCode)
 				at = i;
 		}
 		return at;
 	}

 	// specialized indexOf and lastIndexOf that start at the beginning and end of the actions list respectively
 	public int indexOf(int actionCode) { return indexOf(actionCode, 0); }
 	public int lastIndexOf(int actionCode) { return lastIndexOf(actionCode, actions.length-1); }

     public void setAction(int i, Action action)
     {
         actions[i] = action;
     }
 }
	/*
	*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	*/

	package flash.swf.types;

	import java.util.Arrays;

	import flash.swf.Action;
	import flash.swf.ActionHandler;

	/**
	* This class represents an array of AS2 byte codes.
	*/
	public class ActionList extends ActionHandler
	{
	// start numbering internal opcodes at 256 to make sure we wont
	// collide with a real player opcode. player opcodes are 8-bit.
	public static final int sactionLabel = 256;
	public static final int sactionLineRecord = 257;
	public static final int sactionRegisterRecord = 258;

	public ActionList()
	{
	this(false);
	}

	public ActionList(int capacity)
	{
	this(false, capacity);
	}

	public ActionList(boolean keepOffsets)
	{
	this(keepOffsets, 10);
	}

	public ActionList(boolean keepOffsets, int capacity)
	{
	if (keepOffsets)
	offsets = new int[capacity];
	actions = new Action[capacity];
	size = 0;
	}

	private int[] offsets;
	private Action[] actions;
	private int size;

	public boolean equals(Object object)
	{
	boolean isEqual = false;

	if (object instanceof ActionList)
	{
	ActionList actionList = (ActionList) object;

	if ( Arrays.equals(actionList.actions, this.actions) )
	{
	isEqual = true;
	}
	}

	return isEqual;
	}

	public void visitAll(ActionHandler handler)
	{
	visit(handler, 0, size-1);
	}

	public void visit(ActionHandler handler, int startIndex, int endIndex)
	{
	endIndex = (endIndex < 0) ? size-1 : endIndex;
	for (int j=startIndex; j <= endIndex; j++)
	{
	Action a = actions[j];
	if (a.code != sactionLabel && a.code != sactionLineRecord)
	{
	// don't call this for labels
	if (offsets != null)
	handler.setActionOffset(offsets[j], a);
	else
	handler.setActionOffset(j, a);
	}
	a.visit(handler);
	}
	}

	public void setActionOffset(int offset, Action a)
	{
	insert(offset, a);
	}

	public void grow(int capacity)
	{
	if (offsets != null)
	{
	int[] newoffsets = new int[capacity];
	System.arraycopy(offsets,0,newoffsets,0,size);
	offsets = newoffsets;
	}

	Action[] newactions = new Action[capacity];
	System.arraycopy(actions,0,newactions,0,size);
	actions = newactions;
	}

	public int size()
	{
	return size;
	}

	public Action getAction(int i)
	{
	return actions[i];
	}

	public int getOffset(int i)
	{
	return offsets[i];
	}

	public void remove(int i)
	{
	if (offsets != null)
	System.arraycopy(offsets, i+1, offsets, i, size-i-1);
	System.arraycopy(actions, i+1, actions, i, size-i-1);
	size--;
	}

	/**
	* perform a binary search to find the requested offset.
	* @param k
	* @return the index where that offset is found, or -(ins+1) if
	* the key is not found, and ins is the insertion index.
	*
	*/
	private int find(int k)
	{
	if (offsets != null)
	{
	int lo = 0;
	int hi = size-1;

	while (lo <= hi)
	{
	int i = (lo + hi)/2;
	int m = offsets[i];
	if (k > m)
	lo = i + 1;
	else if (k < m)
	hi = i - 1;
	else
	return i; // key found
	}
	return -(lo + 1); // key not found, lo is the insertion point
	}
	else
	{
	return k;
	}
	}

	public void insert(int offset, Action a)
	{
	if (size==actions.length)
	grow(size*2);
	int i;
	if (size == 0 \|\| offsets == null && offset == size \|\| offsets != null && offset > offsets[size-1])
	{
	// appending.
	i = size;
	}
	else
	{
	i = find(offset);
	if (i < 0)
	{
	// offset not used yet. compute insertion point
	i = -i - 1;
	}
	else
	{
	// offset already used. if we are inserting a real action, make it be last
	if (a.code < 256)
	{
	// this is a real action, we want it to be last at this offset
	while (i < size && offsets[i] == offset)
	i++;
	}
	}
	if (offsets != null)
	System.arraycopy(offsets, i, offsets, i+1, size-i);
	System.arraycopy(actions, i, actions, i+1, size-i);
	}
	if (offsets != null)
	offsets[i] = offset;
	actions[i] = a;
	size++;
	}

	public void append(Action a)
	{
	int i=size;
	if (i == actions.length)
	grow(size*2);
	actions[i] = a;
	size = i+1;
	}

	public String toString()
	{
	StringBuilder stringBuffer = new StringBuilder();

	stringBuffer.append("ActionList: count = " + actions.length);
	stringBuffer.append(", actions = ");

	for (int i = 0; i < size; i++)
	{
	stringBuffer.append(actions[i]);
	}

	return stringBuffer.toString();
	}

	/**
	* Return the index within this action list of the first
	* occurence of the specified actionCode, searching foward
	* starting at the given index
	*/
	public int indexOf(int actionCode, int startAt)
	{
	int at = -1;
	for(int i=startAt; at<0 && i<actions.length; i++)
	{
	Action a = getAction(i);
	if (a != null && a.code == actionCode)
	at = i;
	}
	return at;
	}

	/**
	* Return the index within this action list of the first
	* occurence of the specified actionCode, searching backward
	* starting at the given index
	*/
	public int lastIndexOf(int actionCode, int startAt)
	{
	int at = -1;
	for(int i=startAt; at<0 && i>=0; i--)
	{
	Action a = getAction(i);
	if (a != null && a.code == actionCode)
	at = i;
	}
	return at;
	}

	// specialized indexOf and lastIndexOf that start at the beginning and end of the actions list respectively
	public int indexOf(int actionCode) { return indexOf(actionCode, 0); }
	public int lastIndexOf(int actionCode) { return lastIndexOf(actionCode, actions.length-1); }

	public void setAction(int i, Action action)
	{
	actions[i] = action;
	}
	}