Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.infinispan.protostream.impl;
  
  
 import java.util.Date;

Author(s):
anistor@redhat.com
 
 
    private static final Log log = Log.LogFactory.getLog(ProtoStreamWriterImpl.class);
 
    private final SerializationContextImpl ctx;
 
 
       this. = ctx;
    }
 
        = new WriteMessageContext(fd == null ? null : fd.getName(), marshallerDelegateout);
       return ;
    }
 
    void popContext() {
    }
 
    @Override
       return ;
    }
 
    @Override
    public void writeInt(String fieldNameInteger valuethrows IOException {
       final FieldDescriptor fd = ..getFieldByName(fieldName);
 
       if (value == null) {
          if (fd.isRequired()) {
             throw new IllegalArgumentException("A required field cannot be null : " + fieldName);
          }
          return;
       }
 
       writeInt(fieldNamevalue.intValue());
    }
 
    @Override
    public void writeInt(String fieldNameint valuethrows IOException {
       final FieldDescriptor fd = ..getFieldByName(fieldName);
 
       checkFieldWrite(fd);
 
       //need to know which exact flavor of write to use depending on wire type
       switch (fd.getType()) {
          case :
             ..writeInt32(fd.getNumber(), value);
             break;
          case :
             ..writeFixed32(fd.getNumber(), value);
             break;
          case :
             ..writeUInt32(fd.getNumber(), value);
             break;
          case :
             ..writeSFixed32(fd.getNumber(), value);
             break;
          case :
             ..writeSInt32(fd.getNumber(), value);
             break;
          default:
             throw new IllegalArgumentException("The Protobuf declared field type is not compatible with the written type : " + fieldName);
       }
    }
 
    @Override
    public void writeLong(String fieldNamelong valuethrows IOException {
       final FieldDescriptor fd = ..getFieldByName(fieldName);
 
       checkFieldWrite(fd);
 
       //need to know which exact flavor of write to use depending on wire type
       switch (fd.getType()) {
          case :
             ..writeInt64(fd.getNumber(), value);
             break;
          case :
             ..writeUInt64(fd.getNumber(), value);
             break;
          case :
            ..writeFixed64(fd.getNumber(), value);
            break;
         case :
            ..writeSFixed64(fd.getNumber(), value);
            break;
         case :
            ..writeSInt64(fd.getNumber(), value);
            break;
         default:
            throw new IllegalArgumentException("The Protobuf declared field type is not compatible with the written type : " + fieldName);
      }
   }
   public void writeLong(String fieldNameLong valuethrows IOException {
      if (value == null) {
         if (fd.isRequired()) {
            throw new IllegalArgumentException("A required field cannot be null : " + fieldName);
         }
         return;
      }
      writeLong(fieldNamevalue.longValue());
   }
   public void writeDouble(String fieldNamedouble valuethrows IOException {
      checkFieldWrite(fd);
      if (fd.getType() != .) {
         throw new IllegalArgumentException("The Protobuf declared field type is not compatible with the written type : " + fieldName);
      }
      ..writeDouble(fd.getNumber(), value);
   }
   public void writeDouble(String fieldNameDouble valuethrows IOException {
      if (value == null) {
         if (fd.isRequired()) {
            throw new IllegalArgumentException("A required field cannot be null : " + fieldName);
         }
         return;
      }
      writeDouble(fieldNamevalue.doubleValue());
   }
   public void writeFloat(String fieldNamefloat valuethrows IOException {
      checkFieldWrite(fd);
      if (fd.getType() != .) {
         throw new IllegalArgumentException("The Protobuf declared field type is not compatible with the written type : " + fieldName);
      }
      ..writeFloat(fd.getNumber(), value);
   }
   public void writeFloat(String fieldNameFloat valuethrows IOException {
      if (value == null) {
         if (fd.isRequired()) {
            throw new IllegalArgumentException("A required field cannot be null : " + fieldName);
         }
         return;
      }
      writeFloat(fieldNamevalue.floatValue());
   }
   public void writeBoolean(String fieldNameboolean valuethrows IOException {
      checkFieldWrite(fd);
      if (fd.getType() != .) {
         throw new IllegalArgumentException("The Protobuf declared field type is not compatible with the written type : " + fieldName);
      }
      ..writeBool(fd.getNumber(), value);
   }
   public void writeBoolean(String fieldNameBoolean valuethrows IOException {
      if (value == null) {
         if (fd.isRequired()) {
            throw new IllegalArgumentException("A required field cannot be null : " + fieldName);
         }
         return;
      }
      writeBoolean(fieldNamevalue.booleanValue());
   }
   public void writeString(String fieldNameString valuethrows IOException {
      if (value == null) {
         if (fd.isRequired()) {
            throw new IllegalArgumentException("A required field cannot be null : " + fieldName);
         }
         return;
      }
      checkFieldWrite(fd);
      if (fd.getType() != .) {
         throw new IllegalArgumentException("Declared field type is not of type String : " + fieldName);
      }
      ..writeString(fd.getNumber(), value);
   }
   public void writeBytes(String fieldNamebyte[] valuethrows IOException {
      if (value == null) {
         if (fd.isRequired()) {
            throw new IllegalArgumentException("A required field cannot be null : " + fieldName);
         }
         return;
      }
      checkFieldWrite(fd);
      if (fd.getType() != .) {
         throw new IllegalArgumentException("Declared field type is not of type byte[] : " + fieldName);
      }
      ..writeBytes(fd.getNumber(), value);
   }
   public <E> void writeObject(String fieldName, E valueClass<? extends E> clazzthrows IOException {
      if (value == null) {
         if (fd.isRequired()) {
            throw new IllegalArgumentException("A required field cannot be null : " + fieldName);
         }
         return;
      }
      checkFieldWrite(fd);
      if (fd.getType() == .) {
         writeGroup(fdvalueclazz);
      } else if (fd.getType() == .) {
         writeMessage(fdvalueclazz);
      } else if (fd.getType() == .) {
         writeEnum(fd, (Enumvalue);
      } else {
         throw new IllegalArgumentException("Declared field type is not a message or an enum : " + fieldName);
      }
   }
   private void writeMessage(FieldDescriptor fdObject valueClass clazzthrows IOException {
      BaseMarshallerDelegate marshallerDelegate = .getMarshallerDelegate(clazz);
      RawProtoStreamWriter out = RawProtoStreamWriterImpl.newInstance(baos);
      marshallerDelegate.marshall(fdvaluethisout);
      out.flush();
   }
   private void writeGroup(FieldDescriptor fdObject valueClass clazzthrows IOException {
      BaseMarshallerDelegate marshallerDelegate = .getMarshallerDelegate(clazz);
      marshallerDelegate.marshall(fdvaluethis.);
   }
   private <T extends Enum<T>> void writeEnum(FieldDescriptor fd, T valuethrows IOException {
      BaseMarshallerDelegate<T> marshallerDelegate = (BaseMarshallerDelegate<T>) .getMarshallerDelegate(value.getClass());
      marshallerDelegate.marshall(fdvaluethis.);
   }
   public <E> void writeCollection(String fieldNameCollection<? super E> collectionClass<E> elementClassthrows IOException {
      if (collection == null) {
         // a repeated field is never flagged as required
         return;
      }
      final Type type = fd.getType();
      if (type == .) {
         for (Object t : collection) {
            writeGroup(fdtelementClass);
         }
      } else if (type == .) {
         for (Object t : collection) {
            writeMessage(fdtelementClass);
         }
      } else if (type == .) {
         for (Object t : collection) {
            writeEnum(fd, (Enumt);
         }
      } else {
         final RawProtoStreamWriter out = .;
         final int fieldNumber = fd.getNumber();
         switch (type) {
            case :
               for (Object value : collection) {  //todo check (value != null && value.getClass() == elementClass)
                  out.writeDouble(fieldNumber, (Doublevalue);
               }
               break;
            case :
               for (Object value : collection) {
                  out.writeFloat(fieldNumber, (Floatvalue);
               }
               break;
            case :
               for (Object value : collection) {
                  out.writeBool(fieldNumber, (Booleanvalue);
               }
               break;
            case :
               for (Object value : collection) {
                  out.writeString(fieldNumber, (Stringvalue);
               }
               break;
            case :
               for (Object value : collection) {
                  out.writeBytes(fieldNumber, (byte[]) value);
               }
               break;
            case :
               for (Object value : collection) {
                  out.writeInt64(fieldNumber, (Longvalue);
               }
               break;
            case :
               for (Object value : collection) {
                  out.writeUInt64(fieldNumber, (Longvalue);
               }
               break;
            case :
               for (Object value : collection) {
                  out.writeFixed64(fieldNumber, (Longvalue);
               }
               break;
            case :
               for (Object value : collection) {
                  out.writeSFixed64(fieldNumber, (Longvalue);
               }
               break;
            case :
               for (Object value : collection) {
                  out.writeSInt64(fieldNumber, (Longvalue);
               }
               break;
            case :
               for (Object value : collection) {
                  out.writeInt32(fieldNumber, (Integervalue);
               }
               break;
            case :
               for (Object value : collection) {
                  out.writeFixed32(fieldNumber, (Integervalue);
               }
               break;
            case :
               for (Object value : collection) {
                  out.writeUInt32(fieldNumber, (Integervalue);
               }
               break;
            case :
               for (Object value : collection) {
                  out.writeSFixed32(fieldNumber, (Integervalue);
               }
               break;
            case :
               for (Object value : collection) {
                  out.writeSInt32(fieldNumber, (Integervalue);
               }
               break;
            default:
               throw new IllegalStateException("Unexpected field type : " + type);
         }
      }
   }
   public <E> void writeArray(String fieldName, E[] arrayClass<? extends E> elementClassthrows IOException {
      if (array == null) {
         // a repeated field is never flagged as required
         return;
      }
      final Type type = fd.getType();
      if (type == .) {
         for (Object t : array) {
            writeGroup(fdtelementClass);
         }
      } else if (type == .) {
         for (Object t : array) {
            writeMessage(fdtelementClass);
         }
      } else if (type == .) {
         for (Object t : array) {
            writeEnum(fd, (Enumt);
         }
      } else {
         final RawProtoStreamWriter out = .;
         final int fieldNumber = fd.getNumber();
         switch (type) {
            case :
               for (Object value : array) {  //todo check (value != null && value.getClass() == elementClass)
                  out.writeDouble(fieldNumber, (Doublevalue);
               }
               break;
            case :
               for (Object value : array) {
                  out.writeFloat(fieldNumber, (Floatvalue);
               }
               break;
            case :
               for (Object value : array) {
                  out.writeBool(fieldNumber, (Booleanvalue);
               }
               break;
            case :
               for (Object value : array) {
                  out.writeString(fieldNumber, (Stringvalue);
               }
               break;
            case :
               for (Object value : array) {
                  out.writeBytes(fieldNumber, (byte[]) value);
               }
               break;
            case :
               for (Object value : array) {
                  out.writeInt64(fieldNumber, (Longvalue);
               }
               break;
            case :
               for (Object value : array) {
                  out.writeUInt64(fieldNumber, (Longvalue);
               }
               break;
            case :
               for (Object value : array) {
                  out.writeFixed64(fieldNumber, (Longvalue);
               }
               break;
            case :
               for (Object value : array) {
                  out.writeSFixed64(fieldNumber, (Longvalue);
               }
               break;
            case :
               for (Object value : array) {
                  out.writeSInt64(fieldNumber, (Longvalue);
               }
               break;
            case :
               for (Object value : array) {
                  out.writeInt32(fieldNumber, (Integervalue);
               }
               break;
            case :
               for (Object value : array) {
                  out.writeFixed32(fieldNumber, (Integervalue);
               }
               break;
            case :
               for (Object value : array) {
                  out.writeUInt32(fieldNumber, (Integervalue);
               }
               break;
            case :
               for (Object value : array) {
                  out.writeSFixed32(fieldNumber, (Integervalue);
               }
               break;
            case :
               for (Object value : array) {
                  out.writeSInt32(fieldNumber, (Integervalue);
               }
               break;
            default:
               throw new IllegalStateException("Unexpected field type : " + type);
         }
      }
   }
   public void writeDate(String fieldNameDate valuethrows IOException {
      if (value != null) {
         writeLong(fieldNamevalue.getTime());
      }
   }
   private void checkFieldWrite(FieldDescriptor fd) {
      if (fd.isRepeated()) {
         throw new IllegalArgumentException("A repeated field should be written with one of the methods intended for collections or arrays: " + fd.getFullName());
      }
      if (!.markField(fd.getNumber())) {
         throw new IllegalStateException("A field cannot be written twice : " + fd.getFullName());
      }
            && .isEnabled(..)
            && .getMaxSeenFieldNumber() > fd.getNumber()) {
         .fieldWriteOutOfSequence(fd.getFullName());
      }
   }
   private void checkRepeatedFieldWrite(FieldDescriptor fd) {
      if (!fd.isRepeated()) {
         throw new IllegalArgumentException("This field is not repeated and cannot be written with the methods intended for collections or arrays: " + fd.getFullName());
      }
      if (!.markField(fd.getNumber())) {
         throw new IllegalStateException("A field cannot be written twice : " + fd.getFullName());
      }
            && .isEnabled(..)
            && .getMaxSeenFieldNumber() > fd.getNumber()) {
         .fieldWriteOutOfSequence(fd.getFullName());
      }
   }
New to GrepCode? Check out our FAQ X