// Copyright 2015 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "tonic/dart_library_natives.h"

#include "tonic/converter/dart_converter.h"

namespace tonic {

DartLibraryNatives::DartLibraryNatives() {}

DartLibraryNatives::~DartLibraryNatives() {}

void DartLibraryNatives::Register(std::initializer_list<Entry> entries) {
  for (const Entry &entry : entries) {
    symbols_.emplace(entry.native_function, entry.symbol);
    entries_.emplace(entry.symbol, entry);
  }
}

Dart_NativeFunction
DartLibraryNatives::GetNativeFunction(Dart_Handle name, int argument_count,
                                      bool *auto_setup_scope) {
  std::string name_string = StdStringFromDart(name);
  auto it = entries_.find(name_string);
  if (it == entries_.end())
    return nullptr;
  const Entry &entry = it->second;
  if (entry.argument_count != argument_count)
    return nullptr;
  *auto_setup_scope = entry.auto_setup_scope;
  return entry.native_function;
}

const uint8_t *
DartLibraryNatives::GetSymbol(Dart_NativeFunction native_function) {
  auto it = symbols_.find(native_function);
  if (it == symbols_.end())
    return nullptr;
  return reinterpret_cast<const uint8_t *>(it->second);
}

} // namespace tonic
