コード例 #1
0
            public static Version2 ReadAfterHeader(
                DSHeader aHeader,
                Hdf5Reader aReader,
                long?aLocalMessageSize,
                out long aBytes)
            {
                int
                    fDimCount = aHeader.Dimensionality;
                long
                    fReadlength = (fDimCount * aReader.SuperBlock.SizeOfLengths);
                Flags
                    fHeaderFlags = (Flags)aHeader.Flags;
                bool
                    fHasMax = fHeaderFlags.HasFlag(Flags.HasMax);

                if (fHasMax)
                {
                    fReadlength *= 2;
                }

                if (aLocalMessageSize.HasValue && aLocalMessageSize.Value < fReadlength)
                {
                    throw new ArgumentException("Specified Local Message Size not long enough");
                }
                DataSpaceType
                    fType;

                switch (aHeader.Type)
                {
                case (byte)DataSpaceType.Scaler:
                case (byte)DataSpaceType.Simple:
                case (byte)DataSpaceType.Null:
                    fType = (DataSpaceType)aHeader.Type;
                    break;

                default:
                    throw new System.IO.InvalidDataException("Unknown DataSpaceType");
                }


                aBytes = fReadlength;

                Dimension[]
                fDimensions = ReadDimensions(
                    aReader,
                    fHasMax,
                    fDimCount);

                return(new Version2(fType, fDimensions));
            }
コード例 #2
0
            public static Version1 ReadAfterHeader(
                DSHeader aHeader,
                Hdf5Reader aReader,
                long?aLocalMessageSize,
                out long aBytes)
            {
                int
                    fDimCount    = aHeader.Dimensionality,
                    fBlockLength = (fDimCount * aReader.SuperBlock.SizeOfLengths);
                long
                    fReadlength = (fDimCount * aReader.SuperBlock.SizeOfLengths) + sizeof(UInt32);

                Flags
                    fHeaderFlags = (Flags)aHeader.Flags;

                if (fHeaderFlags.HasFlag(Flags.HasPermutaions))
                {
                    throw new NotSupportedException("Permutation index not supported");
                }

                bool
                    fHasMax = fHeaderFlags.HasFlag(Flags.HasMax);

                if (fHasMax)
                {
                    fReadlength += fBlockLength;
                }

                if (aLocalMessageSize.HasValue && aLocalMessageSize.Value < fReadlength)
                {
                    throw new ArgumentException("Specified Local Message Size not long enough");
                }

                aReader.ReadUInt32(); //Read reserved byte


                aBytes = fReadlength;


                Dimension[] fDimensions = ReadDimensions(
                    aReader,
                    fHasMax,
                    fDimCount);

                return(new Version1(DataSpaceType.Simple, fDimensions));
            }
コード例 #3
0
ファイル: Dataspace.cs プロジェクト: jneedhamspkt/ndf5
        internal static Dataspace Read(
            Hdf5Reader aReader,
            long?aLocalMessageSize,
            out long aBytes)
        {
            if (aLocalMessageSize.HasValue && aLocalMessageSize.Value < DSHeader.Size)
            {
                throw new ArgumentException("Specified Local Message Size not long enough");
            }
            DSHeader
                fHeader = DSHeader.Read(aReader);
            long
                fMessageBodySize;
            Dataspace
                fToRetrun;
            long?
                fBodySize = aLocalMessageSize.HasValue
                    ? (long?)aLocalMessageSize.Value - DSHeader.Size
                    : null;

            switch (fHeader.Version)
            {
            case 1:
                fToRetrun = Version1.ReadAfterHeader(
                    fHeader,
                    aReader,
                    fBodySize,
                    out fMessageBodySize);
                break;

            case 2:
                fToRetrun = Version2.ReadAfterHeader(
                    fHeader,
                    aReader,
                    fBodySize,
                    out fMessageBodySize);
                break;

            default:
                throw new UnknownMessageVersion <Dataspace>(fHeader.Version);
            }
            aBytes = DSHeader.Size + fMessageBodySize;
            return(fToRetrun);
        }