FileBase::FileBase(int data_fd, int meta_fd, const key_type& key_, const id_type& id_, bool check)
    : m_lock()
    , m_refcount(1)
    , m_header()
    , m_id(id_)
    , m_data_fd(data_fd)
    , m_meta_fd(meta_fd)
    , m_dirty(false)
    , m_check(check)
    , m_stream()
    , m_removed(false)
{
    auto data_stream = std::make_shared<POSIXFileStream>(data_fd);
    auto meta_stream = std::make_shared<POSIXFileStream>(meta_fd);

    key_type data_key, meta_key;
    byte generated_keys[KEY_LENGTH * 3];
    hkdf(key_.data(),
         key_.size(),
         nullptr,
         0,
         id_.data(),
         id_.size(),
         generated_keys,
         sizeof(generated_keys));
    memcpy(data_key.data(), generated_keys, KEY_LENGTH);
    memcpy(meta_key.data(), generated_keys + KEY_LENGTH, KEY_LENGTH);
    memcpy(m_key.data(), generated_keys + 2 * KEY_LENGTH, KEY_LENGTH);
    auto crypt = make_cryptstream_aes_gcm(
        std::move(data_stream), std::move(meta_stream), data_key, meta_key, id_, check);

    m_stream = crypt.first;
    m_header = crypt.second;
    read_header();
}

    iterator insert( const key_type& key)
    {
        if( empty())
        {
            keys().push_back( key);
            return begin();
        }

        if( key.time() < front().time())
        {
            keys().insert( begin(), key);
            return begin();
        }

        if( key.time() > back().time())
        {
            keys().push_back( key);
            return end() - 1;
        }

        iterator it( lower_bound( key.time()));

        if( abs( it->time() - key.time()) <= keyframe_t::time_tolerance())
        {
		    *it = key;
            return it;
        }
        else
            return keys().insert( it, key);
    }

 const key_type& key() {
   if(!reversed_key_) {
     key_.set_bits(0, ary_->lsize(), ary_->inverse_matrix().times(key_));
     reversed_key_ = true;
   }
   return key_;
 }

slirc::channeluser_list::size_type slirc::channeluser_list::erase(const key_type &key) {
	slirc::channeluser_list::size_type ret = baseclass::erase(key);
	if (ret && detacher) {
		key->detach();
	}
	return ret;
}

 void operator()(const key_type &key, std::array<M128I<U>, Rp1> &rk) const
 {
     M128I<std::uint64_t> weyl;
     weyl.set(
         ARSWeylConstantTrait<1>::value, ARSWeylConstantTrait<0>::value);
     std::get<0>(rk).load(key.data());
     generate<1>(rk, weyl, std::integral_constant<bool, 1 < Rp1>());
 }

FileTable::FileTable(int version,
                     std::shared_ptr<FileSystemService> root,
                     const key_type& master_key,
                     uint32_t flags,
                     unsigned block_size,
                     unsigned iv_size)
    : m_flags(flags), m_block_size(block_size), m_iv_size(iv_size), m_root(root)
{
    memcpy(m_master_key.data(), master_key.data(), master_key.size());
    switch (version)
    {
    case 1:
        m_fio.reset(new FileTableIOVersion1(root, is_readonly()));
        break;
    case 2:
        m_fio.reset(new FileTableIOVersion2(root, is_readonly()));
        break;
    default:
        throw InvalidArgumentException("Unknown version");
    }
}

MappingIterator::MappingIterator(const ObjectHandle& containerHandle, const container_type& container,
                                 const key_type& key, const Converters& typeConverters)
    : containerHandle_(containerHandle), container_(container), keys_(container_.keys(PyScript::ScriptErrorPrint())),
      index_(0), key_(key), typeConverters_(typeConverters)
{
	if (!key_.exists())
	{
		index_ = container_.size();
	}
	else
	{
		bool found = false;
		// If the key is not found, then index_ == end
		for (; index_ < keys_.size(); ++index_)
		{
			auto scriptKey = keys_.getItem(index_);
			if (key.compareTo(scriptKey, PyScript::ScriptErrorPrint()) == 0)
			{
				found = true;
				break;
			}
		}

		// HACK NGT-1603 Try to cast key to an index
		// Work-around for how ReflectedPropertyItem::getChild will try to
		// access items with the a string "[index]"
		if (!found)
		{
			Variant result;
			ObjectHandle parentHandle;
			const char* childPath = "";
			const bool success = typeConverters_.toVariant(key_, result, parentHandle, childPath);
			PyScript::ScriptList::size_type fakeIndex = container_.size();
			const bool isIndex = result.tryCast(fakeIndex);

			if (isIndex && (fakeIndex >= 0) && (fakeIndex < container_.size()))
			{
				index_ = fakeIndex;
				key_ = keys_.getItem(index_);
			}
		}
	}
}

    typename Matrix::size_type operator() (key_type const& key) const
    {
	return key.col();
    }

 reference operator[](key_type key) const { return (*internal_vector)[key->id()]; }

 math::natural traits<phys::constraint::unilateral::key>::dimension(key_type k) { return k->dim(); }

 inline friend reference get(const Constrained_edge_map& em, key_type e)
 {
   bool b = em.sm_.property(em.constraint,em.sm_.edge_handle(e.idx())); 
   return b;
 }

 /*!
  * The method finds the attribute value by name.
  *
  * \param key Attribute name.
  * \return Iterator to the found element or \c end() if the attribute with such name is not found.
  */
 const_iterator find(key_type const& key) const
 {
     return find_impl(key.data(), key.size());
 }

 bool operator()(const key_type& x, const key_type& y) const { return x.here() < y.here(); }

int atoi_fast::atoi(const key_type& k, int offset) const
{
   char* string = k.get();
   int l = k.size();
   return atoi((const char*)string, l, offset, 0);
}

 value_type operator[] (const key_type& k) const { return k.get_id(); }

			void init_decrypt(AES_KEY &ctx, const key_type &key, const iv_type &iv)
			{
				AES_set_decrypt_key(&key[0], key.size() * 8, &ctx);
			}

 // The put function is required by the property map concept.
 friend void put(const Extended_face_property_map& map,
                 key_type key, value_type val)
 { key->set_data(val); }

 result_type operator() (key_type const& left, key_type const& right) const
 {
     return left.id() < right.id();
 }

#include <string.h>
#include <errno.h>
#include <vector>
#include <algorithm>
#include <set>

#include <fcntl.h>
#include <unistd.h>

TEST_CASE("File table")
{
    using namespace securefs;
    char dir_template[] = "/tmp/securefs_file_table.XXXXXXX";
    mkdtemp(dir_template);

    key_type master_key;
    id_type null_id, file_id;
    memset(master_key.data(), 0xFF, master_key.size());
    memset(null_id.data(), 0, null_id.size());
    memset(file_id.data(), 0xEE, file_id.size());
    const char* xattr_name = "com.apple.FinderInfo...";
    const securefs::PODArray<char, 32> xattr_value(0x11);

    {
        int tmp_fd = ::open(dir_template, O_RDONLY);
        REQUIRE(tmp_fd >= 0);
        FileTable table(tmp_fd, master_key, 0);
        auto dir = dynamic_cast<Directory*>(table.create_as(null_id, FileBase::DIRECTORY));
        dir->add_entry(".", null_id, FileBase::DIRECTORY);
        dir->add_entry("..", null_id, FileBase::DIRECTORY);
        dir->add_entry("hello", file_id, FileBase::REGULAR_FILE);

 // The get function is required by the property map concept.
 friend reference get(const Extended_face_property_map& /* map */,
                      key_type key)
 {
     return key->data();
 }