
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Copyright 2005-2010 Google, Inc.
// Author: sorenj@google.com (Jeffrey Sorensen)

#ifndef FST_LIB_MAPPED_FILE_H_
#define FST_LIB_MAPPED_FILE_H_

#include <unistd.h>
#include <sys/mman.h>

#include <fst/compat.h>
#include <iostream>
#include <fstream>
#include <sstream>

DECLARE_int32(fst_arch_alignment);  // defined in mapped-file.h

namespace fst {

// A memory region is a simple abstraction for allocated memory or data from
// mmap'ed files.  If mmap equals NULL, then data represents an owned region of
// size bytes.  Otherwise, mmap and size refer to the mapping and data is a
// casted pointer to a region contained within [mmap, mmap + size).
// If size is 0, then mmap refers and data refer to a block of memory managed
// externally by some other allocator.
// offset is used when allocating memory to providing padding for alignment.
struct MemoryRegion {
  void *data;
  void *mmap;
  size_t size;
  int offset;
};

class MappedFile {
 public:
  virtual ~MappedFile();

  void* mutable_data() const {
    return reinterpret_cast<void*>(region_.data);
  }

  const void* data() const {
    return reinterpret_cast<void*>(region_.data);
  }

  // Returns a MappedFile object that contains the contents of the input
  // stream s starting from the current file position with size bytes.
  // the memorymap bool is advisory, and Map will default to allocating and
  // reading.  source needs to contain the filename that was used to open
  // the istream.
  static MappedFile* Map(istream* s, bool memorymap, const string& source,
                         size_t size);

  // Creates a MappedFile object with a new[]'ed block of memory of size.
  // Align can be used to specify a desired block alignment.
  // RECOMMENDED FOR INTERNAL USE ONLY, may change in future releases.
  static MappedFile* Allocate(size_t size, int align = kArchAlignment);

  // Creates a MappedFile object pointing to a borrowed reference to data.
  // This block of memory is not owned by the MappedFile object and will not
  // be freed.
  // RECOMMENDED FOR INTERNAL USE ONLY, may change in future releases.
  static MappedFile* Borrow(void *data);

  static const int kArchAlignment;

 private:
  explicit MappedFile(const MemoryRegion &region);

  MemoryRegion region_;
  DISALLOW_COPY_AND_ASSIGN(MappedFile);
};
}  // namespace fst

#endif  // FST_LIB_MAPPED_FILE_H_
