private static void doPopulateField()

in src/main/java/com/netflix/imflibrary/MXFPropertyPopulator.java [78:253]


    private static void doPopulateField(int byteArraySize, ByteProvider byteProvider, Object object, String fieldName) throws IOException
    {

        try
        {
            Field field = getField(object.getClass(), fieldName);
            field.setAccessible(true);
            if (field.getType() == byte[].class)
            {
                byte[] byteArray = byteProvider.getBytes(byteArraySize);
                field.set(object, byteArray);
            }
            else if (field.getType() == InterchangeObject.InterchangeObjectBO.StrongRef.class)
            {
                byte[] byteArray = byteProvider.getBytes(byteArraySize);
                field.set(object, new InterchangeObject.InterchangeObjectBO.StrongRef(byteArray));
            }
            else if(field.getType() == UL.class){
                byte[] byteArray = byteProvider.getBytes(byteArraySize);
                field.set(object, new UL(byteArray));
            }
            else if (field.getType() == String.class)
            {
                byte[] byteArray = byteProvider.getBytes(byteArraySize);
                Charset charset = getFieldCharset(object, fieldName);
                field.set(object, getString(byteArray, charset));
            }
            else if (field.getType() == CompoundDataTypes.Rational.class)
            {
                CompoundDataTypes.Rational rational = new CompoundDataTypes.Rational(byteProvider);
                field.set(object, rational);
            }
            else if (field.getType() == CompoundDataTypes.Timestamp.class)
            {
                CompoundDataTypes.Timestamp timestamp = new CompoundDataTypes.Timestamp(byteProvider);
                field.set(object, timestamp);
            }
            else if (field.getType() == J2KExtendedCapabilities.class) {
                J2KExtendedCapabilities j2KExtendedCapabilities = new J2KExtendedCapabilities(byteProvider);
                field.set(object, j2KExtendedCapabilities);
            }
            else if (field.getType() == CompoundDataTypes.MXFCollections.MXFCollection.class)
            {
                CompoundDataTypes.MXFCollections.Header cHeader = new CompoundDataTypes.MXFCollections.Header(byteProvider);
                ParameterizedType parameterizedType = (ParameterizedType)field.getGenericType();
                if(parameterizedType.getActualTypeArguments().length > 1)
                {
                    throw new MXFException(String.format("Found %d type arguments, however only 1 is supported at this time",
                            parameterizedType.getActualTypeArguments().length));
                }
                if ((parameterizedType.getActualTypeArguments()[0] == byte[].class) ||
                        (parameterizedType.getActualTypeArguments()[0].toString().equals("byte[]")))
                {
                    List<byte[]> cList = new ArrayList<>();
                    for (long i=0; i<cHeader.getNumberOfElements(); i++)
                    {
                        cList.add(byteProvider.getBytes((int)cHeader.getSizeOfElement()));
                    }
                    field.set(object, new CompoundDataTypes.MXFCollections.MXFCollection<>(cHeader, cList, fieldName));
                }
                else if (parameterizedType.getActualTypeArguments()[0] == Short.class) {
                    List<Short> cList = new ArrayList<>();
                    for (long i=0; i <cHeader.getNumberOfElements(); i++)
                    {
                        cList.add(getShort(byteProvider.getBytes(2), KLVPacket.BYTE_ORDER));
                    }
                    field.set(object, new CompoundDataTypes.MXFCollections.MXFCollection<>(cHeader, cList, fieldName));
                }
                else if (parameterizedType.getActualTypeArguments()[0] == Integer.class)
                {
                    List<Integer> cList = new ArrayList<>();
                    for (long i=0; i<cHeader.getNumberOfElements(); i++)
                    {
                        cList.add(getInt(byteProvider.getBytes(4), KLVPacket.BYTE_ORDER));
                    }
                    field.set(object, new CompoundDataTypes.MXFCollections.MXFCollection<>(cHeader, cList, fieldName));
                }
                else if (parameterizedType.getActualTypeArguments()[0] == InterchangeObject.InterchangeObjectBO.StrongRef.class){
                    List<InterchangeObject.InterchangeObjectBO.StrongRef> cList = new ArrayList<>();
                    for (long i=0; i<cHeader.getNumberOfElements(); i++)
                    {
                        cList.add(new InterchangeObject.InterchangeObjectBO.StrongRef(byteProvider.getBytes((int)cHeader.getSizeOfElement())));
                    }
                    field.set(object, new CompoundDataTypes.MXFCollections.MXFCollection<>(cHeader, cList, fieldName));
                }
                else if (parameterizedType.getActualTypeArguments()[0] == UL.class){
                    List<UL> cList = new ArrayList<>();
                    for (long i=0; i<cHeader.getNumberOfElements(); i++)
                    {
                        cList.add(new UL(byteProvider.getBytes((int)cHeader.getSizeOfElement())));
                    }
                    field.set(object, new CompoundDataTypes.MXFCollections.MXFCollection<>(cHeader, cList, fieldName));
                }
                else if (parameterizedType.getActualTypeArguments()[0] == JPEG2000PictureComponent.JPEG2000PictureComponentBO.class){
                    List<JPEG2000PictureComponent.JPEG2000PictureComponentBO> cList = new ArrayList<>();
                    for (long i=0; i<cHeader.getNumberOfElements(); i++)
                    {
                        cList.add(new JPEG2000PictureComponent.JPEG2000PictureComponentBO(byteProvider.getBytes((int)cHeader.getSizeOfElement())));
                    }
                    field.set(object, new CompoundDataTypes.MXFCollections.MXFCollection<>(cHeader, cList, fieldName));
                }
                else
                {
                    throw new MXFException(String.format("Found unsupported type argument = %s", parameterizedType.getActualTypeArguments()[0].toString()));
                }
            }
            else if (field.getType() == Float.class)
            {
                byte[] byteArray = byteProvider.getBytes(byteArraySize);
                field.set(object, getFloat(byteArray, KLVPacket.BYTE_ORDER));
            }
            else if ((field.getType() == Long.class) && (byteArraySize == 8))
            {// long
                byte[] byteArray = byteProvider.getBytes(byteArraySize);
                field.set(object, getLong(byteArray, KLVPacket.BYTE_ORDER));
            }
            else if ((field.getType() == Long.class) && (byteArraySize == 4))
            {// unsigned int
                byte[] byteArray = byteProvider.getBytes(byteArraySize);
                field.set(object, getUnsignedIntAsLong(byteArray, KLVPacket.BYTE_ORDER));
            }
            else if ((field.getType() == Integer.class) && (byteArraySize == 4))
            {//signed int
                byte[] byteArray = byteProvider.getBytes(byteArraySize);
                field.set(object, getInt(byteArray, KLVPacket.BYTE_ORDER));
            }
            else if ((field.getType() == Integer.class) && (byteArraySize == 2))
            {//unsigned short
                byte[] byteArray = byteProvider.getBytes(byteArraySize);
                field.set(object, getUnsignedShortAsInt(byteArray, KLVPacket.BYTE_ORDER));
            }
            else if ((field.getType() == Short.class) && (byteArraySize == 2))
            {//signed short
                byte[] byteArray = byteProvider.getBytes(byteArraySize);
                field.set(object, getShort(byteArray, KLVPacket.BYTE_ORDER));
            }
            else if ((field.getType() == Short.class) && (byteArraySize == 1))
            {//unsigned byte
                byte[] byteArray = byteProvider.getBytes(byteArraySize);
                field.set(object, getUnsignedByteAsShort(byteArray));
            }
            else if ((field.getType() == Byte.class) && (byteArraySize == 1))
            {//signed byte
                byte[] byteArray = byteProvider.getBytes(byteArraySize);
                field.set(object, getByte(byteArray));
            }
            else if ((field.getType() == Boolean.class) && (byteArraySize == 1))
            {//boolean byte
                byte[] byteArray = byteProvider.getBytes(byteArraySize);
                field.set(object, getBooleanFromByte(byteArray));
            }
            else
            {
                throw new MXFException(String.format("unknown type = %s, size = %d combination encountered for field %s",
                        field.getType().toString(), byteArraySize, fieldName));
            }

        }
        catch(NoSuchFieldException e)
        {
            throw new MXFException(e);
        }
        catch(SecurityException e)
        {
            throw new MXFException(e);
        }
        catch(IllegalAccessException e)
        {
            throw new MXFException(e);
        }
        catch(IllegalArgumentException e)
        {
            throw new MXFException(e);
        }

    }