itemgroup.java

用于串口通讯测试的工具软件。完全使用java语言编写。

package com.zcsoft.opc;

import java.util.*;

/** 网络变量所属组
 * <p>Copyright: Copyright (c) 2004－2005</p>
 * <p>Company: Zhicheng Software&Service Co. Ltd.</p>
 * @author 蒋智湘
 * @version 1.0
 */
public class ItemGroup
{
	/** 网络变量组的名称 */
	private String name;
	/** 组中各个变量值的自动请求刷新间隔时间，缺省值为500毫秒 */
	private int updateRate = 500;
	/** 是否自动刷新组上各个变量的值 */
	private boolean active = true;
	/** 组中的所有网络变量的集合 */
	private List items = new ArrayList();

	/**
	 * OPC控制中心使用该属性值操作该变量组。这些操作包括读写、激活变量组等。
	 * 同时OPC控制中心向其反馈异步读写和变量值变换通知时也使用该属性值来标识
	 * 是针对那一个变量组。
	 */
	int index = -1;

	/**
	 * 针对组操作的请求发送接口实现
	 */
	CommandSent cmdSentHook;

	/**
	 * 我们将可能接收到值变化通知的变量存放到一个数组中。
	 * 只要当前通知时值发生变化的变量的个数不大于数组cachedActiveItems
	 * 的长度，就不会重新实例化该数组，这样可以有效地较少频繁的内存开销。
	 */
	transient Item[] cachedActiveItems = new Item[0];
	/**
	 * 我们将可能接收到值变化通知的变量的旧值存放到一个数组中。
	 * 只要当前通知时值发生变化的变量的个数不大于数组cachedOldValues
	 * 的长度，就不会重新实例化该数组，这样可以有效地较少频繁的内存开销。
	 */
	transient Variant[] cachedOldValues;

	/** 回调事件接收接口实例集 */
	transient private Vector callbackListeners;

	public ItemGroup(String name)
	{
		if (name == null)
		{
			throw new NullPointerException();
		}
		this.name = name;
	}

	public String getName()
	{
		return name;
	}

	/**
	 * @retrun 组中定义了多少个网络变量
	 */
	public int itemCount()
	{
		return items.size();
	}

	public void addItem(Item an) throws DuplicatedException
	{
		this.items.add(an);
	}

	public int indexOfItem(String itemId)
	{
		int index = -1;
		List items = this.items;
		for (int i = items.size() - 1; i >= 0; i--)
		{
			if (((Item)items.get(i)).getID().equals(itemId))
			{
				index = i;
				break;
			}
		}
		return index;
	}

	public Item findItem(String itemId)
	{
		int index = indexOfItem(itemId);
		return index != -1?getItem(index):null;
	}

	public Item getItem(int index)
	{
		return (Item)this.items.get(index);
	}
	public int getUpdateRate()
	{
		return updateRate;
	}
	public void setUpdateRate(int updateRate)
	{
		this.updateRate = updateRate;
	}

	public void setActive(boolean active)
	{
		this.active = active;
	}
	public boolean isActive()
	{
		return active;
	}

	/**
	 * 有变量的别名查找这些变量在组上定义的所有变量之集合上的索引。
	 * @param aliasOfItems 待查找变量的别名集
	 * @return 索引集。
	 * @throw IllegalArgumentException 如果有一个变量没有定义。
	 * @throw NullPointerExcepton aliasOfItem中某个成员为null
	 */
	public int[] getIndex(String[] aliasOfItems)
	{
		int n = aliasOfItems.length;
		int[] indexes = new int[n];
		List items = this.items;
		int cntItems = items.size();
		String alias;
		int j;
		int index;
		for (int i = 0; i < n; i++)
		{
			alias = aliasOfItems[i];
			index = -1;
			for (j = 0; j < cntItems; j++)
			{
				if(alias.equals(((Item)items.get(j)).getAlias()))
				{
					index = j;
					break;
				}
			}
			if (index == -1)
			{
				throw new IllegalArgumentException("Not found item: " + alias);
			}
			indexes[i] = index;
		}

		return indexes;
	}

	void ensureCapacity(int capacity)
	{
		if (cachedActiveItems.length < capacity)
		{
			cachedActiveItems = new Item[capacity];
			cachedOldValues =  new Variant[capacity];
		}
	}

	/**
	 * 同步写出多个变量的值
	 * @param indexItems 各个变量的索引
	 * @param cntItems indexItems中前cntItems个变量是实际要写出的
	 * @param values 那些变量的值
	 * @throws java.io.IOException 套接字操作异常或服务端写操作错误
	 */
	public void syncWrite(int[] indexItems, int cntItems, Variant[] values)
			throws java.io.IOException
	{
		if (index == -1)
		{
			throw new OpcException("Has't bound to OpcCtrl");
		}
		List headers = new ArrayList(cntItems);
		int indexItem;
		StringBuffer header = new StringBuffer();
		header.append("SW").append(CommandSent.DELIMETER).append(index)
				.append(CommandSent.DELIMETER).append(cntItems);
		headers.add(header.toString());
		for (int i = 0; i < cntItems; i++)
		{
			indexItem = indexItems[i];

			header.setLength(0);
			header.append(indexItem);
			header.append(CommandSent.DELIMETER);
			header.append(values[i].iValue);

			headers.add(header.toString());
		}
		cmdSentHook.request(headers);
	}


	public synchronized void removeCallbackListener(CallbackListener l)
	{
		if (callbackListeners != null && callbackListeners.contains(l))
		{
			Vector v = (Vector) callbackListeners.clone();
			v.removeElement(l);
			callbackListeners = v;
		}
	}


	public synchronized void addCallbackListener(CallbackListener l)
	{
		Vector v = callbackListeners == null ? new Vector(1) : callbackListeners;
		if (!v.contains(l))
		{
			v.addElement(l);
			callbackListeners = v;
		}
	}


	protected void fireDataChanged(CallbackEvent e)
	{
		if (callbackListeners != null)
		{
			Vector listeners = callbackListeners;
			int count = listeners.size();
			for (int i = 0; i < count; i++)
			{
				((CallbackListener) listeners.elementAt(i)).dataChanged(e);
			}
		}
	}
	public Item[] getCachedActiveItems()
	{
		return cachedActiveItems;
	}
	public Variant[] getCachedOldValues()
	{
		return cachedOldValues;
	}


	/*protected void fireWriteComplete(CallbackEvent e)
	{
		if (callbackListeners != null)
		{
			Vector listeners = callbackListeners;
			int count = listeners.size();
			for (int i = 0; i < count; i++)
			{
				((CallbackListener) listeners.elementAt(i)).writeComplete(e);
			}
		}
	}


	protected void fireReadComplete(CallbackEvent e)
	{
		if (callbackListeners != null)
		{
			Vector listeners = callbackListeners;
			int count = listeners.size();
			for (int i = 0; i < count; i++)
			{
				((CallbackListener) listeners.elementAt(i)).readComplete(e);
			}
		}
	}


	protected void fireCancelComplete(CallbackEvent e)
	{
		if (callbackListeners != null)
		{
			Vector listeners = callbackListeners;
			int count = listeners.size();
			for (int i = 0; i < count; i++)
			{
				((CallbackListener) listeners.elementAt(i)).cancelComplete(e);
			}
		}
	}*/

}