ContainerStructure.java

Go to the documentation of this file.

// -----------------------------------------------------------------------
// MLPI - <System.java>
// -----------------------------------------------------------------------
// Copyright (c) 2012 Bosch Rexroth. All rights reserved.
// Redistribution and use in source and binary forms of this MLPI software
// (SW) provided to you, with or without modification, are permitted
// without prior approval provided that the following conditions are met:
//
// 1. Redistributions of source code of SW must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form of SW must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. User recognizes and acknowledges that it acquires no right,
// title or interest in or to any of the names or trademarks used in
// connection with the SW ("names") by virtue of this License and waives
// any right to or interest in the names. User recognizes and acknowledges
// that names of companies or names or products of companies displayed
// in the documentation of SW to indicate the interoperability of products
// with the SW are the names of their respective owners. The use of such
// names in the documentation of SW does not imply any sponsorship,
// approval, or endorsement by such companies of this product.
//
// 4. Modified code versions, i.e. any addition to or deletion from
// the substance or structure of the original code of the SW running
// the MLPI must be plainly marked as such and must not be misrepresented
// as being original SW.
//
// 5. The SW may only be used in connection with a Bosch Rexroth product.
//
// THIS INFORMATION IS PROVIDED BY BOSCH REXROTH CORPORATION "AS IS"
// AND WITHOUT WARRANTY OF ANY KIND, EXPRESSED OR IMPLIED, INCLUDING
// (BUT NOTLIMITED TO) ANY IMPLIED WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR ANY PARTICULAR PURPOSE, OR NON-INFRINGEMENT. WHILE THE
// INFORMATION PROVIDED IS BELIEVED TO BE ACCURATE, IT MAY INCLUDE
// ERRORS OR INACCURACIES.
// SUBJECT TO COMPULSORY STATUTORY PROVISIONS OF THE GERMAN LAW AS
// THE APPLICABLE LAW FOR THIS LICENSE BOSCH REXROTH CORPORATION WILL
// NOT BE LIABLE FOR ANY DAMAGES OF ANY KIND ARISING FROM THE USE OF
// THE  SOFTWARE  DISTRIBUTED HEREUNDER, INCLUDING BUT NOT LIMITED TO
// DIRECT, INDIRECT, INCIDENTAL, PUNITIVE, AND CONSEQUENTIAL DAMAGES.
// -----------------------------------------------------------------------
//
//
// -----------------------------------------------------------------------
package com.boschrexroth.mlpi;

import java.io.UnsupportedEncodingException;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.CharBuffer;
import java.nio.ShortBuffer;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.StringTokenizer;

import com.boschrexroth.mlpi.Container.ContainerAccess;
import com.boschrexroth.mlpi.Container.ContainerHandle;
import com.boschrexroth.mlpi.Container.ContainerItemInformation;


public class ContainerStructure {
  /*
   * Constants
   */
  private final static BigInteger   ULLONG_MAX_VALUE = new BigInteger("18446744073709551615");
  private final static long         ULONG_MAX_VALUE = 4294967295L;
  private final static int          USHORT_MAX_VALUE = 65535;
  private final static short        UCHAR_MAX_VALUE = 255;

  private final static BigInteger   ULLONG_MIN_VALUE = BigInteger.ZERO;
  private final static long         ULONG_MIN_VALUE = 0L;
  private final static int          USHORT_MIN_VALUE = 0;
  private final static short        UCHAR_MIN_VALUE = 0;
  /*
   * Enums
   */

  /*
   * Structs
   */

  /*
   * Fields
   */
  private final Container _container;
  private final String _name;
  private final ContainerAccess _accessFlag;
  private List<String> _tagList = new LinkedList<String>();
  private ContainerItemInformation[] _itemInfosArray;
  private HashMap<String, ContainerItemInformation> _itemInfosMap = new HashMap<String, Container.ContainerItemInformation>();
  private boolean _isDirty = true;
  private ContainerHandle _containerHandle = new ContainerHandle();
  private byte[] _data = new byte[1];
  private ByteBuffer _buffer;

  /*
   * Methods
   */
  ContainerStructure(Container container, String name, ContainerAccess accessFlag) {
    _name = name;
    _container = container;
    _accessFlag = accessFlag;
  }

  public void finalize() {
    destroy();
  }

  public String getName() {
    return _name;
  }

  public void clear() {
    _tagList.clear();
    _itemInfosMap.clear();
    _isDirty = true;
  }

  public void add(String tags) {
    StringTokenizer tokenizer = new StringTokenizer(tags, ";");

    while (tokenizer.hasMoreTokens()) {
      _tagList.add(tokenizer.nextToken());
      _isDirty = true;
    }
  }

  public void add(String[] tags) {
    for (String tag : tags) {
      add(tag);
    }
  }

  public void remove(String tags) {
    StringTokenizer tokenizer = new StringTokenizer(tags, ";");

    while (tokenizer.hasMoreTokens()) {
      _tagList.remove(tokenizer.nextToken());
      _isDirty = true;
    }
  }

  public void remove(String[] tags) {
    for (String tag : tags) {
      remove(tag);
    }
  }

  public String[] get() {
    return _tagList.toArray(new String[_tagList.size()]);
  }

  public void create(){
    if (_isDirty) {
      // Remove old container
      if (_containerHandle.containerID != -1) {
        _container.destroy(_containerHandle);
        _containerHandle.connectionID = -1;
        _containerHandle.containerID = -1;
      }

      // Create new container
      StringBuilder tagList = new StringBuilder();
      for (String tag : _tagList) {
        tagList.append(tag);
        tagList.append(";");
      }

      int size = _container.create(tagList.toString(), _accessFlag, _containerHandle);
      _data = new byte[size];
      _buffer = ByteBuffer.wrap(_data);
      _buffer.order(ByteOrder.LITTLE_ENDIAN);


      // ReadContainer information. We need these information later to interpret the
      // content of the data buffer. The information tells us the offset, type and data size.
      // For faster access, we also store the information in a hash map.
      int i = 0;
      _itemInfosMap.clear();
      _itemInfosArray = _container.getItemInformation(_containerHandle);
      for (ContainerItemInformation item : _itemInfosArray) {
        _itemInfosMap.put(_tagList.get(i), item);
        i++;
      }

      _isDirty = false;
    }
  }

  public void destroy() {
    if (_containerHandle.containerID != -1) {
      _container.destroy(_containerHandle);
      _containerHandle.connectionID = -1;
      _containerHandle.containerID = -1;
    }
    _buffer = null;
  }

  public void update() {
    if (_isDirty) {
      create();
    }
    _container.update(_containerHandle, _data);
  }

  static private boolean isArray(final Object obj) {
    return  obj instanceof Object[] || obj instanceof boolean[] ||
            obj instanceof byte[]   || obj instanceof short[]   ||
            obj instanceof char[]   || obj instanceof int[]     ||
            obj instanceof long[]   || obj instanceof float[]   ||
            obj instanceof double[] || obj instanceof BigInteger[];
 }

  public void setDataByItemInfo(final ContainerItemInformation itemInfo, final Object data) {
    if (_buffer == null) {
      throw new RuntimeException("Container not initialized! You need to successfully call create()!");
    }

    if (!isArray(data)) {
      setDataByItemInfo(itemInfo, (Number) data);
      return;
    }

    final int len = Array.getLength(data);

    _buffer.position(itemInfo.offset);
    switch(itemInfo.type) {
      case TYPE_CHAR_ARRAY:
      {
        if (len > itemInfo.dataSize / 1) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }

        for (int i = 0; i < len; i++) {
          final byte value = Array.getByte(data, i);
          _buffer.put(value);
        }
        break;
      }
      case TYPE_UCHAR_ARRAY:
      {
        if (len > itemInfo.dataSize / 1) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }

        for (int i = 0; i < len; i++) {
          final byte value = (byte) (Array.getShort(data, i) & UCHAR_MAX_VALUE);
          _buffer.put(value);
        }
        break;
      }
      case TYPE_SHORT_ARRAY:
      {
        if (len > itemInfo.dataSize / 2) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }

        for (int i = 0; i < len; i++) {
          final short value = Array.getShort(data, i);
          _buffer.putShort(value);
        }
        break;
      }
      case TYPE_USHORT_ARRAY:
      {
        if (len > itemInfo.dataSize / 2) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }

        for (int i = 0; i < len; i++) {
          final short value = (short) (Array.getInt(data, i) & USHORT_MAX_VALUE);
          _buffer.putShort(value);
        }
        break;
      }
      case TYPE_LONG_ARRAY:
      {
        if (len > itemInfo.dataSize / 4) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }

        for (int i = 0; i < len; i++) {
          final int value = Array.getInt(data, i);
          _buffer.putInt(value);
        }
        break;
      }
      case TYPE_ULONG_ARRAY:
      {
        if (len > itemInfo.dataSize / 4) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }

        for (int i = 0; i < len; i++) {
          final int value = (int) (Array.getLong(data, i) & ULONG_MAX_VALUE);
          _buffer.putInt(value);
        }
        break;
      }
      case TYPE_LLONG_ARRAY:
      {
        if (len > itemInfo.dataSize / 8) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }

        for (int i = 0; i < len; i++) {
          final long value = Array.getLong(data, i);
          _buffer.putLong(value);
        }
        break;
      }
      case TYPE_ULLONG_ARRAY:
      {
        if (len > itemInfo.dataSize / 8) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }

        BigInteger[] bigIntegerArray = (BigInteger[]) data;
        for (int i = 0; i < len; i++) {
          _buffer.putLong(bigIntegerArray[i].longValue());
        }
        break;
      }
      case TYPE_BOOL8_ARRAY:
      {
        if (len > itemInfo.dataSize / 1) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }

        for (int i = 0; i < len; i++) {
          final byte value = (Array.getBoolean(data, i)) ? (byte)1 : (byte)0;
          _buffer.put(value);
        }
        break;
      }
      case TYPE_FLOAT_ARRAY:
      {
        if (len > itemInfo.dataSize / 4) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }

        for (int i = 0; i < len; i++) {
          final float value = Array.getFloat(data, i);
          _buffer.putFloat(value);
        }
        break;
      }
      case TYPE_DOUBLE_ARRAY:
      {
        if (len > itemInfo.dataSize / 8) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }

        for (int i = 0; i < len; i++) {
          final double value = Array.getDouble(data, i);
          _buffer.putDouble(value);
        }
        break;
      }
      case TYPE_CHAR_UTF16:
      case TYPE_INVALID:
      case TYPE_CHAR_UTF8_ARRAY:
      case TYPE_CHAR_UTF16_ARRAY:
      default:
        // not supported
        throw new RuntimeException("Unsupported type in container. Expected: " + itemInfo.type.toString());
    }
  }

  public void setDataByItemInfo(final ContainerItemInformation itemInfo, final Number data) {
    if (_buffer == null) {
      throw new RuntimeException("Container not initialized! You need to successfully call create()!");
    }

    _buffer.position(itemInfo.offset);
    switch(itemInfo.type) {
      case TYPE_CHAR:
      case TYPE_CHAR_ARRAY:
      {
        if (data.longValue() < Byte.MIN_VALUE || data.longValue() > Byte.MAX_VALUE) {
          throw new ArithmeticException("Data " + data.toString() + " can not be converted to SHORT type!");
        }
        _buffer.put(data.byteValue());
        break;
      }
      case TYPE_UCHAR:
      case TYPE_UCHAR_ARRAY:
      {
        if (data.longValue() < UCHAR_MIN_VALUE || data.longValue() > UCHAR_MAX_VALUE) {
          throw new ArithmeticException("Data " + data.toString() + " can not be converted to UCHAR type!");
        }
        _buffer.put((byte)data.byteValue());
        break;
      }
      case TYPE_SHORT:
      case TYPE_SHORT_ARRAY:
      {
        if (data.longValue() < Short.MIN_VALUE || data.longValue() > Short.MAX_VALUE) {
          throw new ArithmeticException("Data " + data.toString() + " can not be converted to SHORT type!");
        }
        _buffer.putShort(data.shortValue());
        break;
      }
      case TYPE_USHORT:
      case TYPE_USHORT_ARRAY:
      {
        if (data.longValue() < USHORT_MIN_VALUE || data.longValue() > USHORT_MAX_VALUE) {
          throw new ArithmeticException("Data " + data.toString() + " can not be converted to USHORT type!");
        }
        _buffer.putShort(data.shortValue());
        break;
      }
      case TYPE_LONG:
      case TYPE_LONG_ARRAY:
      {
        if (data.longValue() < Integer.MIN_VALUE || data.longValue() > Integer.MAX_VALUE) {
          throw new ArithmeticException("Data " + data.toString() + " can not be converted to USHORT type!");
        }
        _buffer.putInt(data.intValue());
        break;
      }
      case TYPE_ULONG:
      case TYPE_ULONG_ARRAY:
      {
        if (data.longValue() < ULONG_MIN_VALUE || data.longValue() > ULONG_MAX_VALUE) {
          throw new ArithmeticException("Data " + data.toString() + " can not be converted to ULONG type!");
        }
        _buffer.putInt(data.intValue());
        break;
      }
      case TYPE_LLONG:
      case TYPE_LLONG_ARRAY:
      {
        if (data.longValue() < Long.MIN_VALUE || data.longValue() > Long.MAX_VALUE) {
          throw new ArithmeticException("Data " + data.toString() + " can not be converted to LLONG type!");
        }
        _buffer.putLong(data.longValue());
        break;
      }
      case TYPE_ULLONG:
      case TYPE_ULLONG_ARRAY:
      {
        final BigInteger value = new BigInteger(data.toString());
        if ( (value.compareTo(ULLONG_MIN_VALUE) < 0) || (value.compareTo(ULLONG_MAX_VALUE) > 0)) {
          throw new ArithmeticException("Data " + data.toString() + " can not be converted to ULLONG type!");
        }
        _buffer.putLong(value.longValue());
        break;
      }
      case TYPE_FLOAT:
      case TYPE_FLOAT_ARRAY:
      {
        if (data.doubleValue() < -Float.MAX_VALUE || data.doubleValue() > Float.MAX_VALUE) {
          throw new ArithmeticException("Data " + data.toString() + " can not be converted to LLONG type!");
        }
        _buffer.putFloat(data.floatValue());
        break;
      }
      case TYPE_DOUBLE:
      case TYPE_DOUBLE_ARRAY:
      {
        _buffer.putDouble(data.doubleValue());
        break;
      }
      case TYPE_BOOL8:
      case TYPE_BOOL8_ARRAY:
      {
        final byte value = (data.intValue() != 0) ? (byte)1 : (byte)0;
        _buffer.put(value);
        break;
      }
      case TYPE_CHAR_UTF8:
      {
        final String value = data.toString();
        if (value.length() >= itemInfo.dataSize / 1) {
          throw new RuntimeException("String too long for container element. Data: " + value);
        }

        try {
          byte[] value2 = value.getBytes("ISO-8859-1");
          _buffer.put(value2);
        } catch (UnsupportedEncodingException e) {
          throw new RuntimeException("String cannot be converted to ansi string. Data: " + data);
        }
        break;
      }
      case TYPE_INVALID:
      case TYPE_CHAR_UTF16:
      case TYPE_CHAR_UTF8_ARRAY:
      case TYPE_CHAR_UTF16_ARRAY:
      default:
        // not supported
        throw new RuntimeException("Unsupported type in container. Type: " + itemInfo.type.toString());
    }
  }

  public void setDataByItemInfo(final ContainerItemInformation itemInfo, final String data) {
    if (_buffer == null) {
      throw new RuntimeException("Container not initialized! You need to successfully call create()!");
    }

    _buffer.position(itemInfo.offset);
    switch(itemInfo.type) {
      case TYPE_CHAR:
      {
        final byte value = Byte.parseByte(data);
        _buffer.put(value);
        break;
      }
      case TYPE_UCHAR:
      {
        short value = Short.parseShort(data);
        if (value < UCHAR_MIN_VALUE || value > UCHAR_MAX_VALUE) {
          throw new ArithmeticException("String " + data + " can not be converted to UCHAR type!");
        }
        _buffer.put((byte)value);
        break;
      }
      case TYPE_SHORT:
      {
        final short value = Short.parseShort(data);
        _buffer.putShort(value);
        break;
      }
      case TYPE_USHORT:
      {
        final int value = Integer.parseInt(data);
        if (value < USHORT_MIN_VALUE || value > USHORT_MAX_VALUE) {
          throw new ArithmeticException("String " + data + " can not be converted to USHORT type!");
        }
        _buffer.putShort((short)value);
        break;
      }
      case TYPE_LONG:
      {
        final int value = Integer.parseInt(data);
        _buffer.putInt(value);
        break;
      }
      case TYPE_ULONG:
      {
        final long value = Long.parseLong(data);
        if (value < ULONG_MIN_VALUE || value > ULONG_MAX_VALUE) {
          throw new ArithmeticException("String " + data + " can not be converted to ULONG type!");
        }
        _buffer.putInt((int)value);
        break;
      }
      case TYPE_LLONG:
      {
        final long value = Long.parseLong(data);
        _buffer.putLong(value);
        break;
      }
      case TYPE_ULLONG:
      {
        final BigInteger value = new BigInteger(data);
        if ( (value.compareTo(ULLONG_MIN_VALUE) < 0) || (value.compareTo(ULLONG_MAX_VALUE) > 0)) {
          throw new ArithmeticException("String " + data + " can not be converted to ULLONG type!");
        }
        _buffer.putLong(value.longValue());
        break;
      }
      case TYPE_FLOAT:
      {
        final float value = Float.parseFloat(data);
        _buffer.putFloat(value);
        break;
      }
      case TYPE_DOUBLE:
      {
        final double value = Double.parseDouble(data);
        _buffer.putDouble(value);
        break;
      }
      case TYPE_BOOL8:
      {
        final byte value = Boolean.parseBoolean(data) ? (byte)1 : (byte)0;
        _buffer.put(value);
        break;
      }
      case TYPE_CHAR_UTF8:
      {
        if (data.length() >= itemInfo.dataSize / 1) {
          throw new RuntimeException("String too long for container element. Data: " + data);
        }

        try {
          byte[] value = data.getBytes("ISO-8859-1");
          _buffer.put(value);
        } catch (UnsupportedEncodingException e) {
          throw new RuntimeException("String cannot be converted to ansi string. Data: " + data);
        }
        break;
      }
      case TYPE_CHAR_ARRAY:
      {
        String[] values = data.split(" ");
        if (values.length > itemInfo.dataSize / 1) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }
        
        for(int i = 0; i < values.length; i++) {
          final byte value = Byte.parseByte(values[i]);
          _buffer.put(value);
        }
        break;
      }
      case TYPE_UCHAR_ARRAY:
      {
        String[] values = data.split(" ");
        if (values.length > itemInfo.dataSize / 1) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }
        
        for(int i = 0; i < values.length; i++) {
          final short value = Short.parseShort(values[i]);
          if (value < UCHAR_MIN_VALUE || value > UCHAR_MAX_VALUE) {
            throw new ArithmeticException("String '" + data + "' @ index [" + i + "] can not be converted to UCHAR_ARRAY type!");
          }
          _buffer.put((byte)value);
        }
        break;
      }
      case TYPE_SHORT_ARRAY:
      {
        String[] values = data.split(" ");
        if (values.length > itemInfo.dataSize / 2) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }
        
        for(int i = 0; i < values.length; i++) {
          final short value = Short.parseShort(values[i]);
          _buffer.putShort(value);
        }
        break;
      }
      case TYPE_USHORT_ARRAY:
      {
        String[] values = data.split(" ");
        if (values.length > itemInfo.dataSize / 2) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }
        
        for(int i = 0; i < values.length; i++) {
          final int value = Integer.parseInt(values[i]);
          if (value < USHORT_MIN_VALUE || value > USHORT_MAX_VALUE) {
            throw new ArithmeticException("String '" + data + "' @ index [" + i + "] can not be converted to USHORT_ARRAY type!");
          }
          _buffer.putShort((short)value);
        }
        break;
      }
      case TYPE_LONG_ARRAY:
      {
        String[] values = data.split(" ");
        if (values.length > itemInfo.dataSize / 4) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }
        
        for(int i = 0; i < values.length; i++) {
          final int value = Integer.parseInt(values[i]);
          _buffer.putInt(value);
        }
        break;
      }
      case TYPE_ULONG_ARRAY:
      {
        String[] values = data.split(" ");
        if (values.length > itemInfo.dataSize / 4) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }
        
        for(int i = 0; i < values.length; i++) {
          final long value = Long.parseLong(values[i]);
          if (value < ULONG_MIN_VALUE || value > ULONG_MAX_VALUE) {
            throw new ArithmeticException("String '" + data + "' @ index [" + i + "] can not be converted to ULONG_ARRAY type!");
          }
          _buffer.putInt((int)value);
        }
        break;
      }
      case TYPE_LLONG_ARRAY:
      {
        String[] values = data.split(" ");
        if (values.length > itemInfo.dataSize / 8) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }
        
        for(int i = 0; i < values.length; i++) {
          final long value = Long.parseLong(values[i]);
          _buffer.putLong(value);
        }
        break;
      }
      case TYPE_ULLONG_ARRAY:
      {
        String[] values = data.split(" ");
        if (values.length > itemInfo.dataSize / 8) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }
        
        for(int i = 0; i < values.length; i++) {
          final BigInteger value = new BigInteger(values[i]);
          if ( (value.compareTo(ULLONG_MIN_VALUE) < 0) || (value.compareTo(ULLONG_MAX_VALUE) > 0)) {
            throw new ArithmeticException("String '" + data + "' @ index [" + i + "] can not be converted to ULLONG_ARRAY type!");
          }
          _buffer.putLong(value.longValue());
        }
        break;
      }
      case TYPE_FLOAT_ARRAY:
      {
        String[] values = data.split(" ");
        if (values.length > itemInfo.dataSize / 4) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }
        
        for(int i = 0; i < values.length; i++) {
          final float value = Float.parseFloat(values[i]);
          _buffer.putFloat(value);
        }
        break;
      }
      case TYPE_DOUBLE_ARRAY:
      {
        String[] values = data.split(" ");
        if (values.length > itemInfo.dataSize / 8) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }
        
        for(int i = 0; i < values.length; i++) {
          final double value = Double.parseDouble(values[i]);
          _buffer.putDouble(value);
        }
        break;
      }
      case TYPE_BOOL8_ARRAY:
      {
        String[] values = data.split(" ");
        if (values.length > itemInfo.dataSize / 1) {
          throw new RuntimeException("Array is too long for container element in container " + _name);
        }
        
        for(int i = 0; i < values.length; i++) {
          final byte value = Boolean.parseBoolean(values[i]) ? (byte)1 : (byte)0;
          _buffer.put(value);
        }
        break;
      }
      case TYPE_INVALID:
      case TYPE_CHAR_UTF16:
      case TYPE_CHAR_UTF8_ARRAY:
      case TYPE_CHAR_UTF16_ARRAY:
      default:
        // not supported
        throw new RuntimeException("Unsupported type in container. Type: " + itemInfo.type.toString());
    }
  }

  public Object getDataByItemInfoAsObject(final ContainerItemInformation itemInfo) {
    if (_buffer == null) {
      throw new RuntimeException("Container not initialized! You need to successfully call create()!");
    }

    _buffer.position(itemInfo.offset);
    switch(itemInfo.type) {
      case TYPE_CHAR:
      {
        final byte value = (byte) _buffer.get();
        return value;
      }
      case TYPE_UCHAR:
      {
        final short value = (short) (((short) _buffer.get()) & UCHAR_MAX_VALUE);
        return value;
      }
      case TYPE_SHORT:
      {
        final short value = (short) _buffer.getShort();
        return value;
      }
      case TYPE_USHORT:
      {
        final int value = ((int) _buffer.getShort()) & USHORT_MAX_VALUE;
        return value;
      }
      case TYPE_LONG:
      {
        final int value = (int) _buffer.getInt();
        return value;
      }
      case TYPE_ULONG:
      {
        final long value = ((long) _buffer.getInt()) & ULONG_MAX_VALUE;
        return value;
      }
      case TYPE_LLONG:
      {
        final long value = (long) _buffer.getLong();
        return value;
      }
      case TYPE_ULLONG:
      {
        final long value = (long) _buffer.getLong();
        final BigInteger bigValue = new BigInteger(Long.toUnsignedString(value));
        return bigValue;
      }
      case TYPE_FLOAT:
      {
        final float value = (float) _buffer.getFloat();
        return value;
      }
      case TYPE_DOUBLE:
      {
        final double value = (double) _buffer.getDouble();
        return value;
      }
      case TYPE_CHAR_ARRAY:
      {
        final int len = itemInfo.dataSize / 1;
        byte[] values = new byte[len];
        for (int i = 0; i < len; i++) {
          values[i] = (byte) _buffer.get();
        }
        return values;
      }
      case TYPE_UCHAR_ARRAY:
      {
        final int len = itemInfo.dataSize / 1;
        short[] values = new short[len];
        for (int i = 0; i < len; i++) {
          _buffer.position(itemInfo.offset+(i*1));
          values[i] = (short) (((short) _buffer.get()) & UCHAR_MAX_VALUE);
        }
        return values;
      }
      case TYPE_SHORT_ARRAY:
      {
        final int len = itemInfo.dataSize / 2;
        short[] values = new short[len];
        for (int i = 0; i < len; i++) {
          values[i] = (short) _buffer.getShort();
        }
        return values;
      }
      case TYPE_USHORT_ARRAY:
      {
        final int len = itemInfo.dataSize / 2;
        int[] values = new int[len];
        for (int i = 0; i < len; i++) {
          _buffer.position(itemInfo.offset+(i*2));
          values[i] = ((int) _buffer.getShort()) & USHORT_MAX_VALUE;
        }
        return values;
      }
      case TYPE_LONG_ARRAY:
      {
        final int len = itemInfo.dataSize / 4;
        int[] values = new int[len];
        for (int i = 0; i < len; i++) {
          values[i] = (int) _buffer.getInt();
        }
        return values;
      }
      case TYPE_ULONG_ARRAY:
      {
        final int len = itemInfo.dataSize / 4;
        long[] values = new long[len];
        for (int i = 0; i < len; i++) {
          _buffer.position(itemInfo.offset+(i*4));
          values[i] = ((long) _buffer.getInt()) & ULONG_MAX_VALUE;
        }
        return values;
      }
      case TYPE_LLONG_ARRAY:
      {
        final int len = itemInfo.dataSize / 8;
        long[] values = new long[len];
        for (int i = 0; i < len; i++) {
          values[i] = (long) _buffer.getLong();
        }
        return values;
      }
      case TYPE_ULLONG_ARRAY:
      {
        final int len = itemInfo.dataSize / 8;
        BigInteger[] bigValues = new BigInteger[len];
        for (int i = 0; i < len; i++) {
          _buffer.position(itemInfo.offset+(i*8));
          long value = (long) _buffer.getLong();
          bigValues[i] = new BigInteger(Long.toUnsignedString(value));
        }
        return bigValues;
      }
      case TYPE_FLOAT_ARRAY:
      {
        final int len = itemInfo.dataSize / 4;
        float[] values = new float[len];
        for (int i = 0; i < len; i++) {
          values[i] = (float) _buffer.getFloat();
        }
        return values;
      }
      case TYPE_DOUBLE_ARRAY:
      {
        final int len = itemInfo.dataSize / 8;
        double[] values = new double[len];
        for (int i = 0; i < len; i++) {
          values[i] = (double) _buffer.getDouble();
        }
        return values;
      }
      case TYPE_BOOL8:
      {
        final boolean value = (_buffer.get() != 0) ? Boolean.TRUE : Boolean.FALSE;
        return value;
      }
      case TYPE_BOOL8_ARRAY:
      {
        final int len = itemInfo.dataSize / 1;
        boolean[] values = new boolean[len];
        for (int i = 0; i < len; i++) {
          values[i] = (_buffer.get() != 0) ? Boolean.TRUE : Boolean.FALSE;
        }
        return values;
      }
      case TYPE_CHAR_UTF8:
      {
        byte[] value = new byte[itemInfo.dataSize];
        _buffer.get(value);

        try {
          int len;
          for (len = 0; len < value.length && value[len] != 0; len++) { }
          return new String(value, 0, len, "ISO-8859-1");
        } catch (UnsupportedEncodingException e) {
          throw new RuntimeException("String in container is not a valid encoded ansi string. Type: " + itemInfo.type.toString());
        }
      }
      case TYPE_CHAR_UTF16:
      case TYPE_INVALID:
      case TYPE_CHAR_UTF8_ARRAY:
      case TYPE_CHAR_UTF16_ARRAY:
      default:
        // not supported
        throw new RuntimeException("Unsupported type in container. Type: " + itemInfo.type.toString());
    }
  }

  public String getDataByItemInfoAsString(final ContainerItemInformation itemInfo) {
    if (_buffer == null) {
      throw new RuntimeException("Container not initialized! You need to successfully call create()!");
    }

    _buffer.position(itemInfo.offset);
    switch(itemInfo.type) {
      case TYPE_CHAR:
      {
        final byte value = (byte) _buffer.get();
        return String.valueOf(value);
      }
      case TYPE_UCHAR:
      {
        final short value = (short) (((short) _buffer.get()) & UCHAR_MAX_VALUE);
        return String.valueOf(value);
      }
      case TYPE_SHORT:
      {
        final short value = (short) _buffer.getShort();
        return String.valueOf(value);
      }
      case TYPE_USHORT:
      {
        final int value = ((int) _buffer.getShort()) & USHORT_MAX_VALUE;
        return String.valueOf(value);
      }
      case TYPE_LONG:
      {
        final int value = (int) _buffer.getInt();
        return String.valueOf(value);
      }
      case TYPE_ULONG:
      {
        final long value = ((long) _buffer.getInt()) & ULONG_MAX_VALUE;
        return String.valueOf(value);
      }
      case TYPE_LLONG:
      {
        final long value = (long) _buffer.getLong();
        return String.valueOf(value);
      }
      case TYPE_ULLONG:
      {
        final long value = (long) _buffer.getLong();
        return Long.toUnsignedString(value);
      }
      case TYPE_FLOAT:
      {
        final float value = (float) _buffer.getFloat();
        return String.valueOf(value);
      }
      case TYPE_DOUBLE:
      {
        final double value = (double) _buffer.getDouble();
        return String.valueOf(value);
      }
      case TYPE_CHAR_ARRAY:
      {
        String values = "";
        for (int i = 0; i < itemInfo.dataSize / 1; i++) {
          final byte value = (byte) _buffer.get();
          values += String.valueOf(value) + " ";
        }
        return values.trim();
      }
      case TYPE_UCHAR_ARRAY:
      {
        String values = "";
        for (int i = 0; i < itemInfo.dataSize / 1; i++) {
          _buffer.position(itemInfo.offset+(i*1));
          final short value = (short) (((short) _buffer.get()) & UCHAR_MAX_VALUE);
          values += String.valueOf(value) + " ";
        }
        return values.trim();
      }
      case TYPE_SHORT_ARRAY:
      {
        String values = "";
        for (int i = 0; i < itemInfo.dataSize / 2; i++) {
          final short value = (short) _buffer.getShort();
          values += String.valueOf(value) + " ";
        }
        return values.trim();
      }
      case TYPE_USHORT_ARRAY:
      {
        String values = "";
        for (int i = 0; i < itemInfo.dataSize / 2; i++) {
          _buffer.position(itemInfo.offset+(i*2));
          final int value = ((int) _buffer.getInt()) & USHORT_MAX_VALUE;
          values += String.valueOf(value) + " ";
        }
        return values.trim();
      }
      case TYPE_LONG_ARRAY:
      {
        String values = "";
        for (int i = 0; i < itemInfo.dataSize / 4; i++) {
          final int value = (int) _buffer.getInt();
          values += String.valueOf(value) + " ";
        }
        return values.trim();
      }
      case TYPE_ULONG_ARRAY:
      {
        String values = "";
        for (int i = 0; i < itemInfo.dataSize / 4; i++) {
          _buffer.position(itemInfo.offset+(i*4));
          final long value = ((long) _buffer.getLong()) & ULONG_MAX_VALUE;
          values += String.valueOf(value) + " ";
        }
        return values.trim();
      }
      case TYPE_LLONG_ARRAY:
      {
        String values = "";
        for (int i = 0; i < itemInfo.dataSize / 8; i++) {
          final long value = (long) _buffer.getLong();
          values += String.valueOf(value) + " ";
        }
        return values.trim();
      }
      case TYPE_ULLONG_ARRAY:
      {
        String values = "";
        for (int i = 0; i < itemInfo.dataSize / 8; i++) {
          _buffer.position(itemInfo.offset+(i*8));
          final long value = (long) _buffer.getLong();
          values += Long.toUnsignedString(value) + " ";
        }
        return values.trim();
      }
      case TYPE_FLOAT_ARRAY:
      {
        String values = "";
        for (int i = 0; i < itemInfo.dataSize / 4; i++) {
          final float value = (float) _buffer.getFloat();
          values += String.valueOf(value) + " ";
        }
        return values.trim();
      }
      case TYPE_DOUBLE_ARRAY:
      {
        String values = "";
        for (int i = 0; i < itemInfo.dataSize / 8; i++) {
          final double value = (double) _buffer.getDouble();
          values += String.valueOf(value) + " ";
        }
        return values.trim();
      }
      case TYPE_BOOL8:
      {
        final byte value = _buffer.get();
        return (value != 0) ? "TRUE" : "FALSE";
      }
      case TYPE_BOOL8_ARRAY:
      {
        String values = "";
        for (int i = 0; i < itemInfo.dataSize / 1; i++) {
          final byte value = _buffer.get();
          values += (value != 0) ? "TRUE" : "FALSE" + " ";
        }
        return values.trim();
      }
      case TYPE_CHAR_UTF8:
      {
        byte[] value = new byte[itemInfo.dataSize];
        _buffer.get(value);

        try {
          int len;
          for (len = 0; len < value.length && value[len] != 0; len++) { }
          return new String(value, 0, len, "ISO-8859-1");
        } catch (UnsupportedEncodingException e) {
          throw new RuntimeException("String in container is not a valid encoded ansi string. Type: " + itemInfo.type.toString());
        }
      }
      case TYPE_CHAR_UTF16:
      case TYPE_CHAR_UTF8_ARRAY:
      case TYPE_CHAR_UTF16_ARRAY:
      case TYPE_INVALID:
      default:
        // not supported
        throw new RuntimeException("Unsupported type in container. Type: " + itemInfo.type.toString());
    }
  }

  /*
  public String getDataByIndexAsString(final int index) {
    return getDataByItemInfoAsString(_itemInfosArray[index]);
  }
  */

  public Object getDataByTagAsObject(final int index) {
    return getDataByItemInfoAsObject(_itemInfosArray[index]);
  }

  public String getDataByTagAsString(final String tag) {
    final ContainerItemInformation itemInfo = _itemInfosMap.get(tag);
    if (itemInfo == null) {
      throw new RuntimeException("Could not find tag " + tag + " in container structure " + _name);
    }
    return getDataByItemInfoAsString(itemInfo);
  }

  public Object getDataByTagAsObject(final String tag) {
    final ContainerItemInformation itemInfo = _itemInfosMap.get(tag);
    if (itemInfo == null) {
      throw new RuntimeException("Could not find tag " + tag + " in container structure " + _name);
    }
    return getDataByItemInfoAsObject(itemInfo);
  }

  public void setDataByTag(final String tag, final String data) {
    final ContainerItemInformation itemInfo = _itemInfosMap.get(tag);
    if (itemInfo == null) {
      throw new RuntimeException("Could not find tag " + tag + " in container structure " + _name);
    }
    setDataByItemInfo(itemInfo, data);
  }

  public void setDataByTag(final String tag, final Number data) {
    final ContainerItemInformation itemInfo = _itemInfosMap.get(tag);
    if (itemInfo == null) {
      throw new RuntimeException("Could not find tag " + tag + " in container structure " + _name);
    }
    setDataByItemInfo(itemInfo, data);
  }

  public void setDataByTag(final String tag, final Object data) {
    final ContainerItemInformation itemInfo = _itemInfosMap.get(tag);
    if (itemInfo == null) {
      throw new RuntimeException("Could not find tag " + tag + " in container structure " + _name);
    }
    setDataByItemInfo(itemInfo, data);
  }

  public final byte[] getDataAsByteStream() {
    return _data;
  }

  public final ContainerItemInformation getItemInfoByTag(final String tag) {
    return _itemInfosMap.get(tag);
  }

  public boolean isDirty() {
    return _isDirty;
  }
}