• Home
• us.ihmc
• ihmc-pub-sub-serializers-extra
• 0.19.2
• source code
• JacksonInterchangeSerializer.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

us.ihmc.idl.serializers.extra.JacksonInterchangeSerializer Maven / Gradle / Ivy

/**
 * Copyright 2018 Florida Institute for Human and Machine Cognition (IHMC)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package us.ihmc.idl.serializers.extra;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import org.apache.commons.lang3.NotImplementedException;
import us.ihmc.idl.IDLSequence;
import us.ihmc.idl.InterchangeSerializer;
import us.ihmc.pubsub.TopicDataType;

/**
 * Internal class to serialize IDL data to representations supported by Jackson
 * 
 * @author Jesper Smith
 *
 */
class JacksonInterchangeSerializer implements InterchangeSerializer
{
   private final boolean supportsArrays;
   private final ObjectNode node;

   JacksonInterchangeSerializer(ObjectNode node, boolean supportsArrays)
   {
      this.node = node;
      this.supportsArrays = supportsArrays;
   }

   /**
    * Signed short
    */
   public short read_type_1(String name)
   {
      return (short) node.path(name).asInt();
   }

   public void write_type_1(String name, short val)
   {
      node.put(name, val);
   }

   /**
    * Signed int
    */
   public int read_type_2(String name)
   {
      return node.path(name).asInt();
   }

   public void write_type_2(String name, int val)
   {
      node.put(name, val);
   }

   /**
    * Float
    */
   public float read_type_5(String name)
   {
      return (float) node.path(name).asDouble();
   }

   public void write_type_5(String name, float val)
   {
      node.put(name, val);
   }

   /**
    * Double
    */
   public double read_type_6(String name)
   {
      return node.path(name).asDouble();
   }

   public void write_type_6(String name, double val)
   {
      node.put(name, val);
   }

   /**
    * Boolean
    */
   public boolean read_type_7(String name)
   {
      return node.path(name).asBoolean();
   }

   public void write_type_7(String name, boolean val)
   {
      node.put(name, val);
   }

   /**
    * Char
    */
   public char read_type_8(String name)
   {
      String text = node.path(name).asText();
      return str2char(text);
   }

   private final char str2char(String text)
   {
      if (text != null && text.length() > 0)
      {
         return text.charAt(0);
      }
      else
      {
         return '\0';
      }
   }

   public void write_type_8(String name, char val)
   {
      node.put(name, String.valueOf(val));
   }

   /**
    * Octet
    */
   public byte read_type_9(String name)
   {
      return (byte) node.path(name).asInt();
   }

   public void write_type_9(String name, byte val)
   {
      node.put(name, (int) val);
   }

   /**
    * Struct
    */
   public  void read_type_a(String name, TopicDataType type, T data)
   {
      type.deserialize(new JacksonInterchangeSerializer(node.with(name), supportsArrays), data);
   }

   public  void write_type_a(String name, TopicDataType type, T data)
   {
      type.serialize(data, new JacksonInterchangeSerializer(node.putObject(name), supportsArrays));
   }

   /**
    * Enum
    */
   public Enum read_type_c(String name, Class> enumType)
   {
      String val = node.path(name).asText();
      return str2enum(enumType.getEnumConstants(), val);
   }

   private static Enum str2enum(Enum[] enumConstants, String val)
   {
      for (Enum enumVal : enumConstants)
      {
         if (enumVal.name().equals(val))
         {
            return enumVal;
         }
      }
      return null;
   }

   public void write_type_c(String name, Enum val)
   {
      if (val == null)
      {
         node.putNull(name);
      }
      else
      {
         node.put(name, val.name());
      }
   }

   /**
    * String
    */
   public void read_type_d(String name, StringBuilder res)
   {
      res.setLength(0);
      res.append(node.path(name).asText());
   }

   public void write_type_d(String name, StringBuilder str)
   {
      node.put(name, str.toString());
   }
   
   private void checkArraySupport()
   {
      if(!supportsArrays)
      {
         throw new UnsupportedFeatureException("This serializer does not support arrays and sequences");
      }
   }

   /**
    * Sequence
    */
   @SuppressWarnings({"rawtypes", "unchecked"})
   public void read_type_e(String name, IDLSequence seq)
   {
      checkArraySupport();
      seq.resetQuick();
      JsonNode child = node.path(name);
      if (child.isArray())
      {
         for (JsonNode val : child)
         {
            if (seq instanceof IDLSequence.Boolean)
            {
               ((IDLSequence.Boolean) seq).add(val.asBoolean());
            }
            else if (seq instanceof IDLSequence.Byte)
            {
               ((IDLSequence.Byte) seq).add((byte) val.asInt());
            }
            else if (seq instanceof IDLSequence.Char)
            {
               ((IDLSequence.Char) seq).add(str2char(val.asText()));
            }
            else if (seq instanceof IDLSequence.Short)
            {
               ((IDLSequence.Short) seq).add((short) val.asInt());
            }
            else if (seq instanceof IDLSequence.Integer)
            {
               ((IDLSequence.Integer) seq).add(val.asInt());
            }
            else if (seq instanceof IDLSequence.Long)
            {
               ((IDLSequence.Long) seq).add(val.asLong());
            }
            else if (seq instanceof IDLSequence.Float)
            {
               ((IDLSequence.Float) seq).add((float)val.asDouble());
            }
            else if (seq instanceof IDLSequence.Double)
            {
               ((IDLSequence.Double) seq).add(val.asDouble());
            }
            else if (seq instanceof IDLSequence.StringBuilderHolder)
            {
               ((IDLSequence.StringBuilderHolder) seq).add(val.asText());
            }
            else if (seq instanceof IDLSequence.Enum)
            {
               ((IDLSequence.Enum) seq).add(str2enum(((IDLSequence.Enum) seq).getEnumConstants(), val.asText()));
            }
            else if (seq instanceof IDLSequence.Object)
            {
               TopicDataType