path: root/plugins/org.eclipse.osee.ote.core/src/org/eclipse/osee/ote/message/Message.java

/*******************************************************************************
 * Copyright (c) 2004, 2007 Boeing.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Boeing - initial API and implementation
 *******************************************************************************/
package org.eclipse.osee.ote.message;

import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Level;

import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;

import org.eclipse.osee.framework.jdk.core.persistence.Xmlizable;
import org.eclipse.osee.framework.jdk.core.persistence.XmlizableStream;
import org.eclipse.osee.framework.jdk.core.util.xml.Jaxp;
import org.eclipse.osee.framework.jdk.core.util.xml.XMLStreamWriterUtil;
import org.eclipse.osee.framework.logging.OseeLog;
import org.eclipse.osee.ote.core.GCHelper;
import org.eclipse.osee.ote.core.MethodFormatter;
import org.eclipse.osee.ote.core.environment.interfaces.ITestEnvironmentAccessor;
import org.eclipse.osee.ote.core.testPoint.CheckPoint;
import org.eclipse.osee.ote.message.condition.ICondition;
import org.eclipse.osee.ote.message.condition.TransmissionCountCondition;
import org.eclipse.osee.ote.message.data.MessageData;
import org.eclipse.osee.ote.message.elements.Element;
import org.eclipse.osee.ote.message.elements.MsgWaitResult;
import org.eclipse.osee.ote.message.elements.RecordElement;
import org.eclipse.osee.ote.message.enums.DataType;
import org.eclipse.osee.ote.message.interfaces.IMessageManager;
import org.eclipse.osee.ote.message.interfaces.IMessageRequestor;
import org.eclipse.osee.ote.message.interfaces.IMessageScheduleChangeListener;
import org.eclipse.osee.ote.message.interfaces.ITestAccessor;
import org.eclipse.osee.ote.message.interfaces.ITestEnvironmentMessageSystemAccessor;
import org.eclipse.osee.ote.message.listener.IOSEEMessageListener;
import org.eclipse.osee.ote.message.listener.MessageSystemListener;
import org.eclipse.osee.ote.message.tool.MessageMode;
import org.w3c.dom.Document;

/**
 * @author Andrew M. Finkbeiner
 */
public abstract class Message<S extends ITestEnvironmentMessageSystemAccessor, T extends MessageData, U extends Message<S, T, U>> implements Xmlizable, XmlizableStream {
   private static volatile AtomicLong constructed = new AtomicLong(0);
   private static volatile AtomicLong finalized = new AtomicLong(0);
   private final HashMap<String, Element> elementMap;
   private final String name;
   private final MessageSystemListener listenerHandler;
   protected final ArrayList<IMessageScheduleChangeListener> schedulingChangeListeners =
      new ArrayList<IMessageScheduleChangeListener>(10);
   private boolean destroyed = false;

   private DataType currentMemType;
   private final Map<DataType, ArrayList<U>> memTypeToMessageMap = new HashMap<DataType, ArrayList<U>>();
   private final Map<DataType, ArrayList<T>> memToDataMap = new HashMap<DataType, ArrayList<T>>();
   private final int phase;
   protected double rate;
   protected final double defaultRate;
   private final boolean isScheduledFromStart;
   private boolean regularUnscheduleCalled = false;
   private boolean isTurnedOff = false;

   private IMessageRequestor messageRequestor = null;
   private static final double doubleTolerance = 0.000001;
   private final Set<DataType> memTypeActive = new HashSet<DataType>();

   private T defaultMessageData;

   private final List<IMemSourceChangeListener> preMemSourceChangeListeners = new ArrayList<IMemSourceChangeListener>();
   private final List<IMemSourceChangeListener> postMemSourceChangeListeners =
      new ArrayList<IMemSourceChangeListener>();
   private final List<IMessageDisposeListener> preMessageDisposeListeners = new ArrayList<IMessageDisposeListener>();
   private final List<IMessageDisposeListener> postMessageDisposeListeners = new ArrayList<IMessageDisposeListener>();

   private final int defaultByteSize;
   private final int defaultOffset;

   protected final MessageSystemListener removableListenerHandler;

   public Message(String name, int defaultByteSize, int defaultOffset, boolean isScheduled, int phase, double rate) {
      constructed.incrementAndGet();
      listenerHandler = new MessageSystemListener(this);
      this.name = name;
      this.defaultByteSize = defaultByteSize;
      this.defaultOffset = defaultOffset;
      elementMap = new LinkedHashMap<String, Element>(20);
      this.phase = phase;
      this.rate = rate;
      this.defaultRate = rate;
      this.isScheduledFromStart = isScheduled;
      GCHelper.getGCHelper().addRefWatch(this);
      this.removableListenerHandler = new MessageSystemListener(this);
   }

   /**
    * Attemps to remove the specified listener from the list of REMOVABLE listeners. This will NOT remove any listener
    * added using the addListener() call, only those added using the addRemovableListener() call will be removed.
    * 
    * @param listener The removable listener to remove
    */
   public void removeRemovableListener(IOSEEMessageListener listener) {
      removableListenerHandler.removeListener(listener);
   }

   /**
    * Adds listener to the list of listeners removed at the end of every script.
    * 
    * @param listener the removable listern to add.
    */
   public void addRemovableListener(IOSEEMessageListener listener) {
      removableListenerHandler.addListener(listener);
   }

   /**
    * Removes all the listeners from the RemovableListenerHandler. This method is meant to be called upon script
    * completion but can be used by anyone. Other listeners can be removed using the traditional removeListener call.
    */
   public void clearRemovableListeners() {
      this.removableListenerHandler.clearListeners();

   }

   public void destroy() {

      notifyPreDestroyListeners();
      destroyed = true;
      defaultMessageData.dispose();

      memToDataMap.clear();
      memTypeToMessageMap.clear();
      listenerHandler.dispose();

      notifyPostDestroyListeners();
      schedulingChangeListeners.clear();
      postMessageDisposeListeners.clear();
      preMessageDisposeListeners.clear();
      postMemSourceChangeListeners.clear();
      preMemSourceChangeListeners.clear();
      elementMap.clear();

      if (messageRequestor != null) {
         messageRequestor.dispose();
      }
      removableListenerHandler.dispose();
   }

   private void notifyPostDestroyListeners() {
      for (IMessageDisposeListener listener : postMessageDisposeListeners) {
         listener.onPostDispose(this);
      }
   }

   private void notifyPreDestroyListeners() {
      for (IMessageDisposeListener listener : preMessageDisposeListeners) {
         try {
            listener.onPreDispose(this);
         } catch (Exception e) {
            OseeLog.log(MessageSystemTestEnvironment.class, Level.SEVERE, "exception during listener notification", e);
         }
      }
   }

   public void setData(byte[] data) {
      checkState();
      if (data == null) {
         throw new IllegalArgumentException("data array cannot be null");
      }
      for (MessageData msgdata : memToDataMap.get(currentMemType)) {
         msgdata.setFromByteArray(data);
      }
   }

   public void setData(ByteBuffer data, int length) {
      checkState();
      if (data == null) {
         throw new IllegalArgumentException("data array cannot be null");
      }
      for (MessageData msgdata : memToDataMap.get(currentMemType)) {
         msgdata.setFromByteArray(data, length);
      }
   }

   public void setData(byte[] data, int length) {
      checkState();
      if (data == null) {
         throw new IllegalArgumentException("data array cannot be null");
      }
      for (MessageData msgdata : memToDataMap.get(currentMemType)) {
         msgdata.setFromByteArray(data, length);
      }
   }

   public void setBackingBuffer(byte[] data) {
      checkState();
      if (data == null) {
         throw new IllegalArgumentException("data array cannot be null");
      }
      for (MessageData msgdata : memToDataMap.get(currentMemType)) {
         msgdata.setNewBackingBuffer(data);
      }
   }

   public byte[] getData() {
      checkState();
      return getActiveDataSource().toByteArray();
   }

   public T getMemoryResource() {
      checkState();
      return memToDataMap.get(currentMemType).get(0);
   }

   /**
    * Returns the number of byte words in the payload of this message.
    * 
    * @return number of bytes in the message payload
    */
   public int getPayloadSize() {
      checkState();
      return memToDataMap.get(currentMemType).get(0).getPayloadSize();
   }

   public int getPayloadSize(DataType type) {
      checkState();
      return memToDataMap.get(type).get(0).getPayloadSize();
   }

   /**
    * Returns the number of byte words in the header of this message.
    * 
    * @return the number of bytes in the header
    */
   public int getHeaderSize() {
      checkState();
      final IMessageHeader hdr = memToDataMap.get(currentMemType).get(0).getMsgHeader();
      if (hdr != null) {
         return hdr.getHeaderSize();
      }
      return 0;
   }

   public int getHeaderSize(DataType type) {
      checkState();
      return memToDataMap.get(type).get(0).getMsgHeader().getHeaderSize();
   }

   /*
    * protected static final ThreadLocal current = new ThreadLocal() { protected Object initialValue() { return new
    * MemMessageHolder(); } };
    */
   public void send() throws MessageSystemException {
      checkState();
      if (!isTurnedOff) {
         ArrayList<T> dataList = memToDataMap.get(currentMemType);
         if (dataList != null) {
        	int listSize = dataList.size();
            for (int i = 0; i < listSize; i++) {
               dataList.get(i).send();
            }
         } else {
            throw new MessageSystemException(
               "Message: " + name + " does not have the  physical type " + currentMemType + " available for this environment!!!!!",
               Level.SEVERE);
         }
      }
   }

   public void addSendListener(IMessageSendListener listener) {
      getActiveDataSource().addSendListener(listener);
   }

   public void removeSendListener(IMessageSendListener listener) {
      getActiveDataSource().removeSendListener(listener);
   }

   public boolean containsSendListener(IMessageSendListener listener) {
      return getActiveDataSource().containsSendListener(listener);
   }

   public void send(DataType type) throws MessageSystemException {
      checkState();
      if (!isTurnedOff) {
         Collection<T> dataList = memToDataMap.get(type);
         if (dataList != null) {

            for (T data : dataList) {
               data.send();
            }

         } else {
            throw new MessageSystemException(
               "Message: " + name + " does not have a physical type available for this environment!!!!!", Level.SEVERE);
         }
      } else {
         OseeLog.log(MessageSystemTestEnvironment.class, Level.WARNING,
            this.getMessageName() + " has attempted a send(), but is currently turned off.");
      }
   }

   //	we may not really need this guy, in fact I think we don't
   //	protected void takeNextSample() {
   //	for (T item : memToDataMap.get(currentMemType)) {
   //	item.takeNextSample();
   //	}
   //	}

   public boolean setMemSource(S accessor, DataType type) {
      return setMemSource(type);
   }

   /**
    * Associates Messages to MemTypes based on the memType's physical availability
    */
   //	public abstract void associateMessages(S accessor);
   /**
    * Changes the element references for this message to a corresponding message with the given MemType. The messages
    * defined for this memType must have been provided by the associateMessages function to be seen.
    * 
    * @param memType the possibly new physical mem type.
    */
   public void switchElementAssociation(DataType memType) {
      checkState();
      switchElementAssociation(getMessageTypeAssociation(memType));
   }

   //   public abstract void switchElementAssociation(Collection<U> messages);

   public void addMessageTypeAssociation(DataType memType, U messageToBeAdded) {
      checkState();
      ArrayList<U> list;
      if (!memTypeToMessageMap.containsKey(memType)) {
         list = new ArrayList<U>(4);
         memTypeToMessageMap.put(memType, list);
      } else {
         list = memTypeToMessageMap.get(memType);
      }
      list.add(messageToBeAdded);

      //		addMessageDataSource(messageToBeAdded.defaultMessageData);
   }

   protected Collection<U> getMessageTypeAssociation(DataType type) {
      final ArrayList<U> list = memTypeToMessageMap.get(type);
      if (list != null) {
         return Collections.unmodifiableCollection(list);
      } else {
         return new ArrayList<U>();
      }
   }

   public void addMessageDataSource(T... dataList) {
      checkState();
      for (T data : dataList) {
         addMessageDataSource(data);
      }
   }

   public void addMessageDataSource(Collection<T> dataList) {
      for (T data : dataList) {
         addMessageDataSource(data);
      }
   }

   protected void addMessageDataSource(T data) {
      final DataType type = data.getType();
      final ArrayList<T> list;
      if (!memToDataMap.containsKey(type)) {
         list = new ArrayList<T>();
         memToDataMap.put(type, list);
      } else {
         list = memToDataMap.get(type);
      }
      list.add(data);
      data.addMessage(this);
   }

   public Collection<T> getMemSource(DataType type) {
      checkState();
      final ArrayList<T> list = memToDataMap.get(type);
      if (list != null) {
         return Collections.unmodifiableCollection(list);
      } else {
         return new ArrayList<T>();
      }
   }

   public boolean getMemSource(DataType type, Collection<T> listToAddto) {
      checkState();
      final ArrayList<T> list = memToDataMap.get(type);
      if (list != null) {
         return listToAddto.addAll(list);
      }
      return false;
   }

   public DataType getMemType() {
      return currentMemType;
   }

   public void addElement(Element element) {
      checkState();
      elementMap.put(element.getName(), element);
   }

   /**
    * Gets a list of all the message's data elements
    * 
    * @return a collection of {@link Element}s
    */
   public Collection<Element> getElements() {
      checkState();
      return elementMap.values();
   }

   public void getAllElements(Collection<Element> elements) {
      checkState();
      IMessageHeader header = getActiveDataSource().getMsgHeader();
      if (header != null) {
         Collections.addAll(elements, header.getElements());
      }
      elements.addAll(elementMap.values());

   }

   public Collection<Element> getElements(DataType type) {
      checkState();
      LinkedList<Element> list = new LinkedList<Element>();
      for (Element element : elementMap.values()) {
         Element e = element.switchMessages(getMessageTypeAssociation(type));
         if (!e.isNonMappingElement()) {
            list.add(e);
         }
      }
      return list;
   }

   /**
    * @return true if the Message contains an element with the given name, false otherwise
    */
   public boolean hasElement(String elementName) {
      checkState();
      return elementMap.containsKey(elementName);
   }

   /**
    * @return HashMap<String, Element>
    */
   public HashMap<String, Element> getElementMap() {
      checkState();
      return elementMap;
   }

   /**
    * @param elementName the name of the element as defined in the message ( All caps ).
    * @return the element associated with the given name
    * @throws IllegalArgumentException if an element doesn't exist with given name. Use {@link #hasElement(String)} with
    * any use of this function.
    */
   public Element getElement(String elementName) {
      return getElement(elementName, currentMemType);
   }

   public <E extends Element> E getElement(String elementName, Class<E> clazz) {
      checkState();
      return clazz.cast(getElement(elementName, currentMemType));
   }

   public boolean hasElement(List<Object> elementPath) {
      return getElement(elementPath) != null;
   }

   public Element getElement(List<Object> elementPath) {
      checkState();
      Element el = null;
      RecordElement rel = null;
      if (elementPath.size() == 1) {
         el = elementMap.get(elementPath.get(0));
      } else {
         String string = (String) elementPath.get(1);
         if (string.startsWith("HEADER(")) {
            Element[] elements = getActiveDataSource(currentMemType).getMsgHeader().getElements();
            for (Element element : elements) {
               if (element.getName().equals(elementPath.get(2))) {
                  return element;
               }
            }
            return null;
         } else {
            el = this.elementMap.get(string);
            if (el instanceof RecordElement) {
               rel = (RecordElement) el;
            }
         }
         for (int i = 2; i < elementPath.size(); i++) {
            if (elementPath.get(i) instanceof String) {
               String name = (String) elementPath.get(i);
               el = rel.getElementMap().get(name);
               if (el instanceof RecordElement) {
                  rel = (RecordElement) el;
               }
            } else if (elementPath.get(i) instanceof Integer) {
               Integer index = (Integer) elementPath.get(i);
               rel = rel.get(index);
               el = rel;
            }
         }
      }
      return el;
   }

   public Element getElement(List<Object> elementPath, DataType type) {
	  Element element = getElement(elementPath);
	  if (element == null) {
		  return null;
	  }
      return element.switchMessages(this.getMessageTypeAssociation(type));
   }

   /**
    * @return the element associated with the given name
    * @throws IllegalArgumentException if an element doesn't exist with given name. Use {@link #hasElement(String)} with
    * any use of this function.
    */
   public Element getElement(String elementName, DataType type) {
      checkState();
      Element retVal = elementMap.get(elementName);
      if (retVal != null) {
         return retVal.switchMessages(this.getMessageTypeAssociation(type));
      }
      return null;

   }

   public Element getBodyOrHeaderElement(String elementName) {
      return getBodyOrHeaderElement(elementName, currentMemType);
   }

   public Element getBodyOrHeaderElement(String elementName, DataType type) {
      checkState();
      Element e = elementMap.get(elementName);
      if (e == null) {
         Element[] elements = getActiveDataSource(type).getMsgHeader().getElements();
         for (Element element : elements) {
            if (element.getName().equals(elementName)) {
               return element;
            }
         }
      } else {
         e = e.switchMessages(this.getMessageTypeAssociation(type));
      }
      return e;
   }

   /**
    * Turning off a message causes sends to be short-circuited and the message to be unscheduled.
    */
   public void turnOff() {
      checkState();
      isTurnedOff = true;
      unschedule();
   }

   /**
    * Turning on message allows sends to work again & reschedules message if that is the default state defined by the
    * message constructor call.
    */
   public void turnOn() {
      checkState();
      isTurnedOff = false;
      if (isScheduledFromStart()) {
         schedule();
      }
   }

   /**
    * This is the turnOn being called from the method register in MessageCollection. Messages shouldn't be scheduled at
    * this point b/c the control message hasn't gone out yet. Messages can't go out until the control message goes out
    * the first time so that collisions in the box are avoided.
    */
   public void whenBeingRegisteredTurnOn() {
      isTurnedOff = false;
   }

   /**
    * Returns if the message is turned off.
    */
   public boolean isTurnedOff() {
      return isTurnedOff;
   }

   private void setSchedule(boolean newValue) {
      ArrayList<T> dataList = memToDataMap.get(currentMemType);
      for (T d : dataList) {
         d.setScheduled(newValue);
      }
   }

   /**
    * This method schedules the message. There is also some code that allows the scheduled state to be updated in
    * Message Watch.
    */
   public void schedule() {
      checkState();
      if (!isTurnedOff) {
         setSchedule(true);
         regularUnscheduleCalled = false;
         for (IMessageScheduleChangeListener listener : schedulingChangeListeners) {
            listener.isScheduledChanged(true);
         }
      }
   }

   /**
    * This method unschedules the message. The variable regularUnscheduledCalled is used to preserve unschedules that
    * are called in constructors, which is before the control message goes out for the first time.
    */
   public void unschedule() {
      checkState();
      setSchedule(false);
      regularUnscheduleCalled = true;
      for (IMessageScheduleChangeListener listener : schedulingChangeListeners) {
         listener.isScheduledChanged(false);
      }
   }

   /**
    * Returns if the message is scheduled or not.
    */
   @Deprecated
   public boolean isScheduled() {
      ArrayList<T> dataList = memToDataMap.get(currentMemType);
      for (T d : dataList) {
         if (!d.isScheduled()) {
            return false;
         }
      }
      return true;
   }

   /**
    * This is called at the end of a script run to reset the "hard" unschedule variable that is used to preserve
    * unschedules called in constructors.
    */
   public void resetScheduling() {
      regularUnscheduleCalled = false;

   }

   /**
    * @return - double - rate of message
    */
   public double getRate() {
      return rate;
   }

   /**
    * @return - int - phase of message
    */
   public int getPhase() {
      return phase;
   }

   public MessageSystemListener getListener() {
      return listenerHandler;
   }

   public MessageSystemListener getRemoveableListener() {
      return removableListenerHandler;
   }

   public void addListener(IOSEEMessageListener listener) {
      listenerHandler.addListener(listener);
   }

   public boolean removeListener(IOSEEMessageListener listener) {
      return listenerHandler.removeListener(listener);
   }

   /**
    * Notifies all registered listeners of an update.
    * <P>
    * <B>NOTE: </B>Should only be called from sub classes of {@link MessageData}
    * 
    * @param data the Message Data object that has been updated
    * @param type the memtype of the message data object
    */
   public void notifyListeners(final MessageData data, final DataType type) {
      checkState();
      this.listenerHandler.onDataAvailable(data, type);
      this.removableListenerHandler.onDataAvailable(data, type);
   }

   /*
    * public HashMap getTypeToMessageData(){ return typeToMessageData; }
    */
   /**
    * @return Returns the name.
    */
   public String getName() {
      return name;
   }

   private static final int TransmissionTimeoutDefault = 15000;

   @Override
   public String toString() {
      return name;
   }

   /**
    * @return Returns the messageName.
    */
   public String getMessageName() {
      return name;
   }

   @Override
   public org.w3c.dom.Element toXml(Document doc) {
      org.w3c.dom.Element rootElement = doc.createElement("Message");
      rootElement.appendChild(Jaxp.createElement(doc, "Name", name));
      rootElement.appendChild(Jaxp.createElement(doc, "Type", getMemType().name()));
      return rootElement;
   }

   @Override
   public void toXml(XMLStreamWriter writer) throws XMLStreamException {
      writer.writeStartElement("Message");
      XMLStreamWriterUtil.writeElement(writer, "Name", name);
      XMLStreamWriterUtil.writeElement(writer, "Type", getMemType().name());
      writer.writeEndElement();
   }

   public void zeroize() {
      checkState();
      for (DataType memType : memToDataMap.keySet()) {
         for (Element el : getElements(memType)) {
            el.zeroize();
         }
      }
      //		for (ArrayList<T> list : memToDataMap.values()) {
      //		for (T md : list) {
      //		md.zeroize();
      //		}
      //		}
   }

   /**
    * Verifies that the message is sent at least once using the default message timeout.
    * 
    * @return if the check passed
    */
   public final boolean checkForTransmission(ITestAccessor accessor) throws InterruptedException {
      return checkForTransmission(accessor, TransmissionTimeoutDefault);
   }

   /**
    * Verifies that the message is sent at least once within the time specified.
    * 
    * @param milliseconds the amount to time (in milliseconds) to allow
    * @return if the check passed
    */
   public final boolean checkForTransmission(ITestAccessor accessor, int milliseconds) throws InterruptedException {
      return checkForTransmissions(accessor, 1, milliseconds);
   }

   /**
    * Verifies that the message is sent at least "numTransmission" times within the default message timeout.
    * 
    * @param numTransmissions the number of transmissions to look for
    * @return if the check passed
    */
   public final boolean checkForTransmissions(ITestAccessor accessor, int numTransmissions) throws InterruptedException {
      return checkForTransmissions(accessor, numTransmissions, TransmissionTimeoutDefault);
   }

   /**
    * Verifies that the message is sent at least "numTransmission" times within the time specified.
    * 
    * @param numTransmissions the number of transmission to look for
    * @param milliseconds the amount to time (in milliseconds) to allow
    * @return if the check passed
    */
   public boolean checkForTransmissions(ITestAccessor accessor, int numTransmissions, int milliseconds) throws InterruptedException {
      checkState();
      accessor.getLogger().methodCalledOnObject(accessor, getMessageName(),
         new MethodFormatter().add(numTransmissions).add(milliseconds));
      TransmissionCountCondition c = new TransmissionCountCondition(numTransmissions);
      MsgWaitResult result = waitForCondition(accessor, c, false, milliseconds);
      CheckPoint passFail =
         new CheckPoint(this.name, Integer.toString(numTransmissions), Integer.toString(result.getXmitCount()),
            result.isPassed(), result.getXmitCount(), result.getElapsedTime());
      accessor.getLogger().testpoint(accessor, accessor.getTestScript(), accessor.getTestCase(), passFail);
      accessor.getLogger().methodEnded(accessor);
      return passFail.isPass();
   }

   /**
    * Verifies that the message is not sent within the time specified.
    * 
    * @param milliseconds the amount to time (in milliseconds) to check
    * @return if the check passed
    */
   public boolean checkForNoTransmissions(ITestEnvironmentMessageSystemAccessor accessor, int milliseconds) throws InterruptedException {
      checkState();
      if (accessor == null) {
         throw new IllegalArgumentException("accessor cannot be null");
      }
      accessor.getLogger().methodCalledOnObject(accessor, getMessageName(), new MethodFormatter().add(milliseconds),
         this);
      long time = accessor.getEnvTime();
      org.eclipse.osee.ote.core.environment.interfaces.ICancelTimer cancelTimer =
         accessor.setTimerFor(listenerHandler, milliseconds);

      boolean result;
      listenerHandler.waitForData(); // will also return if the timer (set above)
      // expires

      result = listenerHandler.isTimedOut();

      cancelTimer.cancelTimer();
      time = accessor.getEnvTime() - time;

      accessor.getLogger().testpoint(
         accessor,
         accessor.getTestScript(),
         accessor.getTestScript().getTestCase(),
         new CheckPoint(this.getMessageName(), "No Transmissions",
            result ? "No Transmissions" : "Transmissions Occurred", result, time));
      if (accessor != null) {
         accessor.getLogger().methodEnded(accessor);
      }
      return result;
   }

   /**
    * Waits until message is sent at least once within the default message timeout.
    * 
    * @return if the check passed
    */
   public boolean waitForTransmission(ITestEnvironmentMessageSystemAccessor accessor) throws InterruptedException {
      return waitForTransmission(accessor, TransmissionTimeoutDefault);
   }

   /**
    * Waits until message is sent at least once within the time specified.
    * 
    * @param milliseconds the amount to time (in milliseconds) to allow
    * @return if the check passed
    */
   public boolean waitForTransmission(ITestEnvironmentMessageSystemAccessor accessor, int milliseconds) throws InterruptedException {
      return waitForTransmissions(accessor, 1, milliseconds);
   }

   /**
    * Waits until message is sent at least "numTransmission" times within the default message timeout.
    * 
    * @param numTransmissions the number of transmissions to look for
    * @return if the check passed
    */
   public boolean waitForTransmissions(ITestEnvironmentMessageSystemAccessor accessor, int numTransmissions) throws InterruptedException {
      return waitForTransmissions(accessor, numTransmissions, TransmissionTimeoutDefault);
   }

   /**
    * Waits until message is sent at least "numTransmission" times within the time specified.
    * 
    * @param milliseconds the amount to time (in milliseconds) to allow
    * @return if the check passed
    */
   public boolean waitForTransmissions(ITestEnvironmentMessageSystemAccessor accessor, int numTransmissions, int milliseconds) throws InterruptedException {
      checkState();
      accessor.getLogger().methodCalledOnObject(accessor, getMessageName(),
         new MethodFormatter().add(numTransmissions).add(milliseconds), this);
      boolean pass = waitForTransmissionsNoLog(accessor, numTransmissions, milliseconds);
      accessor.getLogger().methodEnded(accessor);
      return pass;
   }

   public boolean waitForTransmissionsNoLog(ITestEnvironmentMessageSystemAccessor accessor, int numTransmissions, int milliseconds) throws InterruptedException {
      checkState();
      if (accessor == null) {
         throw new IllegalArgumentException("environment accessor parameter cannot be null");
      }
      TransmissionCountCondition c = new TransmissionCountCondition(numTransmissions);
      MsgWaitResult result = waitForCondition(accessor, c, false, milliseconds);
      return result.isPassed();
   }

   public MsgWaitResult waitForCondition(ITestEnvironmentAccessor accessor, ICondition condition, boolean maintain, int milliseconds) throws InterruptedException {
      checkState();
      return listenerHandler.waitForCondition(accessor, condition, maintain, milliseconds);
   }

   /**
    * @return Returns size value.
    */
   public int getMaxDataSize() {
      checkState();
      return getMaxDataSize(currentMemType);
   }

   public int getMaxDataSize(DataType type) {
      checkState();
      int size = 0;
      for (MessageData msgData : memToDataMap.get(type)) {
         if (msgData != null && msgData.getPayloadSize() > size) {
            size = msgData.getPayloadSize();
         }
      }
      return size;
   }

   /*
    * @Override public boolean equals(Object obj) { return this.getClass().equals(obj.getClass()); }
    */

   /*
    * @Override public int hashCode() { return getClass().hashCode(); }
    */

   /**
    * returns a {@link MessageState} object that represents this message's state. The state is intended to be used in
    * synchronizing a remote instance of this message
    * 
    * @return Returns MessageState object reference.
    */
   public MessageState getMessageState() {
      checkState();
      MessageMode mode = isWriter() ? MessageMode.WRITER : MessageMode.READER;
      return new MessageState(currentMemType, getData(), memToDataMap.keySet(), mode);
   }

   /**
    * restores the state of this message. The state is intended to come from a remote instance of this message.
    */
   public void setMessageState(final MessageState state) {
      checkState();
      setMemSource(state.getCurrentMemType());
      setData(state.getData());
   }

   public void addSchedulingChangeListener(IMessageScheduleChangeListener listener) {
      checkState();
      schedulingChangeListeners.add(listener);
   }

   public void removeSchedulingChangeListener(IMessageScheduleChangeListener listener) {
      checkState();
      schedulingChangeListeners.remove(listener);
   }

   public T getActiveDataSource() {
      checkState();
      ArrayList<T> dataList = memToDataMap.get(currentMemType);
      if (dataList == null) {
         throw new IllegalStateException("no datas for " + currentMemType);
      }
      return dataList.get(0);
   }

   public T getActiveDataSource(DataType type) {
      checkState();
      ArrayList<T> dataList = memToDataMap.get(type);
      return dataList != null ? dataList.get(0) : null;
   }

   public void addElements(Element... elements) {
      checkState();
      for (Element element : elements) {
         elementMap.put(element.getElementName(), element);
         element.addPath(this.getClass().getName());
      }
   }

   public int getBitOffset() {
      return 0;
   }

   /**
    * @param currentMemType the currentMemType to set
    */
   protected void setCurrentMemType(DataType currentMemType) {
      checkState();
      this.currentMemType = currentMemType;
   }

   public boolean setMemSource(DataType type) {
      checkState();
      DataType oldMemType = getMemType();
      notifyPreMemSourceChangeListeners(oldMemType, type, this);
      this.switchElementAssociation(type);
      setCurrentMemType(type);
      notifyPostMemSourceChangeListeners(oldMemType, type, this);
      return true;
   }

   public boolean activateMemSource(DataType type) {
      checkState();
      DataType oldMemType = getMemType();
      notifyPreMemSourceChangeListeners(oldMemType, type, this);
      //		this.switchElementAssociation(type);
      //		setCurrentMemType(type);
      notifyPostMemSourceChangeListeners(oldMemType, type, this);
      return true;
   }

   private void notifyPostMemSourceChangeListeners(DataType old, DataType newtype, Message<?, ?, ?> message) {
      checkState();
      for (IMemSourceChangeListener listener : postMemSourceChangeListeners) {
         try {
            listener.onChange(old, newtype, message);
         } catch (Exception e) {
            OseeLog.log(MessageSystemTestEnvironment.class, Level.SEVERE, e);
         }
      }
   }

   private void notifyPreMemSourceChangeListeners(DataType old, DataType newtype, Message<?, ?, ?> message) {
      checkState();
      for (IMemSourceChangeListener listener : preMemSourceChangeListeners) {
         listener.onChange(old, newtype, message);
      }
   }

   public void addPreMemSourceChangeListener(IMemSourceChangeListener listener) {
      checkState();
      preMemSourceChangeListeners.add(listener);
   }

   public void addPostMemSourceChangeListener(IMemSourceChangeListener listener) {
      checkState();
      postMemSourceChangeListeners.add(listener);
   }

   public void addPreMessageDisposeListener(IMessageDisposeListener listener) {
      checkState();
      preMessageDisposeListeners.add(listener);
   }

   public void removePreMessageDisposeListener(IMessageDisposeListener listener) {
      checkState();
      preMessageDisposeListeners.remove(listener);
   }

   public void addPostMessageDisposeListener(IMessageDisposeListener listener) {
      checkState();
      postMessageDisposeListeners.add(listener);
   }

   /**
    * @return the memToDataMap
    */
   public Collection<ArrayList<T>> getAllData() {
      checkState();
      return memToDataMap.values();
   }

   public Set<DataType> getAvailableMemTypes() {
      checkState();
      return memToDataMap.keySet();
   }

   public Collection<T> getMessageData(DataType type) {
      checkState();
      return memToDataMap.get(type);
   }

   public String getTypeName() {
      return getName();
   }

   /**
    * This variable reflects whether a message is defined to start out being scheduled.
    * 
    * @return Returns the isScheduledFromStart.
    */
   public boolean isScheduledFromStart() {
      return isScheduledFromStart;
   }

   /**
    * This variable reflects whether unsubscribe has been called on the message. The main purpose of this is to preserve
    * if an unschedule is called on a message from a constructor.
    * 
    * @return Returns the regularUnscheduleCalled.
    */
   public boolean isRegularUnscheduleCalled() {
      return regularUnscheduleCalled;
   }

   /**
    * @return the defaultMessageData
    */
   public T getDefaultMessageData() {
      checkState();
      return defaultMessageData;
   }

   /**
    * @param defaultMessageData the defaultMessageData to set
    */
   protected void setDefaultMessageData(T defaultMessageData) {
      checkState();
      this.defaultMessageData = defaultMessageData;
      addMessageDataSource(defaultMessageData);
      addMessageTypeAssociation(defaultMessageData.getType(), (U) this);
   }

   public boolean isWriter() {
      checkState();
      return defaultMessageData.isWriter();
   }

   public void setMemTypeActive(DataType type) {
      checkState();
      memTypeActive.add(type);
      notifyPostMemSourceChangeListeners(currentMemType, currentMemType, this);
   }

   public void setMemTypeInactive(DataType type) {
      checkState();
      memTypeActive.add(type);
      notifyPostMemSourceChangeListeners(currentMemType, currentMemType, this);
   }

   public boolean isMemTypeActive(DataType type) {
      checkState();
      return memTypeActive.contains(type);
   }

   protected void checkState() throws IllegalStateException {
      if (isDestroyed()) {
         throw new IllegalStateException(getName() + " is destroyed");
      }
   }

   public boolean isDestroyed() {
      return destroyed;
   }

   @Override
   protected void finalize() throws Throwable {
      finalized.incrementAndGet();
      super.finalize();
   }

   public static long getConstructed() {
      return constructed.get();
   }

   public static long getFinalized() {
      return finalized.get();
   }

   public boolean isValidElement(Element currentElement, Element proposedElement) {
      return true;
   }

   public IMessageHeader[] getHeaders() {
      final Collection<T> dataSources = getMemSource(getMemType());
      if (dataSources.size() > 0) {
         final IMessageHeader[] headers = new IMessageHeader[dataSources.size()];
         int i = 0;
         for (T dataSrc : dataSources) {
            headers[i] = dataSrc.getMsgHeader();
            i++;
         }
         return headers;
      } else {
         return new IMessageHeader[0];
      }
   }

   public long getActivityCount() {
      return getActiveDataSource().getActivityCount();
   }

   public long getSentCount() {
      return getActiveDataSource().getSentCount();
   }

   public void setActivityCount(long activityCount) {
      getActiveDataSource().setActivityCount(activityCount);
   }

   public void switchElementAssociation(Collection<U> messages) {
   }

   public Map<? extends DataType, Class<? extends Message>[]> getAssociatedMessages() {
      return new HashMap<DataType, Class<? extends Message>[]>();
   }

   public void postCreateMessageSetup(IMessageManager messageManager, MessageData data) throws Exception {
      Map<? extends DataType, Class<? extends Message>[]> o = getAssociatedMessages();
      messageRequestor = messageManager.createMessageRequestor(getName());
      for (Entry<? extends DataType, Class<? extends Message>[]> entry : o.entrySet()) {
         if (messageManager.isPhysicalTypeAvailable(entry.getKey())) {
            for (Class<? extends Message> clazz : entry.getValue()) {
               final Message message;
               if (data.isWriter()) {
                  message = messageRequestor.getMessageWriter(clazz);
               } else {
                  message = messageRequestor.getMessageReader(clazz);
               }
               this.addMessageDataSource((T) message.getDefaultMessageData());
               this.addMessageTypeAssociation(entry.getKey(), (U) message);
               setMemSource(entry.getKey());
            }
         }
      }
   }

   /**
    * Changes the rate a message is being published at. NOTE: This is only going to be allowed to be used on periodic
    * message & users are not allowed to set rate to zero.
    * 
    * @param newRate - hz
    */
   public void changeRate(double newRate) {
      if (Math.abs(newRate - 0.0) < doubleTolerance) { //newRate == 0.0
         throw new IllegalArgumentException(
            "Cannot change message rate to zero (" + getName() + ")!\n\tUse unschedule() to do that!");
      }
      if (Math.abs(newRate - rate) > doubleTolerance) { //newRate != rate
         //         accessor.getMsgManager().changeMessageRate(this, newRate, rate);
         double oldRate = rate;
         rate = newRate;
         for (IMessageScheduleChangeListener listener : schedulingChangeListeners) {
            listener.onRateChanged(this, oldRate, newRate);
         }
      }
   }

   /**
    * Changes the rate back to the default rate.
    */
   public void changeRateToDefault(ITestEnvironmentMessageSystemAccessor accessor) {
      //      accessor.getMsgManager().changeMessageRate(this, defaultRate, rate);
      double oldRate = getRate();
      rate = defaultRate;
      for (IMessageScheduleChangeListener listener : schedulingChangeListeners) {
         listener.onRateChanged(this, oldRate, defaultRate);
      }
   }

   public void sendWithLog(ITestAccessor accessor) {
      if (accessor != null) {
         accessor.getLogger().methodCalledOnObject(accessor, getMessageName(), new MethodFormatter(), this);
      }
      send();
      if (accessor != null) {
         accessor.getLogger().methodEnded(accessor);
      }
   }

   public int getDefaultByteSize() {
      return defaultByteSize;
   }

   public int getDefaultOffset() {
      return defaultOffset;
   }

   public Element getElementByPath(ElementPath path) {
      return getElementByPath(path, currentMemType);
   }

   public Element getElementByPath(ElementPath path, DataType type) {
      if (path.isHeaderElement()) {
         Element[] elements = getActiveDataSource(type).getMsgHeader().getElements();
         for (Element element : elements) {
            if (element.getName().equals(path.getElementName())) {
               return element;
            }
         }
         return null;
      }
      return getElement(path.getList(), type);
   }
}