예제 #1
0
 protected IEncoder(Schema schema, ArrayAccess arrayAccess, MapAccess mapAccess)
 {
     Schema       = schema;
     _arrayAccess = arrayAccess;
     _mapAccess   = mapAccess;
     _writer      = ResolveWriter(schema);
 }
예제 #2
0
 protected PreresolvingDatumWriter(Schema schema, ArrayAccess arrayAccess, MapAccess mapAccess)
 {
     Schema       = schema;
     _arrayAccess = arrayAccess;
     _mapAccess   = mapAccess;
     _writer      = ResolveWriter(schema);
 }
예제 #3
0
        internal MapViewStream(MemoryMappedFile backingFile, long mapSize, bool isWriteable)
        {
            if (backingFile == null)
            {
                throw new MMException("MapViewStream.MapViewStream - backingFile is null");
            }
            if (!backingFile.IsOpen)
            {
                throw new MMException("MapViewStream.MapViewStream - backingFile is not open");
            }
            if ((mapSize < 1) || (mapSize > backingFile.MaxSize))
            {
                throw new MMException(string.Format("MapViewStream.MapViewStream - mapSize is invalid.  mapSize == {0}, backingFile.MaxSize == {1}", mapSize, backingFile.MaxSize));
            }

            _backingFile = backingFile;
            _isWriteable = isWriteable;
            _access      = isWriteable ? MapAccess.FileMapWrite : MapAccess.FileMapRead;

            _mapSize = mapSize;

            _isOpen = true;



            Seek(0, SeekOrigin.Begin);
        }
        public Stream MapView(MapAccess access, long offset, IntPtr size)
        {
            if (!IsOpen)
            {
                throw new ObjectDisposedException("MMF already closed");
            }

            IntPtr baseAddress = IntPtr.Zero;

            baseAddress = Win32MapApis.MapViewOfFile(
                _hMap, (int)access,
                (int)((offset >> 32) & 0xFFFFFFFF),
                (int)(offset & 0xFFFFFFFF), size
                );

            if (baseAddress == IntPtr.Zero)
            {
                throw new FileMapIOException(Marshal.GetHRForLastWin32Error());
            }

            // Find out what MapProtection to use
            // based on the MapAccess flags...
            MapProtection protection;

            if (access == MapAccess.FileMapRead)
            {
                protection = MapProtection.PageReadOnly;
            }
            else
            {
                protection = MapProtection.PageReadWrite;
            }

            return(new MapViewStream(baseAddress, size.ToInt64(), protection));
        }
예제 #5
0
        /// <summary>
        /// Constructor used internally by MemoryMappedFile.
        /// </summary>
        /// <param name="backingFile">Preconstructed MemoryMappedFile</param>
        /// <param name="mapSize">Size of the view, in bytes.</param>
        /// <param name="isWriteable">True if Read/Write access is desired, False otherwise</param>
        internal MapViewStream(MemoryMappedFile backingFile, long mapSize, bool isWriteable)
        {
            if (backingFile == null)
            {
                throw new Exception("MapViewStream.MapViewStream - backingFile is null");
            }
            if (!backingFile.IsOpen)
            {
                throw new Exception("MapViewStream.MapViewStream - backingFile is not open");
            }
            if ((mapSize < 1) || (mapSize > backingFile.MaxSize))
            {
                throw new Exception(string.Format("MapViewStream.MapViewStream - mapSize is invalid.  mapSize == {0}, backingFile.MaxSize == {1}", mapSize, backingFile.MaxSize));
            }

            _backingFile = backingFile;
            _isWriteable = isWriteable;
            _access      = isWriteable ? MapAccess.FileMapWrite : MapAccess.FileMapRead;
            // Need a backingFile.SupportsAccess function that takes a MapAccess compares it against its stored MapProtection protection and returns bool
            _mapSize = mapSize;

            _isOpen = true;

            // Map the first view

            Seek(0, SeekOrigin.Begin);
        }
예제 #6
0
 public IntPtr Map(MapAccess access)
 {
     unsafe
     {
         var result = Gl.MapBuffer(Target, (uint)access);
         GlHelper.GetError();
         return(new IntPtr(result));
     }
 }
        private object ReadMap(object reuse, Decoder decoder, MapAccess mapAccess, ReadItem valueReader)
        {
            object map = mapAccess.Create(reuse);

            for (int n = (int)decoder.ReadMapStart(); n != 0; n = (int)decoder.ReadMapNext())
            {
                mapAccess.AddElements(map, n, valueReader, decoder, false);
            }
            return(map);
        }
예제 #8
0
        /// <summary>
        ///   Open an existing named File Mapping object
        /// </summary>
        /// <param name="access">desired access to the map</param>
        /// <param name="name">name of object</param>
        /// <returns>The memory mapped file instance</returns>
        public static MemoryMappedFile Open(MapAccess access, String name)
        {
            MemoryMappedFile map = new MemoryMappedFile();

            map._hMap = Win32MapApis.OpenFileMapping((int)access, false, name);
            if (map._hMap == NULL_HANDLE)
                throw new FileMapIOException(Marshal.GetHRForLastWin32Error());

            return map;
        }
예제 #9
0
            /// <summary>
            ///
            /// </summary>
            /// <param name="fileName"></param>
            /// <param name="protection"></param>
            /// <param name="access"></param>
            /// <param name="maxSize"></param>
            /// <param name="name"></param>
            public MemoryMappedFile(String fileName, MapProtection protection, MapAccess access,
                                    long maxSize, String name)
            {
                //try to open the mmf by name. if failed create the file and mmf.
                IntPtr hFile = IntPtr.Zero;

                try
                {
                    m_hMap = Win32MapApis.OpenFileMapping((int)access, false, name);
                    if (m_hMap == NULL_HANDLE)
                    {
                        int desiredAccess = GENERIC_READ;
                        if ((protection == MapProtection.PageReadWrite) ||
                            (protection == MapProtection.PageWriteCopy))
                        {
                            desiredAccess |= GENERIC_WRITE;
                        }
                        hFile = Win32MapApis.CreateFile(
                            GetMMFDir() + fileName, desiredAccess, 0,
                            IntPtr.Zero, OPEN_ALWAYS, 0, IntPtr.Zero
                            );
                        if (hFile != NULL_HANDLE)
                        {
                            m_hMap = Win32MapApis.CreateFileMapping(
                                hFile, IntPtr.Zero, (int)protection,
                                0,
                                (int)(maxSize & 0xFFFFFFFF), name
                                );
                            if (m_hMap != NULL_HANDLE)
                            {
                                m_maxSize = maxSize;
                            }
                            else
                            {
                                throw new FileMapIOException(Marshal.GetHRForLastWin32Error());
                            }
                        }
                        else
                        {
                            throw new FileMapIOException(Marshal.GetHRForLastWin32Error());
                        }
                    }
                }
                catch (Exception Err)
                {
                    throw Err;
                }
                finally
                {
                    if (!(hFile == NULL_HANDLE))
                    {
                        Win32MapApis.CloseHandle(hFile);
                    }
                }
            }
예제 #10
0
        /// <summary>
        ///   Open an existing named File Mapping object
        /// </summary>
        /// <param name="access">desired access to the map</param>
        /// <param name="name">name of object</param>
        /// <returns>The memory mapped file instance</returns>
        public static MemoryMappedFile Open(MapAccess access, String name)
        {
            MemoryMappedFile map = new MemoryMappedFile
            {
                _hMap = Win32MapApis.OpenFileMapping((int)access, false, name)
            };

            if (map._hMap == NULL_HANDLE)
            {
                throw new FileMapIOException(Marshal.GetHRForLastWin32Error());
            }
            map._maxSize = -1; // debug unknown
            return(map);
        }
        /// <summary>
        ///   Open an existing named File Mapping object
        /// </summary>
        /// <param name="access">desired access to the map</param>
        /// <param name="name">name of object</param>
        /// <returns>The memory mapped file instance</returns>
        public static MemoryMappedFile Open(MapAccess access, String name)
        {
            MemoryMappedFile map = new MemoryMappedFile();

            // Debug.Log("mem map start");
            map._hMap = Win32MapApis.OpenFileMapping((int)access, false, name);
            if (map._hMap == NULL_HANDLE)
            {
                // Debug.Log("mem map doesnt exist");
                return(null);
            }
            //throw new FileMapIOException ( Marshal.GetHRForLastWin32Error() );

            return(map);
        }
예제 #12
0
            /// <summary>
            ///
            /// </summary>
            /// <param name="access"></param>
            /// <param name="name"></param>
            public bool Open(MapAccess access, String name)
            {
                bool RV = true;

                try
                {
                    m_hMap = Win32MapApis.OpenFileMapping((int)access, false, name);
                    if (m_hMap == NULL_HANDLE)
                    {
                        RV = false;
                    }
                    return(RV);
                }
                catch
                {
                    return(RV);
                }
            }
예제 #13
0
            /// <summary>
            ///
            /// </summary>
            /// <param name="access"></param>
            /// <param name="offset"></param>
            /// <param name="size"></param>
            /// <param name="path"></param>
            /// <returns></returns>
            public MapViewStream MapView(MapAccess access, long offset, int size, string path)
            {
                IntPtr baseAddress = IntPtr.Zero;

                try
                {
                    baseAddress = Win32MapApis.MapViewOfFile(
                        m_hMap, (int)access,
                        (int)((offset >> 32) & 0xFFFFFFFF),
                        (int)(offset & 0xFFFFFFFF), size
                        );

                    if (baseAddress != IntPtr.Zero)
                    {
                        MapProtection protection;
                        if (access == MapAccess.FileMapRead)
                        {
                            protection = MapProtection.PageReadOnly;
                        }
                        else
                        {
                            protection = MapProtection.PageReadWrite;
                        }

                        if (path != "")
                        {
                            System.IO.FileInfo oFi = new System.IO.FileInfo(GetMMFDir() + path);
                            m_maxSize = (int)oFi.Length;
                        }
                        return(new MapViewStream(baseAddress, m_maxSize, protection));
                    }
                    return(null);
                }
                catch
                {
                    throw new FileMapIOException(Marshal.GetHRForLastWin32Error());
                }
            }
예제 #14
0
        public IntPtr MapView(MapAccess access, long offset, long size)
        {
            if (!IsOpen)
            {
                throw new ObjectDisposedException("Memmoryfile Already closed");
            }


            IntPtr mapSize = new IntPtr(size);

            IntPtr baseAddress = Win32MapApis.MapViewOfFile(
                _hMap, (int)access,
                (int)((offset >> 32) & 0xFFFFFFFF),
                (int)(offset & 0xFFFFFFFF), mapSize
                );

            if (baseAddress == IntPtr.Zero)
            {
                throw new MMException(Marshal.GetHRForLastWin32Error());
            }

            return(baseAddress);
        }
예제 #15
0
        public IntPtr MapView(MapAccess access, long offset, long size)
        {
            if (!IsOpen)
            {
                throw new ObjectDisposedException("Winterdom.IO.FileMap.MemoryMappedFile.MapView - MMF already closed");
            }

            // Throws OverflowException if (a) this is a 32-bit platform AND (b) size is out of bounds (ie. int bounds) with respect to this platform
            IntPtr mapSize = new IntPtr(size);

            IntPtr baseAddress = Win32MapApis.MapViewOfFile(
                _hMap, (int)access,
                (int)((offset >> 32) & 0xFFFFFFFF),
                (int)(offset & 0xFFFFFFFF), mapSize
                );

            if (baseAddress == IntPtr.Zero)
            {
                throw new FileMapIOException(Marshal.GetHRForLastWin32Error());
            }

            return(baseAddress);
        }
예제 #16
0
 public IntPtr Map(int offset, int length, MapAccess access)
 {
     context.Bindings.Buffers.ByTarget(target).Set(this);
     return(GL.MapBufferRange((int)target, (IntPtr)offset, (IntPtr)length, (int)access));
 }
예제 #17
0
        /// <summary>
        ///   Map a view of the file mapping object
        ///   This returns a stream, giving you easy access to the memory,
        ///   as you can use StreamReaders and StreamWriters on top of it
        /// </summary>
        /// <param name="access">desired access to the view</param>
        /// <param name="offset">offset of the file mapping object to 
        ///            start view at</param>
        /// <param name="size">size of the view</param>
        public Stream MapView( MapAccess access, long offset, int size )
        {
            if ( !IsOpen )
            throw new ObjectDisposedException("MMF already closed");

             IntPtr baseAddress = IntPtr.Zero;
             baseAddress = Win32MapApis.MapViewOfFile (
                           _hMap, (int)access,
                           (int)((offset >> 32) & 0xFFFFFFFF),
                           (int)(offset & 0xFFFFFFFF), size
                        );

             if ( baseAddress == IntPtr.Zero )
            throw new FileMapIOException ( Marshal.GetHRForLastWin32Error() );

             // Find out what MapProtection to use
             // based on the MapAccess flags...
             MapProtection protection;
             if ( access == MapAccess.FileMapRead )
            protection = MapProtection.PageReadOnly;
             else
            protection = MapProtection.PageReadWrite;

             return new MapViewStream ( baseAddress, size, protection );
        }
예제 #18
0
        /// <summary>
        ///   Open an existing named File Mapping object
        /// </summary>
        /// <param name="access">desired access to the map</param>
        /// <param name="name">name of object</param>
        /// <returns>The memory mapped file instance</returns>
        public static MemoryMappedFile Open( MapAccess access, String name )
        {
            MemoryMappedFile map = new MemoryMappedFile();

             map._hMap = Win32MapApis.OpenFileMapping ( (int)access, false, name );
             if ( map._hMap == NULL_HANDLE )
            throw new FileMapIOException ( Marshal.GetHRForLastWin32Error() );

             return map;
        }
 /// <summary>
 ///   Map a view of the file mapping object
 ///   This returns a stream, giving you easy access to the memory,
 ///   as you can use StreamReaders and StreamWriters on top of it
 /// </summary>
 /// <param name="access">desired access to the view</param>
 /// <param name="offset">offset of the file mapping object to
 ///            start view at</param>
 /// <param name="size">size of the view</param>
 public Stream MapView(MapAccess access, long offset, int size)
 {
     //  Debug.Log("start mapview with size "+ size);
     return(MapView(access, offset, new IntPtr(size)));
 }
        public IntPtr MapView(MapAccess access, long offset, long size)
        {
            if (!IsOpen)
                throw new ObjectDisposedException("Winterdom.IO.FileMap.MemoryMappedFile.MapView - MMF already closed");

            // Throws OverflowException if (a) this is a 32-bit platform AND (b) size is out of bounds (ie. int bounds) with respect to this platform
            IntPtr mapSize = new IntPtr(size); 

            IntPtr baseAddress = Win32MapApis.MapViewOfFile(
              _hMap, (int)access,
              (int)((offset >> 32) & 0xFFFFFFFF),
              (int)(offset & 0xFFFFFFFF), mapSize
              );

            if (baseAddress == IntPtr.Zero)
                throw new FileMapIOException(Marshal.GetHRForLastWin32Error());

            return baseAddress;

        }
 public static extern byte *MapViewOfFile(SafeFileHandle hFileMappingObject, MapAccess dwDesiredAccess, int dwFileOffsetHigh, int dwFileOffsetLow, IntPtr dwNumBytesToMap);
예제 #22
0
        IntPtr _viewBaseAddr = IntPtr.Zero; // Pointer to the base address of the currently mapped view

        #endregion Fields

        #region Constructors

        /// <summary>
        /// Constructor used internally by MemoryMappedFile.
        /// </summary>
        /// <param name="backingFile">Preconstructed MemoryMappedFile</param>
        /// <param name="mapSize">Size of the view, in bytes.</param>
        /// <param name="isWriteable">True if Read/Write access is desired, False otherwise</param>
        internal MapViewStream(MemoryMappedFile backingFile, long mapSize, bool isWriteable)
        {
            if (backingFile == null)
            {
                throw new Exception("MapViewStream.MapViewStream - backingFile is null");
            }
            if (!backingFile.IsOpen)
            {
                throw new Exception("MapViewStream.MapViewStream - backingFile is not open");
            }
            if ((mapSize < 1) || (mapSize > backingFile.MaxSize))
            {
                throw new Exception(string.Format("MapViewStream.MapViewStream - mapSize is invalid.  mapSize == {0}, backingFile.MaxSize == {1}", mapSize, backingFile.MaxSize));
            }

            _backingFile = backingFile;
            _isWriteable = isWriteable;
            _access = isWriteable ? MapAccess.FileMapWrite : MapAccess.FileMapRead;
            // Need a backingFile.SupportsAccess function that takes a MapAccess compares it against its stored MapProtection protection and returns bool
            _mapSize = mapSize;

            _isOpen = true;

            // Map the first view

            Seek(0, SeekOrigin.Begin);
        }
 /// <summary>
 ///   Map a view of the file mapping object
 ///   This returns a stream, giving you easy access to the memory,
 ///   as you can use StreamReaders and StreamWriters on top of it
 /// </summary>
 /// <param name="access">desired access to the view</param>
 /// <param name="offset">offset of the file mapping object to
 ///            start view at</param>
 /// <param name="size">size of the view</param>
 public Stream MapView(MapAccess access, long offset, int size)
 {
     return(MapView(access, offset, new IntPtr(size)));
 }
예제 #24
0
            /// <summary>
            ///
            /// </summary>
            /// <param name="FileName"></param>
            /// <param name="protection"></param>
            /// <param name="name"></param>
            /// <param name="access"></param>
            /// <returns></returns>
            public bool OpenEx(string FileName, MapProtection protection, string name, MapAccess access)
            {
                bool RV = false;

                m_hMap = Win32MapApis.OpenFileMapping((int)access, false, name);
                if (m_hMap == NULL_HANDLE)
                {
                    if (System.IO.File.Exists(GetMMFDir() + FileName))
                    {
                        long maxSize;
                        System.IO.FileStream stream = System.IO.File.Open(GetMMFDir() + FileName, System.IO.FileMode.Open);
                        maxSize = stream.Length;
                        stream.Close();


                        IntPtr   hFile    = INVALID_HANDLE_VALUE;
                        OFSTRUCT ipStruct = new OFSTRUCT();
                        string   MMFName  = GetMMFDir() + FileName;
                        hFile = Win32MapApis.OpenFile(MMFName,
                                                      ipStruct
                                                      , 2);

                        // determine file access needed
                        // we'll always need generic read access
                        int desiredAccess = GENERIC_READ;
                        if ((protection == MapProtection.PageReadWrite) ||
                            (protection == MapProtection.PageWriteCopy))
                        {
                            desiredAccess |= GENERIC_WRITE;
                        }

                        // open or create the file
                        // if it doesn't exist, it gets created
                        m_hMap = Win32MapApis.CreateFileMapping(
                            hFile, IntPtr.Zero, (int)protection,
                            (int)((maxSize >> 32) & 0xFFFFFFFF),
                            (int)(maxSize & 0xFFFFFFFF), name
                            );

                        // close file handle, we don't need it
                        if (!(hFile == NULL_HANDLE))
                        {
                            Win32MapApis.CloseHandle(hFile);
                        }
                        RV = true;
                    }
                }
                else
                {
                    RV = true;
                }
                return(RV);
            }
예제 #25
0
		/// <summary>
		///   Map a view of the file mapping object
		///   This returns a stream, giving you easy access to the memory,
		///   as you can use StreamReaders and StreamWriters on top of it
		/// </summary>
		/// <param name="access">desired access to the view</param>
		/// <param name="offset">offset of the file mapping object to 
		///            start view at</param>
		/// <param name="size">size of the view</param>
		public Stream MapView(MapAccess access, long offset, int size)
		{
			return MapView(access, offset, new IntPtr(size));
		}
예제 #26
0
파일: Buffer.cs 프로젝트: Zulkir/ObjectGL
 public IntPtr Map(int offset, int length, MapAccess access)
 {
     context.Bindings.Buffers.ByTarget(target).Set(this);
     return GL.MapBufferRange((int)target, (IntPtr)offset, (IntPtr)length, (int)access);
 }