/**
  * @param clsInfo
  * @param referencee
  * @param toWrite
  * @return true if header already wrote object
  * @throws IOException
  */
 protected boolean writeObjectHeader(
     final FSTClazzInfo clsInfo, final FSTClazzInfo.FSTFieldInfo referencee, final Object toWrite)
     throws IOException {
   if (toWrite.getClass() == referencee.getType() && !clsInfo.useCompatibleMode()) {
     return codec.writeTag(TYPED, clsInfo, 0, toWrite);
   } else {
     final Class[] possibleClasses = referencee.getPossibleClasses();
     if (possibleClasses == null) {
       if (!codec.writeTag(OBJECT, clsInfo, 0, toWrite)) {
         codec.writeClass(clsInfo);
         return false;
       } else {
         return true;
       }
     } else {
       final int length = possibleClasses.length;
       for (int j = 0; j < length; j++) {
         final Class possibleClass = possibleClasses[j];
         if (possibleClass == toWrite.getClass()) {
           codec.writeFByte(j + 1);
           return false;
         }
       }
       if (!codec.writeTag(OBJECT, clsInfo, 0, toWrite)) {
         codec.writeClass(clsInfo);
         return false;
       } else {
         return true;
       }
     }
   }
 }
 // avoid creation of dummy ref
 FSTClazzInfo.FSTFieldInfo getCachedFI(Class... possibles) {
   if (curDepth >= refs.length) {
     return new FSTClazzInfo.FSTFieldInfo(possibles, null, true);
   } else {
     FSTClazzInfo.FSTFieldInfo inf = refs[curDepth];
     if (inf == null) {
       inf = new FSTClazzInfo.FSTFieldInfo(possibles, null, true);
       refs[curDepth] = inf;
       return inf;
     }
     inf.setPossibleClasses(possibles);
     return inf;
   }
 }
 /** if class is same as last referenced, returned cached clzinfo, else do a lookup */
 protected FSTClazzInfo getFstClazzInfo(FSTClazzInfo.FSTFieldInfo referencee, Class clazz) {
   FSTClazzInfo serializationInfo = null;
   FSTClazzInfo lastInfo = referencee.lastInfo;
   if (lastInfo != null && lastInfo.getClazz() == clazz) {
     serializationInfo = lastInfo;
   } else {
     serializationInfo = getClassInfoRegistry().getCLInfo(clazz);
     referencee.lastInfo = serializationInfo;
   }
   return serializationInfo;
 }
 // incoming array is already registered
 protected void writeArray(FSTClazzInfo.FSTFieldInfo referencee, Object array) throws IOException {
   if (array == null) {
     codec.writeClass(Object.class);
     codec.writeFInt(-1);
     return;
   }
   final int len = Array.getLength(array);
   Class<?> componentType = array.getClass().getComponentType();
   codec.writeClass(array.getClass());
   codec.writeFInt(len);
   if (!componentType.isArray()) {
     if (codec.isPrimitiveArray(array, componentType)) {
       codec.writePrimitiveArray(array, 0, len);
     } else { // objects
       Object arr[] = (Object[]) array;
       for (int i = 0; i < len; i++) {
         Object toWrite = arr[i];
         writeObjectWithContext(referencee, toWrite);
       }
     }
   } else { // multidim array. FIXME shared refs to subarrays are not tested !!!
     Object[] arr = (Object[]) array;
     FSTClazzInfo.FSTFieldInfo ref1 =
         new FSTClazzInfo.FSTFieldInfo(
             referencee.getPossibleClasses(),
             null,
             conf.getCLInfoRegistry().isIgnoreAnnotations());
     for (int i = 0; i < len; i++) {
       Object subArr = arr[i];
       boolean needsWrite = true;
       if (codec.isTagMultiDimSubArrays()) {
         if (subArr == null) {
           needsWrite = !codec.writeTag(NULL, null, 0, null);
         } else {
           needsWrite = !codec.writeTag(ARRAY, subArr, 0, subArr);
         }
       }
       if (needsWrite) writeArray(ref1, subArr);
     }
   }
 }
 // write identical to other version, but take field values from hashmap (because of annoying
 // putField/getField feature)
 private void writeCompatibleObjectFields(
     Object toWrite, Map fields, FSTClazzInfo.FSTFieldInfo[] fieldInfo) throws IOException {
   int booleanMask = 0;
   int boolcount = 0;
   for (int i = 0; i < fieldInfo.length; i++) {
     try {
       FSTClazzInfo.FSTFieldInfo subInfo = fieldInfo[i];
       boolean isarr = subInfo.isArray();
       Class subInfType = subInfo.getType();
       if (subInfType != boolean.class || isarr) {
         if (boolcount > 0) {
           codec.writeFByte(booleanMask << (8 - boolcount));
           boolcount = 0;
           booleanMask = 0;
         }
       }
       if (subInfo.isIntegral() && !isarr) {
         if (subInfType == boolean.class) {
           if (boolcount == 8) {
             codec.writeFByte(booleanMask << (8 - boolcount));
             boolcount = 0;
             booleanMask = 0;
           }
           boolean booleanValue =
               ((Boolean) fields.get(subInfo.getField().getName())).booleanValue();
           booleanMask = booleanMask << 1;
           booleanMask = (booleanMask | (booleanValue ? 1 : 0));
           boolcount++;
         } else if (subInfType == int.class) {
           codec.writeFInt(((Number) fields.get(subInfo.getField().getName())).intValue());
         } else if (subInfType == long.class) {
           codec.writeFLong(((Number) fields.get(subInfo.getField().getName())).longValue());
         } else if (subInfType == byte.class) {
           codec.writeFByte(((Number) fields.get(subInfo.getField().getName())).byteValue());
         } else if (subInfType == char.class) {
           codec.writeFChar((char) ((Number) fields.get(subInfo.getField().getName())).intValue());
         } else if (subInfType == short.class) {
           codec.writeFShort(((Number) fields.get(subInfo.getField().getName())).shortValue());
         } else if (subInfType == float.class) {
           codec.writeFFloat(((Number) fields.get(subInfo.getField().getName())).floatValue());
         } else if (subInfType == double.class) {
           codec.writeFDouble(((Number) fields.get(subInfo.getField().getName())).doubleValue());
         }
       } else {
         // object
         Object subObject = fields.get(subInfo.getField().getName());
         writeObjectWithContext(subInfo, subObject);
       }
     } catch (Exception ex) {
       throw FSTUtil.rethrow(ex);
     }
   }
   if (boolcount > 0) {
     codec.writeFByte(booleanMask << (8 - boolcount));
   }
 }
 private void writeObjectFields(
     Object toWrite,
     FSTClazzInfo serializationInfo,
     FSTClazzInfo.FSTFieldInfo[] fieldInfo,
     int startIndex,
     int version)
     throws IOException {
   try {
     int booleanMask = 0;
     int boolcount = 0;
     final int length = fieldInfo.length;
     int j = startIndex;
     if (!codec.isWritingAttributes()) {
       for (; ; j++) {
         if (j == length || fieldInfo[j].getVersion() != version) {
           if (boolcount > 0) {
             codec.writeFByte(booleanMask << (8 - boolcount));
           }
           break;
         }
         final FSTClazzInfo.FSTFieldInfo subInfo = fieldInfo[j];
         if (subInfo.getIntegralType() != subInfo.BOOL) {
           if (boolcount > 0) {
             codec.writeFByte(booleanMask << (8 - boolcount));
           }
           break;
         } else {
           if (boolcount == 8) {
             codec.writeFByte(booleanMask << (8 - boolcount));
             boolcount = 0;
             booleanMask = 0;
           }
           boolean booleanValue = subInfo.getBooleanValue(toWrite);
           booleanMask = booleanMask << 1;
           booleanMask = (booleanMask | (booleanValue ? 1 : 0));
           boolcount++;
         }
       }
     }
     for (int i = j; i < length; i++) {
       final FSTClazzInfo.FSTFieldInfo subInfo = fieldInfo[i];
       if (subInfo.getVersion() != version) {
         codec.writeVersionTag(subInfo.getVersion());
         writeObjectFields(toWrite, serializationInfo, fieldInfo, i, subInfo.getVersion());
         return;
       }
       codec.writeAttributeName(subInfo);
       if (subInfo.isPrimitive()) {
         // speed safe
         int integralType = subInfo.getIntegralType();
         switch (integralType) {
           case FSTClazzInfo.FSTFieldInfo.BOOL:
             codec.writeFByte(subInfo.getBooleanValue(toWrite) ? 1 : 0);
             break;
           case FSTClazzInfo.FSTFieldInfo.BYTE:
             codec.writeFByte(subInfo.getByteValue(toWrite));
             break;
           case FSTClazzInfo.FSTFieldInfo.CHAR:
             codec.writeFChar((char) subInfo.getCharValue(toWrite));
             break;
           case FSTClazzInfo.FSTFieldInfo.SHORT:
             codec.writeFShort((short) subInfo.getShortValue(toWrite));
             break;
           case FSTClazzInfo.FSTFieldInfo.INT:
             codec.writeFInt(subInfo.getIntValue(toWrite));
             break;
           case FSTClazzInfo.FSTFieldInfo.LONG:
             codec.writeFLong(subInfo.getLongValue(toWrite));
             break;
           case FSTClazzInfo.FSTFieldInfo.FLOAT:
             codec.writeFFloat(subInfo.getFloatValue(toWrite));
             break;
           case FSTClazzInfo.FSTFieldInfo.DOUBLE:
             codec.writeFDouble(subInfo.getDoubleValue(toWrite));
             break;
         }
       } else if (subInfo.isConditional()) {
         final int conditional = codec.getWritten();
         codec.skip(4);
         // object
         Object subObject = subInfo.getObjectValue(toWrite);
         if (subObject == null) {
           codec.writeTag(NULL, null, 0, toWrite);
         } else {
           writeObjectWithContext(subInfo, subObject);
         }
         int v = codec.getWritten();
         codec.writeInt32At(conditional, v);
       } else {
         // object
         Object subObject = subInfo.getObjectValue(toWrite);
         if (subObject == null) {
           codec.writeTag(NULL, null, 0, toWrite);
         } else {
           writeObjectWithContext(subInfo, subObject);
         }
       }
     }
     codec.writeVersionTag((byte) 0);
   } catch (IllegalAccessException ex) {
     throw FSTUtil.rethrow(ex);
   }
 }
  // splitting this slows down ...
  protected void writeObjectWithContext(FSTClazzInfo.FSTFieldInfo referencee, Object toWrite)
      throws IOException {
    int startPosition = codec.getWritten();
    boolean dontShare = objects.disabled;
    objectWillBeWritten(toWrite, startPosition);

    try {
      if (toWrite == null) {
        codec.writeTag(NULL, null, 0, toWrite);
        return;
      }
      final Class clazz = toWrite.getClass();
      if (clazz == String.class) {
        String[] oneOf = referencee.getOneOf();
        if (oneOf != null) {
          for (int i = 0; i < oneOf.length; i++) {
            String s = oneOf[i];
            if (s.equals(toWrite)) {
              codec.writeTag(ONE_OF, oneOf, i, toWrite);
              codec.writeFByte(i);
              return;
            }
          }
        }
        if (dontShare) {
          codec.writeTag(STRING, toWrite, 0, toWrite);
          codec.writeStringUTF((String) toWrite);
          return;
        }
      } else if (clazz == Integer.class) {
        codec.writeTag(BIG_INT, null, 0, toWrite);
        codec.writeFInt(((Integer) toWrite).intValue());
        return;
      } else if (clazz == Long.class) {
        codec.writeTag(BIG_LONG, null, 0, toWrite);
        codec.writeFLong(((Long) toWrite).longValue());
        return;
      } else if (clazz == Boolean.class) {
        codec.writeTag(
            ((Boolean) toWrite).booleanValue() ? BIG_BOOLEAN_TRUE : BIG_BOOLEAN_FALSE,
            null,
            0,
            toWrite);
        return;
      } else if ((referencee.getType() != null && referencee.getType().isEnum())
          || toWrite instanceof Enum) {
        if (!codec.writeTag(ENUM, toWrite, 0, toWrite)) {
          boolean isEnumClass = toWrite.getClass().isEnum();
          if (!isEnumClass) {
            // weird stuff ..
            Class c = toWrite.getClass();
            while (c != null && !c.isEnum()) {
              c = toWrite.getClass().getEnclosingClass();
            }
            if (c == null) {
              throw new RuntimeException("Can't handle this enum: " + toWrite.getClass());
            }
            codec.writeClass(c);
          } else {
            codec.writeClass(getFstClazzInfo(referencee, toWrite.getClass()));
          }
          codec.writeFInt(((Enum) toWrite).ordinal());
        }
        return;
      }

      FSTClazzInfo serializationInfo = getFstClazzInfo(referencee, clazz);
      // check for identical / equal objects
      FSTObjectSerializer ser = serializationInfo.getSer();
      if (!dontShare
          && !referencee.isFlat()
          && !serializationInfo.isFlat()
          && (ser == null || !ser.alwaysCopy())) {
        int handle =
            objects.registerObjectForWrite(toWrite, codec.getWritten(), serializationInfo, tmp);
        // determine class header
        if (handle >= 0) {
          final boolean isIdentical =
              tmp[0] == 0; // objects.getReadRegisteredObject(handle) == toWrite;
          if (isIdentical) {
            //                        System.out.println("POK writeHandle"+handle+"
            // "+toWrite.getClass().getName());
            if (!codec.writeTag(HANDLE, null, handle, toWrite)) codec.writeFInt(handle);
            return;
          }
        }
      }
      if (clazz.isArray()) {
        if (codec.writeTag(ARRAY, toWrite, 0, toWrite))
          return; // some codecs handle primitive arrays like an primitive type
        writeArray(referencee, toWrite);
      } else if (ser == null) {
        // default write object wihtout custom serializer
        // handle write replace
        if (!dontShare) {
          if (serializationInfo.getWriteReplaceMethod() != null) {
            Object replaced = null;
            try {
              replaced = serializationInfo.getWriteReplaceMethod().invoke(toWrite);
            } catch (Exception e) {
              throw FSTUtil.rethrow(e);
            }
            if (replaced != toWrite) {
              toWrite = replaced;
              serializationInfo = getClassInfoRegistry().getCLInfo(toWrite.getClass());
              // fixme: update object map ?
            }
          }
          // clazz uses some JDK special stuff (frequently slow)
          if (serializationInfo.useCompatibleMode() && !serializationInfo.isExternalizable()) {
            writeObjectCompatible(referencee, toWrite, serializationInfo);
            return;
          }
        }
        if (!writeObjectHeader(
            serializationInfo,
            referencee,
            toWrite)) { // skip in case codec can write object as primitive
          defaultWriteObject(toWrite, serializationInfo);
          if (serializationInfo.isExternalizable()) codec.externalEnd(serializationInfo);
        }
      } else { // object has custom serializer
        // Object header (nothing written till here)
        int pos = codec.getWritten();
        if (!writeObjectHeader(
            serializationInfo,
            referencee,
            toWrite)) { // skip in case code can write object as primitive
          // write object depending on type (custom, externalizable, serializable/java, default)
          ser.writeObject(this, toWrite, serializationInfo, referencee, pos);
          codec.externalEnd(serializationInfo);
        }
      }
    } finally {
      objectHasBeenWritten(toWrite, startPosition, codec.getWritten());
    }
  }