java-org.hwo.servicelink/src/org/hwo/ui/servicelink/register/ServiceRegister.java

package org.hwo.ui.servicelink.register;

import java.awt.Component;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;

import javax.swing.JComponent;

import org.hwo.i18n.Messages;
import org.hwo.interactiveobjects.InteractiveObject;
import org.hwo.servicelink.ServiceLink;
import org.hwo.servicelink.ServiceLink.ServiceTelegram;
import org.hwo.servicelink.ServiceLinkException;
import org.hwo.servicelink.ServiceLinkRequestFailedException;
import org.hwo.servicelink.ServiceRegisterListener;
import org.hwo.models.TableMapper.TableColumn;
import org.hwo.ui.servicelink.register.bitfield.BitFieldEditor;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

@InteractiveObject(editor=ServiceRegisterEditorDialog.class)
public abstract class ServiceRegister implements ServiceRegisterListener {
	
	static HashMap<String, Class<? extends ServiceRegister>> serviceRegisterTypes;
	public static void addServiceRegisterType(String typename,Class<? extends ServiceRegister> clazz)
	{
		serviceRegisterTypes.put(typename, clazz);
	}	
	
	public static ServiceRegister createServiceRegister(ServiceLink serviceLink,String typeName)
	{
		ServiceRegister sr = null;
		
		Class<? extends ServiceRegister> clazz = serviceRegisterTypes.get(typeName);
		if (clazz != null)
		{
			try {
				sr = clazz.getDeclaredConstructor(ServiceLink.class).newInstance(serviceLink);
			} catch (InstantiationException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				e.printStackTrace();
			} catch (NoSuchMethodException e) {
				e.printStackTrace();
			}
		}
		return sr;
	}
	public static ServiceRegister createServiceRegister(ServiceLink serviceLink,Element registerNode)
	{
		ServiceRegister sr = null;
		String registerType = registerNode.getAttribute("type");
		
		if (registerType == null || registerType.equals(""))
			registerType = "Integer";
		
		sr = createServiceRegister(serviceLink, registerType);
		if (sr != null)
		{
			sr.setRegisterNode(registerNode);
		}
		return sr;
	}
		
	private Element		registerNode;
	
	private ServiceLink serviceLink;
	private Integer		ax,
						node,
						register;
	
	private boolean		asFloat;
	
	private	String		registerType;
	private String		registerName;
	
	protected Integer	lastAsyncIntValue;
	protected Float		lastAsyncFloatValue;
	
	private ServiceRegisterControl
						serviceRegisterControl;
	
	public ServiceRegister(ServiceLink serviceLink,boolean asFloat)
	{
		this.serviceLink = serviceLink;
		this.asFloat = asFloat;
	}
	
	public void dispose(){
		removeServiceRegisterListener();
	}
	
	private void removeServiceRegisterListener(){
		if ((this.serviceLink != null)&&(ax != null)&&(node != null)&&(register != null))
			this.serviceLink.getAsynchronServiceLinkProvider().removeServiceRegisterListener(this.ax, this.node, this.register, this.asFloat, this);		
	}
	private void addServiceRegisterListener(){
		if ((this.serviceLink != null) &&(ax != null)&&(node != null)&&(register != null))
			this.serviceLink.getAsynchronServiceLinkProvider().addServiceRegisterListener(this.ax, this.node, this.register, this.asFloat, this);
	}
	
	
	@TableColumn(label="Bezeichnung",after="Register",width=400)
	public String getRegisterName() {
		return registerName;
	}
	public void setRegisterName(String registerName) {
		this.registerName = registerName;
	}
	
	@TableColumn(label="Register",firstColumn=true,width=80)
	public Integer getRegister() {
		return register;
	}
	public void setRegister(Integer register) {
		removeServiceRegisterListener();
		this.register = register;
		addServiceRegisterListener();
	}
	
	@TableColumn(label="Wert",after="Bezeichnung",width=250)
	abstract public String getTextRepresentation();

	abstract public JComponent	getEditorComponent();
	abstract public void		acceptEditorValue();
	abstract public void		updateEditorValue();
	
	public Element getRegisterNode()
	{
		return registerNode;
	};
	public void setRegisterNode(Element registerNode)
	{
		this.registerNode = registerNode;
		
		if (this.registerNode != null)
		{
			Element labelNode	= (Element)this.registerNode.getElementsByTagName("Label").item(0);
			Element addressNode	= (Element)this.registerNode.getElementsByTagName("Address").item(0);
			
			register		= Integer.decode(addressNode.getTextContent());
			registerName	= Messages.getString(labelNode.getTextContent());
		}
		
	}
	
	public void setAsFloat(boolean asFloat) {
		removeServiceRegisterListener();
		this.asFloat = asFloat;
		addServiceRegisterListener();
	}
	public boolean getAsFloat() {
		return this.asFloat;
	}
	
	
	public ServiceLink getServiceLink() {
		return serviceLink;
	}
	public void setServiceLink(ServiceLink serviceLink) {
		this.serviceLink = serviceLink;
	}


	public Integer getAx() {
		return ax;
	}
	public void setAx(Integer ax) {
		removeServiceRegisterListener();
		this.ax = ax;
		addServiceRegisterListener();
	}


	public Integer getNode() {
		return node;
	}
	public void setNode(Integer node) {
		removeServiceRegisterListener();
		this.node = node;
		addServiceRegisterListener();
	}
	
	public Float readFloatValue()
	{
		if (lastAsyncFloatValue != null)
			return lastAsyncFloatValue;
		return 0.0f;
		//return serviceLink.getServiceRegisterCache().getCachedFloat(ax, node, register);
	}
	public void writeFloatValue(Float value)
	{
		try
		{
			this.serviceLink.writeFloat(ax.byteValue(), node.byteValue(), register,value);
		} catch (Exception e)
		{
			e.printStackTrace();
		}
	}

	public Float readFloatValueSynchron()
	{
		try {
			return serviceLink.readFloat(ax.byteValue(), node.byteValue(), register);
		} catch (ServiceLinkRequestFailedException e) {
		} catch (IOException e) {
		} catch (ServiceLinkException e) {
		}
		return null;
	}
	
	
	public Integer readIntegerValue()
	{
		if (lastAsyncIntValue != null)
			return lastAsyncIntValue;
		return 0;
		//return serviceLink.getServiceRegisterCache().getCachedInteger(ax, node, register);
	}
	public void writeIntegerValue(Integer value)
	{
		try
		{
			this.serviceLink.writeInt(ax.byteValue(), node.byteValue(), register,value);
		} catch (Exception e)
		{
			e.printStackTrace();
		}
	}
	
	@Override
	public void ServiceRegisterValueUpdated(int ax, int node,
			int registervalue, Float value) {
		this.lastAsyncFloatValue = value;
	}
	@Override
	public void ServiceRegisterValueUpdated(int ax, int node,
			int registervalue, Integer value) {
		this.lastAsyncIntValue = value;
	}	
	

	static {
		serviceRegisterTypes = new HashMap<String, Class<? extends ServiceRegister>>();
		
		serviceRegisterTypes.put("Integer", IntegerServiceRegister.class);
		serviceRegisterTypes.put("Float", FloatServiceRegister.class);
		serviceRegisterTypes.put("BitField", BitFieldServiceRegister.class);
		serviceRegisterTypes.put("IndexedList", IndexedListServiceRegister.class);
	}
	
}