text,length,is_long_context,metric_val,label_metric
"// Copyright (c) YugaByte, Inc.
//
// 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.
//

#include ""yb/master/master_snapshot_coordinator.h""

#include <unordered_map>

#include <boost/multi_index/composite_key.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/asio/io_context.hpp>

#include ""yb/common/snapshot.h""

#include ""yb/docdb/consensus_frontier.h""
#include ""yb/docdb/doc_key.h""
#include ""yb/docdb/rocksdb_writer.h""
#include ""yb/docdb/value.h""
#include ""yb/docdb/value_type.h""

#include ""yb/master/async_snapshot_tasks.h""
#include ""yb/master/catalog_entity_info.h""
#include ""yb/master/master_error.h""
#include ""yb/master/master_heartbeat.pb.h""
#include ""yb/master/master_util.h""
#include ""yb/master/restoration_state.h""
#include ""yb/master/scoped_leader_shared_lock.h""
#include ""yb/master/snapshot_coordinator_context.h""
#include ""yb/master/snapshot_schedule_state.h""
#include ""yb/master/snapshot_state.h""
#include ""yb/master/sys_catalog_writer.h""

#include ""yb/rpc/poller.h""
#include ""yb/rpc/scheduler.h""

#include ""yb/tablet/operations/snapshot_operation.h""
#include ""yb/tablet/operations/write_operation.h""
#include ""yb/tablet/tablet.h""
#include ""yb/tablet/tablet_snapshots.h""
#include ""yb/tablet/write_query.h""

#include ""yb/util/async_util.h""
#include ""yb/util/flag_tags.h""
#include ""yb/util/pb_util.h""
#include ""yb/util/status_format.h""
#include ""yb/util/status_log.h""
#include ""yb/util/stopwatch.h""

using namespace std::literals;
using namespace std::placeholders;

DECLARE_int32(sys_catalog_write_timeout_ms);

DEFINE_uint64(snapshot_coordinator_poll_interval_ms, 5000,
              ""Poll interval for snapshot coordinator in milliseconds."");

DEFINE_test_flag(bool, skip_sending_restore_finished, false,
                 ""Whether we should skip sending RESTORE_FINISHED to tablets."");

DEFINE_bool(schedule_snapshot_rpcs_out_of_band, true,
            ""Should tablet snapshot RPCs be scheduled out of band from the periodic""
            "" background scheduling."");
TAG_FLAG(schedule_snapshot_rpcs_out_of_band, runtime);

DEFINE_bool(schedule_restoration_rpcs_out_of_band, true,
            ""Should tablet restoration RPCs be scheduled out of band from the periodic""
            "" background scheduling."");
TAG_FLAG(schedule_restoration_rpcs_out_of_band, runtime);

DEFINE_bool(skip_crash_on_duplicate_snapshot, false,
            ""Should we not crash when we get a create snapshot request with the same ""
            ""id as one of the previous snapshots."");
TAG_FLAG(skip_crash_on_duplicate_snapshot, runtime);

DEFINE_test_flag(int32, delay_sys_catalog_restore_on_followers_secs, 0,
                 ""Sleep for these many seconds on followers during sys catalog restore"");
TAG_FLAG(TEST_delay_sys_catalog_restore_on_followers_secs, runtime);

DECLARE_bool(allow_consecutive_restore);

namespace yb {
namespace master {

namespace {

YB_DEFINE_ENUM(Bound, (kFirst)(kLast));

void SubmitWrite(
    docdb::KeyValueWriteBatchPB&& write_batch, int64_t leader_term,
    SnapshotCoordinatorContext* context,
    const std::shared_ptr<Synchronizer>& synchronizer = nullptr) {
  auto query = std::make_unique<tablet::WriteQuery>(
      leader_term, CoarseMonoClock::now() + FLAGS_sys_catalog_write_timeout_ms * 1ms,
      /* context */ nullptr, /* tablet= */ nullptr);
  if (synchronizer) {
    query->set_callback(
        tablet::MakeWeakSynchronizerOperationCompletionCallback(synchronizer));
  }
  *query->operation().AllocateRequest()->mutable_write_batch() = std::move(write_batch);
  context->Submit(query.release()->PrepareSubmit(), leader_term);
}

Status SynchronizedWrite(
    docdb::KeyValueWriteBatchPB&& write_batch, int64_t leader_term, CoarseTimePoint deadline,
    SnapshotCoordinatorContext* context) {
  auto synchronizer = std::make_shared<Synchronizer>();
  SubmitWrite(std::move(write_batch), leader_term, context, synchronizer);
  return synchronizer->WaitUntil(ToSteady(deadline));
}

struct RestorationData {
  TxnSnapshotId snapshot_id;
  TxnSnapshotRestorationId restoration_id;
  HybridTime restore_at;
  std::optional<int64_t> db_oid;
};

struct NoOp {
  template <class... Args>
  void operator()(Args&&... args) const {}
};

// Utility to create callback that is invoked when operation done.
// Finds appropriate entry in passed collection and invokes Done on it.
template <class Collection, class PostProcess = NoOp>
auto MakeDoneCallback(
    std::mutex* mutex, const Collection& collection, const typename Collection::key_type& key,
    const TabletId& tablet_id, const PostProcess& post_process = PostProcess()) {
  struct DoneFunctor {
    std::mutex& mutex;
    const Collection& collection;
    typename Collection::key_type key;
    TabletId tablet_id;
    PostProcess post_process;

    void operator()(Result<const tserver::TabletSnapshotOpResponsePB&> resp) const {
      std::unique_lock<std::mutex> lock(mutex);
      auto it = collection.find(key);
      if (it == collection.end()) {
        LOG(DFATAL) << ""Received reply for unknown "" << key;
        return;
      }

      (**it).Done(tablet_id, ResultToStatus(resp));
      post_process(it->get(), &lock);
    }
  };

  return DoneFunctor {
    .mutex = *mutex,
    .collection = collection,
    .key = key,
    .tablet_id = tablet_id,
    .post_process = post_process,
  };
}

} // namespace

class MasterSnapshotCoordinator::Impl {
 public:
  explicit Impl(SnapshotCoordinatorContext* context, enterprise::CatalogManager* cm)
      : context_(*context), cm_(cm), poller_(std::bind(&Impl::Poll, this)) {}

  Result<TxnSnapshotId> Create(
      const SysRowEntries& entries, bool imported, int64_t leader_term, CoarseTimePoint deadline) {
    auto synchronizer = std::make_shared<Synchronizer>();
    auto snapshot_id = TxnSnapshotId::GenerateRandom();
    SubmitCreate(
        entries, imported, SnapshotScheduleId::Nil(), HybridTime::kInvalid, snapshot_id,
        leader_term,
        tablet::MakeWeakSynchronizerOperationCompletionCallback(synchronizer));
    RETURN_NOT_OK(synchronizer->WaitUntil(ToSteady(deadline)));

    return snapshot_id;
  }

  Result<TxnSnapshotId> CreateForSchedule(
      const SnapshotScheduleId& schedule_id, int64_t leader_term, CoarseTimePoint deadline) {
    boost::optional<SnapshotScheduleOperation> operation;
    {
      std::lock_guard<std::mutex> lock(mutex_);
      auto it = schedules_.find(schedule_id);
      if (it == schedules_.end()) {
        return STATUS_FORMAT(NotFound, ""Unknown snapshot schedule: $0"", schedule_id);
      }
      auto* last_snapshot = BoundingSnapshot((**it).id(), Bound::kLast);
      auto last_snapshot_time = last_snapshot ? last_snapshot->snapshot_hybrid_time()
                                              : HybridTime::kInvalid;
      auto creating_snapshot_data = (**it).creating_snapshot_data();
      if (creating_snapshot_data.snapshot_id) {
        auto snapshot_it = snapshots_.find(creating_snapshot_data.snapshot_id);
        if (snapshot_it != snapshots_.end()) {
          VLOG(2) << __func__ << "" for "" << schedule_id << "" while creating snapshot: ""
                  << (**snapshot_it).ToString();
        } else {
          auto passed = CoarseMonoClock::now() - creating_snapshot_data.start_time;
          auto message = Format(
              ""$0 for $1 while creating unknown snapshot: $2 (passed $3)"",
              __func__, schedule_id, creating_snapshot_data.snapshot_id, passed);
          if (passed > 30s) {
            LOG(DFATAL) << message;
          } else {
            VLOG(2) << message;
          }
        }
      }
      operation = VERIFY_RESULT((**it).ForceCreateSnapshot(last_snapshot_time));
    }

    auto synchronizer = std::make_shared<Synchronizer>();
    RETURN_NOT_OK(ExecuteScheduleOperation(*operation, leader_term, synchronizer));
    RETURN_NOT_OK(synchronizer->WaitUntil(ToSteady(deadline)));

    return operation->snapshot_id;
  }

  Status CreateReplicated(
      int64_t leader_term, const tablet::SnapshotOperation& operation) {
    // TODO(txn_backup) retain logs with this operation while doing snapshot
    auto id = VERIFY_RESULT(FullyDecodeTxnSnapshotId(operation.request()->snapshot_id()));

    VLOG(1) << __func__ << ""("" << id << "", "" << operation.ToString() << "")"";

    auto snapshot = std::make_unique<SnapshotState>(
        &context_, id, *operation.request(),
        GetRpcLimit(FLAGS_max_concurrent_snapshot_rpcs,
                    FLAGS_max_concurrent_snapshot_rpcs_per_tserver, leader_term));

    TabletSnapshotOperations operations;
    docdb::KeyValueWriteBatchPB write_batch;
    RETURN_NOT_OK(snapshot->StoreToWriteBatch(&write_batch));
    boost::optional<tablet::CreateSnapshotData> sys_catalog_snapshot_data;
    bool snapshot_empty = false;
    {
      std::lock_guard<std::mutex> lock(mutex_);
      auto emplace_result = snapshots_.emplace(std::move(snapshot));
      if (!emplace_result.second) {
        LOG(INFO) << ""Received a duplicate create snapshot request for id: "" << id;
        if (FLAGS_skip_crash_on_duplicate_snapshot) {
          LOG(INFO) << ""Skipping duplicate create snapshot request gracefully."";
          return Status::OK();
        } else {
          return STATUS_FORMAT(IllegalState, ""Duplicate snapshot id: $0"", id);
        }
      }

      if (leader_term >= 0) {
        (**emplace_result.first).PrepareOperations(&operations);
      }
      auto temp = (**emplace_result.first).SysCatalogSnapshotData(operation);
      if (temp.ok()) {
        sys_catalog_snapshot_data = *temp;
      } else if (!temp.status().IsUninitialized()) {
        return temp.status();
      }
      snapshot_empty = (**emplace_result.first).Empty();
    }

    RETURN_NOT_OK(operation.tablet()->ApplyOperation(operation, /* batch_idx= */ -1, write_batch));
    if (sys_catalog_snapshot_data) {
      RETURN_NOT_OK(operation.tablet()->snapshots().Create(*sys_catalog_snapshot_data));
    }

    ExecuteOperations(operations, leader_term);

    if (leader_term >= 0 && snapshot_empty) {
      // There could be snapshot for 0 tables, so they should be marked as complete right after
      // creation.
      UpdateSnapshotIfPresent(id, leader_term);
    }

    return Status::OK();
  }

  void UpdateSnapshotIfPresent(const TxnSnapshotId& id, int64_t leader_term)
      NO_THREAD_SAFETY_ANALYSIS EXCLUDES(mutex_) {
    std::unique_lock<std::mutex> lock(mutex_);
    auto it = snapshots_.find(id);
    if (it != snapshots_.end()) {
      UpdateSnapshot(it->get(), leader_term, &lock);
    }
  }

  template <class Pb, class Map>
  Status LoadEntryOfType(
      tablet::Tablet* tablet, const SysRowEntryType& type, Map* m) REQUIRES(mutex_) {
    return EnumerateSysCatalog(tablet, context_.schema(), type,
        [this, &m](const Slice& id, const Slice& data) NO_THREAD_SAFETY_ANALYSIS -> Status {
          return LoadEntry<Pb>(id, data, m);
    });
  }

  Status Load(tablet::Tablet* tablet) {
    std::lock_guard<std::mutex> lock(mutex_);
    RETURN_NOT_OK(LoadEntryOfType<SysSnapshotEntryPB>(
        tablet, SysRowEntryType::SNAPSHOT, &snapshots_));
    RETURN_NOT_OK(LoadEntryOfType<SnapshotScheduleOptionsPB>(
        tablet, SysRowEntryType::SNAPSHOT_SCHEDULE, &schedules_));
    return LoadEntryOfType<SysRestorationEntryPB>(
        tablet, SysRowEntryType::SNAPSHOT_RESTORATION, &restorations_);
  }

  Status ApplyWritePair(Slice key, const Slice& value) {
    docdb::SubDocKey sub_doc_key;
    RETURN_NOT_OK(sub_doc_key.FullyDecodeFrom(key, docdb::HybridTimeRequired::kFalse));

    if (sub_doc_key.doc_key().has_cotable_id()) {
      return Status::OK();
    }

    if (sub_doc_key.doc_key().range_group().size() != 2) {
      LOG(DFATAL) << ""Unexpected size of range group in sys catalog entry (2 expected): ""
                  << AsString(sub_doc_key.doc_key().range_group()) << ""("" << sub_doc_key.ToString()
                  << "")"";
      return Status::OK();
    }

    auto first_key = sub_doc_key.doc_key().range_group().front();
    if (first_key.type() != docdb::KeyEntryType::kInt32) {
      LOG(DFATAL) << ""Unexpected value type for the first range component of sys catalog entry ""
                  << ""(kInt32 expected): ""
                  << AsString(sub_doc_key.doc_key().range_group());;
    }

    switch (first_key.GetInt32()) {
      case SysRowEntryType::SNAPSHOT:
        return DoApplyWrite<SysSnapshotEntryPB>(
            sub_doc_key.doc_key().range_group()[1].GetString(), value, &snapshots_);

      case SysRowEntryType::SNAPSHOT_SCHEDULE:
        return DoApplyWrite<SnapshotScheduleOptionsPB>(
            sub_doc_key.doc_key().range_group()[1].GetString(), value, &schedules_);

      case SysRowEntryType::SNAPSHOT_RESTORATION:
        return DoApplyWrite<SysRestorationEntryPB>(
            sub_doc_key.doc_key().range_group()[1].GetString(), value, &restorations_);

      default:
        return Status::OK();
    }
  }

  template <class Pb, class Map>
  Status DoApplyWrite(const std::string& id_str, const Slice& value, Map* map) {
    docdb::Value decoded_value;
    RETURN_NOT_OK(decoded_value.Decode(value));

    auto value_type = decoded_value.primitive_value().value_type();

    if (value_type == docdb::ValueEntryType::kTombstone) {
      std::lock_guard<std::mutex> lock(mutex_);
      auto id = Uuid::TryFullyDecode(id_str);
      if (id.IsNil()) {
        LOG(WARNING) << ""Unable to decode id: "" << id_str;
        return Status::OK();
      }
      bool erased = map->erase(typename Map::key_type(id)) != 0;
      LOG_IF(DFATAL, !erased) << ""Unknown entry tombstoned: "" << id.ToString();
      return Status::OK();
    }

    if (value_type != docdb::ValueEntryType::kString) {
      return STATUS_FORMAT(
          Corruption,
          ""Bad value type: $0, expected kString while replaying write for sys catalog"",
          decoded_value.primitive_value().value_type());
    }

    std::lock_guard<std::mutex> lock(mutex_);
    return LoadEntry<Pb>(id_str, decoded_value.primitive_value().GetString(), map);
  }

  Status ListSnapshots(
      const TxnSnapshotId& snapshot_id, bool list_deleted, ListSnapshotsResponsePB* resp) {
    std::lock_guard<std::mutex> lock(mutex_);
    if (snapshot_id.IsNil()) {
      for (const auto& p : snapshots_.get<ScheduleTag>()) {
        if (!list_deleted) {
          auto aggreaged_state = p->AggregatedState();
          if (aggreaged_state.ok() && *aggreaged_state == SysSnapshotEntryPB::DELETED) {
            continue;
          }
        }
        RETURN_NOT_OK(p->ToPB(resp->add_snapshots()));
      }
      return Status::OK();
    }

    SnapshotState& snapshot = VERIFY_RESULT(FindSnapshot(snapshot_id));
    return snapshot.ToPB(resp->add_snapshots());
  }

  Status Delete(
      const TxnSnapshotId& snapshot_id, int64_t leader_term, CoarseTimePoint deadline) {
    VLOG_WITH_FUNC(4) << snapshot_id << "", "" << leader_term;

    {
      std::lock_guard<std::mutex> lock(mutex_);
      SnapshotState& snapshot = VERIFY_RESULT(FindSnapshot(snapshot_id));
      RETURN_NOT_OK(snapshot.TryStartDelete());
    }

    auto synchronizer = std::make_shared<Synchronizer>();
    SubmitDelete(snapshot_id, leader_term, synchronizer);
    return synchronizer->WaitUntil(ToSteady(deadline));
  }

  Status DeleteReplicated(
      int64_t leader_term, const tablet::SnapshotOperation& operation) {
    auto snapshot_id = VERIFY_RESULT(FullyDecodeTxnSnapshotId(operation.request()->snapshot_id()));
    VLOG_WITH_FUNC(4) << leader_term << "", "" << snapshot_id;

    docdb::KeyValueWriteBatchPB write_batch;
    TabletSnapshotOperations operations;
    bool delete_sys_catalog_snapshot;
    {
      std::lock_guard<std::mutex> lock(mutex_);
      SnapshotState& snapshot = VERIFY_RESULT(FindSnapshot(snapshot_id));
      if (snapshot.schedule_id()) {
        delete_sys_catalog_snapshot = true;
      }
      snapshot.SetInitialTabletsState(SysSnapshotEntryPB::DELETING);
      RETURN_NOT_OK(snapshot.StoreToWriteBatch(&write_batch));
      if (leader_term >= 0) {
        snapshot.PrepareOperations(&operations);
      }
    }

    if (delete_sys_catalog_snapshot) {
      RETURN_NOT_OK(operation.tablet()->snapshots().Delete(operation));
    }

    RETURN_NOT_OK(operation.tablet()->ApplyOperation(operation, /* batch_idx= */ -1, write_batch));

    ExecuteOperations(operations, leader_term);

    return Status::OK();
  }

  Status RestoreSysCatalogReplicated(
      int64_t leader_term, const tablet::SnapshotOperation& operation, Status* complete_status) {
    auto restoration = std::make_shared<SnapshotScheduleRestoration>(SnapshotScheduleRestoration {
      .snapshot_id = VERIFY_RESULT(FullyDecodeTxnSnapshotId(operation.request()->snapshot_id())),
      .restore_at = HybridTime::FromPB(operation.request()->snapshot_hybrid_time()),
      .restoration_id = VERIFY_RESULT(FullyDecodeTxnSnapshotRestorationId(
          operation.request()->restoration_id())),
      .op_id = operation.op_id(),
      .write_time = operation.hybrid_time(),
      .term = leader_term,
      .schedules = {},
      .non_system_obsolete_tablets = {},
      .non_system_obsolete_tables = {},
      .non_system_objects_to_restore = {},
      .existing_system_tables = {},
      .restoring_system_tables = {},
    });
    {
      std::lock_guard<std::mutex> lock(mutex_);
      SnapshotState& snapshot = VERIFY_RESULT(FindSnapshot(restoration->snapshot_id));
      SnapshotScheduleState& schedule_state = VERIFY_RESULT(
          FindSnapshotSchedule(snapshot.schedule_id()));
      LOG(INFO) << ""Restore sys catalog from snapshot: "" << snapshot.ToString() << "", schedule: ""
                << schedule_state.ToString() << "" at "" << restoration->restore_at << "", op id: ""
                << restoration->op_id;
      size_t this_idx = std::numeric_limits<size_t>::max();
      for (const auto& snapshot_schedule : schedules_) {
        if (snapshot_schedule->id() == snapshot.schedule_id()) {
          this_idx = restoration->schedules.size();
        }
        restoration->schedules.emplace_back(
            snapshot_schedule->id(), snapshot_schedule->options().filter());
      }
      if (this_idx == std::numeric_limits<size_t>::max()) {
        return STATUS_FORMAT(IllegalState, ""Cannot find schedule for restoration: $0"",
                             snapshot.schedule_id());
      }
      std::swap(restoration->schedules[0], restoration->schedules[this_idx]);
    }
    // Inject artificial delay on followers for tests.
    if (leader_term < 0 && FLAGS_TEST_delay_sys_catalog_restore_on_followers_secs > 0) {
      SleepFor(MonoDelta::FromSeconds(FLAGS_TEST_delay_sys_catalog_restore_on_followers_secs));
    }
    // Disable concurrent RPCs to the master leader for the duration of sys catalog restore.
    if (leader_term >= 0) {
      context_.PrepareRestore();
    }
    LOG_SLOW_EXECUTION(INFO, 1000, ""Restore sys catalog took"") {
      RETURN_NOT_OK_PREPEND(
          context_.RestoreSysCatalog(restoration.get(), operation.tablet(), complete_status),
          ""Restore sys catalog failed"");
    }
    return Status::OK();
  }

  Status ListRestorations(
      const TxnSnapshotRestorationId& restoration_id, const TxnSnapshotId& snapshot_id,
      ListSnapshotRestorationsResponsePB* resp) {
    std::lock_guard<std::mutex> lock(mutex_);
    if (!restoration_id) {
      for (const auto& p : restorations_) {
        if (!snapshot_id || p->snapshot_id() == snapshot_id) {
          RETURN_NOT_OK(p->ToPB(resp->add_restorations()));
        }
      }
      return Status::OK();
    }

    RestorationState& restoration = VERIFY_RESULT(FindRestoration(restoration_id));
    return restoration.ToPB(resp->add_restorations());
  }

  Result<TxnSnapshotRestorationId> Restore(
      const TxnSnapshotId& snapshot_id, HybridTime restore_at, int64_t leader_term) {
    auto restoration_id = TxnSnapshotRestorationId::GenerateRandom();
    RETURN_NOT_OK(DoRestore(
        snapshot_id, restore_at, restoration_id, RestorePhase::kInitial, leader_term));
    return restoration_id;
  }

  Result<SnapshotScheduleId> CreateSchedule(
      const CreateSnapshotScheduleRequestPB& req, int64_t leader_term, CoarseTimePoint deadline) {
    SnapshotScheduleState schedule(&context_, req);

    docdb::KeyValueWriteBatchPB write_batch;
    RETURN_NOT_OK(schedule.StoreToWriteBatch(&write_batch));

    RETURN_NOT_OK(SynchronizedWrite(std::move(write_batch), leader_term, deadline, &context_));

    return schedule.id();
  }

  Status ListSnapshotSchedules(
      const SnapshotScheduleId& snapshot_schedule_id, ListSnapshotSchedulesResponsePB* resp) {
    std::lock_guard<std::mutex> lock(mutex_);
    if (snapshot_schedule_id.IsNil()) {
      for (const auto& p : schedules_) {
        RETURN_NOT_OK(FillSchedule(*p, resp->add_schedules()));
      }
      return Status::OK();
    }

    SnapshotScheduleState& schedule = VERIFY_RESULT(FindSnapshotSchedule(snapshot_schedule_id));
    return FillSchedule(schedule, resp->add_schedules());
  }

  Status DeleteSnapshotSchedule(
      const SnapshotScheduleId& snapshot_schedule_id, int64_t leader_term,
      CoarseTimePoint deadline) {
    docdb::KeyValueWriteBatchPB write_batch;
    {
      std::lock_guard<std::mutex> lock(mutex_);
      SnapshotScheduleState& schedule = VERIFY_RESULT(FindSnapshotSchedule(snapshot_schedule_id));
      auto encoded_key = VERIFY_RESULT(schedule.EncodedKey());
      auto pair = write_batch.add_write_pairs();
      pair->set_key(encoded_key.AsSlice().cdata(), encoded_key.size());
      auto options = schedule.options();
      options.set_delete_time(context_.Clock()->Now().ToUint64());
      auto* value = pair->mutable_value();
      value->push_back(docdb::ValueEntryTypeAsChar::kString);
      RETURN_NOT_OK(pb_util::AppendPartialToString(options, value));
    }

    return SynchronizedWrite(std::move(write_batch), leader_term, deadline, &context_);
  }

  Status FillHeartbeatResponse(TSHeartbeatResponsePB* resp) {
    std::lock_guard<std::mutex> lock(mutex_);
    auto* out = resp->mutable_snapshots_info();
    for (const auto& schedule : schedules_) {
      // Don't send deleted schedules.
      if (schedule->deleted()) {
        continue;
      }
      const auto& id = schedule->id();
      auto* out_schedule = out->add_schedules();
      out_schedule->set_id(id.data(), id.size());
      auto time = LastSnapshotTime(id);
      if (time) {
        out_schedule->set_last_snapshot_hybrid_time(time.ToUint64());
      }
    }
    out->set_last_restorations_update_ht(last_restorations_update_ht_.ToUint64());
    for (const auto& restoration : restorations_) {
      auto* out_restoration = out->add_restorations();
      const auto& id = restoration->restoration_id();
      out_restoration->set_id(id.data(), id.size());
      auto complete_time = restoration->complete_time();
      if (complete_time) {
        out_restoration->set_complete_time_ht(complete_time.ToUint64());
      }
    }
    return Status::OK();
  }

  void VerifyRestoration(RestorationState* restoration) REQUIRES(mutex_) {
    auto schedule_result = FindSnapshotSchedule(restoration->schedule_id());
    LOG_IF(DFATAL, !schedule_result.ok())
        << ""Snapshot schedule not found for pending restore with id ""
        << restoration->restoration_id() << "", status: "" << schedule_result.status();
    auto status = context_.VerifyRestoredObjects(
        restoration->MasterMetadata(), (*schedule_result).options().filter().tables().tables());
    LOG_IF(DFATAL, !status.ok()) << ""Verify restoration failed: "" << status;
    LOG(INFO) << ""PITR: Master metadata verified successsfully for restoration ""
              << restoration->restoration_id();
  }

  boost::optional<yb::master::SnapshotState&> ValidateRestoreAndGetSnapshot(
      RestorationState* restoration) REQUIRES(mutex_) {
    // Ignore if already completed.
    if (restoration->complete_time()) {
      return boost::none;
    }
    // If the restore is still undergoing the sys catalog phase.
    if (!restoration->IsSysCatalogRestorationDone()) {
      return boost::none;
    }
    // If the snapshot to restore is not ok.
    auto snapshot = FindSnapshot(restoration->snapshot_id());
    if (!snapshot.ok()) {
      LOG(DFATAL) << ""Snapshot not found for pending restore with id ""
                  << restoration->restoration_id();
      return boost::none;
    }

    return *snapshot;
  }

  void SendPendingRestoreRpcs(
      const vector<RestorationData>& postponed_restores, int64_t term) {
    for (const auto& restoration : postponed_restores) {
      LOG(INFO) << ""PITR: Issuing pending tserver RPCs for restoration ""
                << restoration.restoration_id;
      auto status = DoRestore(restoration.snapshot_id, restoration.restore_at,
                              restoration.restoration_id,
                              RestorePhase::kPostSysCatalogLoad, term,
                              restoration.db_oid);
      LOG_IF(DFATAL, !status.ok())
          << ""Failed to restore tablets for restoration ""
          << restoration.restoration_id << "": "" << status;
    }
  }

  std::optional<int64_t> ComputeDbOid(RestorationState* restoration) REQUIRES(mutex_) {
    std::optional<int64_t> db_oid;
    bool contains_sequences_data = false;
    for (const auto& id_and_type : restoration->MasterMetadata()) {
      if (id_and_type.second == SysRowEntryType::NAMESPACE &&
          id_and_type.first == kPgSequencesDataNamespaceId) {
        contains_sequences_data = true;
      }
    }
    if (contains_sequences_data) {
      for (const auto& id_and_type : restoration->MasterMetadata()) {
        if (id_and_type.second == SysRowEntryType::NAMESPACE &&
            id_and_type.first != kPgSequencesDataNamespaceId) {
          auto db_oid_res = GetPgsqlDatabaseOid(id_and_type.first);
          LOG_IF(DFATAL, !db_oid_res.ok())
              << ""Unable to obtain db_oid for namespace id ""
              << id_and_type.first << "": "" << db_oid_res.status();
          db_oid = static_cast<int64_t>(*db_oid_res);
          LOG(INFO) << ""DB OID of restoring database "" << *db_oid;
          // TODO(Sanket): In future can enhance to pass a list of db_oids.
          break;
        }
      }
      LOG_IF(DFATAL, !db_oid)
          << ""Unable to fetch db oid for the restoring database"";
    }
    return db_oid;
  }

  void SysCatalogLoaded(int64_t term) {
    if (term == OpId::kUnknownTerm) {
      // Do nothing on follower.
      return;
    }
    // Issue pending restoration rpcs.
    vector<RestorationData> postponed_restores;
    {
      std::lock_guard<decltype(mutex_)> lock(mutex_);
      // TODO(pitr) cancel restorations.
      for (const auto& restoration : restorations_) {
        auto snapshot = ValidateRestoreAndGetSnapshot(restoration.get());
        if (!snapshot) {
          continue;
        }
        // If it is PITR restore, then verify restoration and add to the queue for rpcs.
        if (!restoration->schedule_id().IsNil()) {
          VerifyRestoration(restoration.get());
          auto db_oid = ComputeDbOid(restoration.get());
          postponed_restores.push_back(RestorationData {
            .snapshot_id = restoration->snapshot_id(),
            .restoration_id = restoration->restoration_id(),
            .restore_at = restoration->restore_at(),
            .db_oid = db_oid,
          });
        }
        // Set the throttling limits.
        restoration->Throttler().RefreshLimit(
            GetRpcLimit(FLAGS_max_concurrent_restoration_rpcs,
                        FLAGS_max_concurrent_restoration_rpcs_per_tserver, term));
        // Set the current term so that the snapshot coordinator can pick it up.
        restoration->SetLeaderTerm(term);
      }
    }
    SendPendingRestoreRpcs(postponed_restores, term);
  }

  Result<SnapshotSchedulesToObjectIdsMap> MakeSnapshotSchedulesToObjectIdsMap(
      SysRowEntryType type) {
    std::vector<std::pair<SnapshotScheduleId, SnapshotScheduleFilterPB>> schedules;
    {
      std::lock_guard<std::mutex> lock(mutex_);
      for (const auto& schedule : schedules_) {
        if (!schedule->deleted()) {
          schedules.emplace_back(schedule->id(), schedule->options().filter());
        }
      }
    }
    SnapshotSchedulesToObjectIdsMap result;
    for (const auto& id_and_filter : schedules) {
      auto entries = VERIFY_RESULT(CollectEntries(id_and_filter.second));
      auto& ids = result[id_and_filter.first];
      for (const auto& entry : entries.entries()) {
        if (entry.type() == type) {
          ids.push_back(entry.id());
        }
      }
      std::sort(ids.begin(), ids.end());
    }
    return result;
  }

  Result<bool> IsTableCoveredBySomeSnapshotSchedule(const TableInfo& table_info) {
    auto lock = table_info.LockForRead();
    {
      std::lock_guard<std::mutex> l(mutex_);
      for (const auto& schedule : schedules_) {
        for (const auto& table_identifier : schedule->options().filter().tables().tables()) {
          if (VERIFY_RESULT(TableMatchesIdentifier(table_info.id(),
                                                   lock->pb,
                                                   table_identifier))) {
            return true;
          }
        }
      }
    }
    return false;
  }

  bool IsPitrActive() {
    std::lock_guard<std::mutex> lock(mutex_);
    for (const auto& schedule : schedules_) {
      if (!schedule->deleted()) {
        return true;
      }
    }
    return false;
  }

  Result<docdb::KeyValuePairPB> UpdateRestorationAndGetWritePair(
      SnapshotScheduleRestoration* restoration) {
    std::lock_guard<decltype(mutex_)> lock(mutex_);
    RestorationState* restoration_ptr =
        VERIFY_RESULT(GetRestorationPtrOrNull(restoration->restoration_id));
    // Won't be found on followers.
    if (!restoration_ptr) {
      LOG(INFO) << ""Constructing new restoration state for id "" << restoration->restoration_id;
      SnapshotState& snapshot = VERIFY_RESULT(FindSnapshot(restoration->snapshot_id));
      if (!VERIFY_RESULT(snapshot.Complete())) {
        return STATUS(IllegalState, ""The snapshot state is not complete"",
                      restoration->snapshot_id.ToString(),
                      MasterError(MasterErrorPB::SNAPSHOT_IS_NOT_READY));
      }
      auto restoration_state = std::make_unique<RestorationState>(
          &context_, restoration->restoration_id, &snapshot,
          restoration->restore_at, IsSysCatalogRestored::kTrue,
          GetRpcLimit(FLAGS_max_concurrent_restoration_rpcs,
                      FLAGS_max_concurrent_restoration_rpcs_per_tserver, restoration->term));
      restoration_ptr = restorations_.emplace(std::move(restoration_state)).first->get();
    }
    // Set the phase to post sys catalog restoration.
    restoration_ptr->SetSysCatalogRestored(IsSysCatalogRestored::kTrue);
    // Reset the tablet list since it could have changed from the time of snapshot
    // to restoration time. Also, set the metadata for verifying restoration
    // post sys catalog load.
    std::vector<TabletId> restore_tablets;
    for (const auto& id_and_type : restoration->non_system_objects_to_restore) {
      restoration_ptr->MutableMasterMetadata()->emplace(id_and_type.first, id_and_type.second);
      if (id_and_type.second == SysRowEntryType::TABLET) {
        restore_tablets.push_back(id_and_type.first);
      }
    }
    LOG(INFO) << ""PITR: "" << restoration->restoration_id
              << "", tablets to restore: "" << AsString(restore_tablets);
    restoration_ptr->InitTabletIds(restore_tablets);
    // Prepare write batch.
    docdb::KeyValuePairPB restore_kv;
    RETURN_NOT_OK(restoration_ptr->StoreToKeyValuePair(&restore_kv));

    return restore_kv;
  }

  void Start() {
    {
      std::lock_guard<std::mutex> lock(mutex_);
      last_restorations_update_ht_ = context_.Clock()->Now();
    }
    poller_.Start(&context_.Scheduler(), FLAGS_snapshot_coordinator_poll_interval_ms * 1ms);
  }

  void Shutdown() {
    poller_.Shutdown();
  }

 private:
  template <class Pb, class Map>
  Status LoadEntry(const Slice& id_slice, const Slice& data, Map* map) REQUIRES(mutex_) {
    VLOG(2) << __func__ << ""("" << id_slice.ToDebugString() << "", "" << data.ToDebugString() << "")"";

    auto id = Uuid::TryFullyDecode(id_slice);
    if (id.IsNil()) {
      return Status::OK();
    }
    auto metadata = VERIFY_RESULT(pb_util::ParseFromSlice<Pb>(data));
    return LoadEntry(typename Map::key_type(id), metadata, map);
  }

  template <class Pb, class Map>
  Status LoadEntry(
      const typename Map::key_type& id, const Pb& data, Map* map)
      REQUIRES(mutex_) {
    VLOG(1) << __func__ << ""("" << id << "", "" << data.ShortDebugString() << "")"";

    auto new_entry = std::make_unique<typename Map::value_type::element_type>(&context_, id, data);

    auto it = map->find(id);
    if (it == map->end()) {
      map->emplace(std::move(new_entry));
    } else if ((**it).ShouldUpdate(*new_entry)) {
      map->replace(it, std::move(new_entry));
    } else {
      VLOG_WITH_FUNC(1) << ""Ignore because of version check, existing: "" << (**it).ToString()
                        << "", loaded: "" << new_entry->ToString();
    }

    return Status::OK();
  }

  Result<SnapshotState&> FindSnapshot(const TxnSnapshotId& snapshot_id) REQUIRES(mutex_) {
    auto it = snapshots_.find(snapshot_id);
    if (it == snapshots_.end()) {
      return STATUS(NotFound, ""Could not find snapshot"", snapshot_id.ToString(),
                    MasterError(MasterErrorPB::SNAPSHOT_NOT_FOUND));
    }
    return **it;
  }

  Result<RestorationState&> FindRestoration(
      const TxnSnapshotRestorationId& restoration_id) REQUIRES(mutex_) {
    auto it = restorations_.find(restoration_id);
    if (it == restorations_.end()) {
      return STATUS(NotFound, ""Could not find restoration"", restoration_id.ToString(),
                    MasterError(MasterErrorPB::OBJECT_NOT_FOUND));
    }
    return **it;
  }

  Result<RestorationState*> GetRestorationPtrOrNull(
      const TxnSnapshotRestorationId& restoration_id) REQUIRES(mutex_) {
    auto restoration_result = FindRestoration(restoration_id);
    if (!restoration_result.ok() && restoration_result.status().IsNotFound()) {
      return nullptr;
    }
    RETURN_NOT_OK(restoration_result);
    return &*restoration_result;
  }

  Result<SnapshotScheduleState&> FindSnapshotSchedule(
      const SnapshotScheduleId& id) REQUIRES(mutex_) {
    auto it = schedules_.find(id);
    if (it == schedules_.end()) {
      return STATUS(NotFound, ""Could not find snapshot schedule"", id.ToString(),
                    MasterError(MasterErrorPB::SNAPSHOT_NOT_FOUND));
    }
    return **it;
  }

  void ExecuteOperations(const TabletSnapshotOperations& operations, int64_t leader_term) {
    if (operations.empty()) {
      return;
    }
    VLOG(4) << __func__ << ""("" << AsString(operations) << "")"";

    size_t num_operations = operations.size();
    LOG(INFO) << ""Number of snapshot operations to be executed "" << num_operations;
    std::vector<TabletId> tablet_ids;
    tablet_ids.reserve(num_operations);
    for (const auto& operation : operations) {
      tablet_ids.push_back(operation.tablet_id);
    }
    auto tablet_infos = context_.GetTabletInfos(tablet_ids);
    for (size_t i = 0; i != num_operations; ++i) {
      ExecuteOperation(operations[i], tablet_infos[i], leader_term);
    }
  }

  void ExecuteOperation(
      const TabletSnapshotOperation& operation, const TabletInfoPtr& tablet_info,
      int64_t leader_term) {
    auto callback = MakeDoneCallback(
        &mutex_, snapshots_, operation.snapshot_id, operation.tablet_id,
        std::bind(&Impl::UpdateSnapshot, this, _1, leader_term, _2));
    if (!tablet_info) {
      callback(STATUS_EC_FORMAT(NotFound, MasterError(MasterErrorPB::TABLET_NOT_RUNNING),
                                ""Tablet info not found for $0"", operation.tablet_id));
      return;
    }
    auto snapshot_id_str = operation.snapshot_id.AsSlice().ToBuffer();

    if (operation.state == SysSnapshotEntryPB::DELETING) {
      auto task = context_.CreateAsyncTabletSnapshotOp(
          tablet_info, snapshot_id_str, tserver::TabletSnapshotOpRequestPB::DELETE_ON_TABLET,
          callback);
      context_.ScheduleTabletSnapshotOp(task);
    } else if (operation.state == SysSnapshotEntryPB::CREATING) {
      auto task = context_.CreateAsyncTabletSnapshotOp(
          tablet_info, snapshot_id_str, tserver::TabletSnapshotOpRequestPB::CREATE_ON_TABLET,
          callback);
      task->SetSnapshotScheduleId(operation.schedule_id);
      task->SetSnapshotHybridTime(operation.snapshot_hybrid_time);
      context_.ScheduleTabletSnapshotOp(task);
    } else {
      LOG(DFATAL) << ""Unsupported snapshot operation: "" << operation.ToString();
    }
  }

  void ExecuteRestoreOperations(
      const TabletRestoreOperations& operations, int64_t leader_term) {
    if (operations.empty()) {
      return;
    }

    size_t num_operations = operations.size();
    LOG(INFO) << ""Number of tablet restore operations to be executed "" << num_operations;
    std::vector<TabletId> tablet_ids;
    tablet_ids.reserve(num_operations);
    for (const auto& operation : operations) {
      tablet_ids.push_back(operation.tablet_id);
    }
    auto tablet_infos = context_.GetTabletInfos(tablet_ids);
    for (size_t i = 0; i != num_operations; ++i) {
      ExecuteRestoreOperation(
          operations[i], tablet_infos[i], leader_term);
    }
  }

  void ExecuteRestoreOperation(
      const TabletRestoreOperation& operation, const TabletInfoPtr& tablet_info,
      int64_t leader_term) {
    auto snapshot_id_str = operation.snapshot_id.AsSlice().ToBuffer();
    // If this tablet did not participate in snapshot, i.e. was deleted.
    // We just change hybrid hybrid time limit and clear hide state.
    auto task = context_.CreateAsyncTabletSnapshotOp(
        tablet_info, operation.is_tablet_part_of_snapshot ? snapshot_id_str : std::string(),
        tserver::TabletSnapshotOpRequestPB::RESTORE_ON_TABLET,
        MakeDoneCallback(&mutex_, restorations_, operation.restoration_id, operation.tablet_id,
                          std::bind(&Impl::FinishRestoration, this, _1, leader_term)));
    task->SetSnapshotHybridTime(operation.restore_at);
    task->SetRestorationId(operation.restoration_id);
    if (operation.sys_catalog_restore_needed) {
      task->SetMetadata(tablet_info->table()->LockForRead()->pb);
    }
    // For sequences_data_table, we should set partial restore and db_oid.
    if (tablet_info->table()->id() == kPgSequencesDataTableId) {
      LOG_IF(DFATAL, !operation.db_oid) << ""DB OID not found for restoring database"";
      task->SetDbOid(*operation.db_oid);
    }
    context_.ScheduleTabletSnapshotOp(task);
  }

  struct PollSchedulesData {
    std::vector<TxnSnapshotId> delete_snapshots;
    SnapshotScheduleOperations schedule_operations;
    ScheduleMinRestoreTime schedule_min_restore_time;
  };

  void Poll() {
    auto leader_term = context_.LeaderTerm();
    if (leader_term < 0) {
      return;
    }
    SCOPED_LEADER_SHARED_LOCK(l, cm_);
    if (!l.catalog_status().ok() || !l.leader_status().ok()) {
      return;
    }
    VLOG(4) << __func__ << ""()"";
    std::vector<TxnSnapshotId> cleanup_snapshots;
    TabletSnapshotOperations operations;
    TabletRestoreOperations restore_operations;
    PollSchedulesData schedules_data;
    {
      std::lock_guard<std::mutex> lock(mutex_);
      for (const auto& p : snapshots_) {
        if (p->NeedCleanup()) {
          LOG(INFO) << ""Cleanup of snapshot "" << p->id() << "" started."";
          if (!p->CleanupTracker().Start().ok()) {
            LOG(DFATAL) << ""Cleanup of snapshot "" << p->id() << "" was already started."";
          }
          cleanup_snapshots.push_back(p->id());
        } else {
          // Refresh the throttle limit.
          p->Throttler().RefreshLimit(
              GetRpcLimit(FLAGS_max_concurrent_snapshot_rpcs,
                          FLAGS_max_concurrent_snapshot_rpcs_per_tserver, leader_term));
          p->PrepareOperations(&operations);
        }
      }
      PollSchedulesPrepare(&schedules_data);
      for (const auto& r : restorations_) {
        auto snapshot = ValidateRestoreAndGetSnapshot(r.get());
        if (!snapshot || r->GetLeaderTerm() != leader_term) {
          continue;
        }
        r->Throttler().RefreshLimit(
            GetRpcLimit(FLAGS_max_concurrent_restoration_rpcs,
                        FLAGS_max_concurrent_restoration_rpcs_per_tserver, leader_term));
        auto tablets = (*snapshot).tablet_ids();
        std::unordered_set<TabletId> tablets_snapshot(tablets.begin(), tablets.end());
        std::optional<int64_t> db_oid = std::nullopt;
        if (!snapshot->schedule_id().IsNil()) {
          db_oid = ComputeDbOid(r.get());
        }
        r->PrepareOperations(&restore_operations, tablets_snapshot, db_oid);
      }
    }
    for (const auto& id : cleanup_snapshots) {
      CleanupObject(leader_term, id, snapshots_, EncodedSnapshotKey(id, &context_));
    }
    ExecuteOperations(operations, leader_term);
    PollSchedulesComplete(schedules_data, leader_term);
    ExecuteRestoreOperations(restore_operations, leader_term);
  }

  void TryDeleteSnapshot(SnapshotState* snapshot, PollSchedulesData* data) {
    auto delete_status = snapshot->TryStartDelete();
    if (!delete_status.ok()) {
      VLOG(1) << ""Unable to delete snapshot "" << snapshot->id() << ""/"" << snapshot->schedule_id()
              << "": "" << delete_status << "", state: "" << snapshot->ToString();
      return;
    }

    VLOG(1) << ""Cleanup snapshot: "" << snapshot->id() << ""/"" << snapshot->schedule_id();
    data->delete_snapshots.push_back(snapshot->id());
  }

  void PollSchedulesPrepare(PollSchedulesData* data) REQUIRES(mutex_) {
    auto now = context_.Clock()->Now();
    for (const auto& p : schedules_) {
      HybridTime last_snapshot_time;
      if (p->deleted()) {
        auto range = snapshots_.get<ScheduleTag>().equal_range(p->id());
        for (const auto& snapshot : boost::make_iterator_range(range.first, range.second)) {
          TryDeleteSnapshot(snapshot.get(), data);
        }
      } else {
        auto& index = snapshots_.get<ScheduleTag>();
        auto range = index.equal_range(p->id());
        if (range.first != range.second) {
          --range.second;
          for (; range.first != range.second; ++range.first) {
            if ((**range.first).initial_state() != SysSnapshotEntryPB::DELETING) {
              break;
            }
          }
          auto& first_snapshot = **range.first;
          data->schedule_min_restore_time[p->id()] =
              first_snapshot.previous_snapshot_hybrid_time()
                  ? first_snapshot.previous_snapshot_hybrid_time()
                  : first_snapshot.snapshot_hybrid_time();
          auto gc_limit = now.AddSeconds(-p->options().retention_duration_sec());
          VLOG_WITH_FUNC(4) << ""Gc limit: "" << gc_limit;
          for (; range.first != range.second; ++range.first) {
            if ((**range.first).snapshot_hybrid_time() >= gc_limit) {
              break;
            }
            TryDeleteSnapshot(range.first->get(), data);
          }
          last_snapshot_time = (**range.second).snapshot_hybrid_time();
        }
      }
      p->PrepareOperations(last_snapshot_time, now, &data->schedule_operations);
    }
  }

  void PollSchedulesComplete(const PollSchedulesData& data, int64_t leader_term) EXCLUDES(mutex_) {
    for (const auto& id : data.delete_snapshots) {
      SubmitDelete(id, leader_term, nullptr);
    }
    for (const auto& operation : data.schedule_operations) {
      switch (operation.type) {
        case SnapshotScheduleOperationType::kCreateSnapshot:
          WARN_NOT_OK(ExecuteScheduleOperation(operation, leader_term),
                      Format(""Failed to execute operation on $0"", operation.schedule_id));
          break;
        case SnapshotScheduleOperationType::kCleanup:
          CleanupObject(
              leader_term, operation.schedule_id, schedules_,
              SnapshotScheduleState::EncodedKey(operation.schedule_id, &context_));
          break;
        default:
          LOG(DFATAL) << ""Unexpected operation type: "" << operation.type;
          break;
      }
    }
    context_.CleanupHiddenObjects(data.schedule_min_restore_time);
  }

  SnapshotState* BoundingSnapshot(const SnapshotScheduleId& schedule_id, Bound bound)
      REQUIRES(mutex_) {
    auto& index = snapshots_.get<ScheduleTag>();
    decltype(index.begin()) it;
    if (bound == Bound::kFirst) {
      it = index.lower_bound(schedule_id);
      if (it == index.end()) {
        return nullptr;
      }
    } else {
      it = index.upper_bound(schedule_id);
      if (it == index.begin()) {
        return nullptr;
      }
      --it;
    }
    return (**it).schedule_id() == schedule_id ? it->get() : nullptr;
  }

  HybridTime LastSnapshotTime(const SnapshotScheduleId& schedule_id) REQUIRES(mutex_) {
    auto snapshot = BoundingSnapshot(schedule_id, Bound::kLast);
    return snapshot ? snapshot->snapshot_hybrid_time() : HybridTime::kInvalid;
  }

  template <typename Id, typename Map>
  void CleanupObjectAborted(Id id, const Map& map) {
    LOG(INFO) << ""Aborting cleanup of object "" << id;
    std::lock_guard<std::mutex> l(mutex_);
    auto it = map.find(id);
    if (it == map.end()) {
      return;
    }
    (**it).CleanupTracker().Abort();
  }

  template <typename Map, typename Id>
  void CleanupObject(int64_t leader_term, Id id, const Map& map,
                     const Result<docdb::KeyBytes>& encoded_key) {
    if (!encoded_key.ok()) {
      LOG(DFATAL) << ""Failed to encode id for deletion: "" << encoded_key.status();
      return;
    }

    auto query = std::make_unique<tablet::WriteQuery>(
        leader_term, CoarseMonoClock::Now() + FLAGS_sys_catalog_write_timeout_ms * 1ms,
        nullptr /* context */, nullptr /* tablet */);

    auto* write_batch = query->operation().AllocateRequest()->mutable_write_batch();
    auto pair = write_batch->add_write_pairs();
    pair->set_key((*encoded_key).AsSlice().cdata(), (*encoded_key).size());
    char value = { docdb::ValueEntryTypeAsChar::kTombstone };
    pair->set_value(&value, 1);

    query->set_callback([this, id, &map](const Status& s) {
      if (s.ok()) {
        LOG(INFO) << ""Finished cleanup of object "" << id;
        return;
      }
      CleanupObjectAborted(id, map);
    });

    context_.Submit(query.release()->PrepareSubmit(), leader_term);
  }

  Status ExecuteScheduleOperation(
      const SnapshotScheduleOperation& operation, int64_t leader_term,
      const std::weak_ptr<Synchronizer>& synchronizer = std::weak_ptr<Synchronizer>()) {
    auto entries = CollectEntries(operation.filter);
    VLOG(2) << __func__ << ""("" << AsString(operation) << "", "" << leader_term << ""), entries: ""
            << AsString(entries);
    if (!entries.ok()) {
      CreateSnapshotAborted(entries.status(), operation.schedule_id, operation.snapshot_id);
      return entries.status();
    }
    SubmitCreate(
        *entries, /* imported= */ false, operation.schedule_id,
        operation.previous_snapshot_hybrid_time, operation.snapshot_id, leader_term,
        [this, schedule_id = operation.schedule_id, snapshot_id = operation.snapshot_id,
         synchronizer](
            const Status& status) {
          if (!status.ok()) {
            CreateSnapshotAborted(status, schedule_id, snapshot_id);
          }
          auto locked_synchronizer = synchronizer.lock();
          if (locked_synchronizer) {
            locked_synchronizer->StatusCB(status);
          }
        });
    return Status::OK();
  }

  void CreateSnapshotAborted(
      const Status& status, const SnapshotScheduleId& schedule_id,
      const TxnSnapshotId& snapshot_id) {
    LOG(INFO) << __func__ << "" for "" << schedule_id << "", snapshot: "" << snapshot_id
              << "", status: "" << status;
    std::lock_guard<std::mutex> lock(mutex_);
    auto it = schedules_.find(schedule_id);
    if (it == schedules_.end()) {
      return;
    }
    (**it).SnapshotFinished(snapshot_id, status);
  }

  void SubmitCreate(
      const SysRowEntries& entries, bool imported, const SnapshotScheduleId& schedule_id,
      HybridTime previous_snapshot_hybrid_time, TxnSnapshotId snapshot_id, int64_t leader_term,
      tablet::OperationCompletionCallback completion_clbk) {
    auto operation = std::make_unique<tablet::SnapshotOperation>(/* tablet= */ nullptr);
    auto request = operation->AllocateRequest();

    VLOG(1) << __func__ << ""("" << AsString(entries) << "", "" << imported << "", "" << schedule_id
            << "", "" << snapshot_id << "")"";
    // There could be more than one entry of the same tablet,
    // for instance in the case of colocated tables.
    std::unordered_set<TabletId> unique_tablet_ids;
    for (const auto& entry : entries.entries()) {
      if (entry.type() == SysRowEntryType::TABLET) {
        if (unique_tablet_ids.insert(entry.id()).second) {
          VLOG(1) << __func__ << ""(Adding tablet "" << entry.id()
                  << "" for snapshot "" << snapshot_id << "")"";
          request->add_tablet_id(entry.id());
        }
      }
    }

    request->set_snapshot_hybrid_time(context_.Clock()->MaxGlobalNow().ToUint64());
    request->set_operation(tserver::TabletSnapshotOpRequestPB::CREATE_ON_MASTER);
    request->set_snapshot_id(snapshot_id.data(), snapshot_id.size());
    request->set_imported(imported);
    if (schedule_id) {
      request->set_schedule_id(schedule_id.data(), schedule_id.size());
    }
    if (previous_snapshot_hybrid_time) {
      request->set_previous_snapshot_hybrid_time(previous_snapshot_hybrid_time.ToUint64());
    }

    request->mutable_extra_data()->PackFrom(entries);

    operation->set_completion_callback(std::move(completion_clbk));

    context_.Submit(std::move(operation), leader_term);
  }

  void SubmitDelete(const TxnSnapshotId& snapshot_id, int64_t leader_term,
                    const std::shared_ptr<Synchronizer>& synchronizer) {
    auto operation = std::make_unique<tablet::SnapshotOperation>(nullptr);
    auto request = operation->AllocateRequest();

    request->set_operation(tserver::TabletSnapshotOpRequestPB::DELETE_ON_MASTER);
    request->set_snapshot_id(snapshot_id.data(), snapshot_id.size());

    operation->set_completion_callback(
        [this, wsynchronizer = std::weak_ptr<Synchronizer>(synchronizer), snapshot_id]
        (const Status& status) {
          auto synchronizer = wsynchronizer.lock();
          if (synchronizer) {
            synchronizer->StatusCB(status);
          }
          if (!status.ok()) {
            DeleteSnapshotAborted(status, snapshot_id);
          }
        });

    context_.Submit(std::move(operation), leader_term);
  }

  Status SubmitRestore(
      const TxnSnapshotId& snapshot_id, HybridTime restore_at,
      const TxnSnapshotRestorationId& restoration_id, int64_t leader_term) {
    auto synchronizer = std::make_shared<Synchronizer>();

    auto operation = std::make_unique<tablet::SnapshotOperation>(nullptr);
    auto request = operation->AllocateRequest();

    request->set_operation(tserver::TabletSnapshotOpRequestPB::RESTORE_SYS_CATALOG);
    request->set_snapshot_id(snapshot_id.data(), snapshot_id.size());
    request->set_snapshot_hybrid_time(restore_at.ToUint64());
    if (restoration_id) {
      request->set_restoration_id(restoration_id.data(), restoration_id.size());
    }

    operation->set_completion_callback(
        tablet::MakeWeakSynchronizerOperationCompletionCallback(synchronizer));

    context_.Submit(std::move(operation), leader_term);

    return synchronizer->Wait();
  }

  void DeleteSnapshotAborted(
      const Status& status, const TxnSnapshotId& snapshot_id) {
    LOG(INFO) << __func__ << "", snapshot: "" << snapshot_id << "", status: "" << status;
    std::lock_guard<std::mutex> lock(mutex_);
    auto it = snapshots_.find(snapshot_id);
    if (it == snapshots_.end()) {
      return;
    }
    (**it).DeleteAborted(status);
  }

  void UpdateSnapshot(
      SnapshotState* snapshot, int64_t leader_term, std::unique_lock<std::mutex>* lock)
      REQUIRES(mutex_) {
    bool batch_done = false;
    bool is_empty = snapshot->Empty();

    if (!is_empty) {
      batch_done = snapshot->Throttler().RemoveOutstandingTask();
    }
    if (!snapshot->AllTabletsDone()) {
      if (FLAGS_schedule_snapshot_rpcs_out_of_band && batch_done && !is_empty) {
        // Send another batch. This prevents having to wait for the regular cycle
        // of master snapshot coordinator which can be too slow.
        context_.Scheduler().io_service().post([this]() {
          LOG(INFO) << ""Rescheduling Snapshot RPCs out of band."";
          Poll();
        });
      }
      return;
    }

    if (snapshot->schedule_id()) {
      UpdateSchedule(*snapshot);
    }

    docdb::KeyValueWriteBatchPB write_batch;
    auto status = snapshot->StoreToWriteBatch(&write_batch);
    if (!status.ok()) {
      LOG(DFATAL) << ""Failed to prepare write batch for snapshot: "" << status;
      return;
    }
    lock->unlock();

    SubmitWrite(std::move(write_batch), leader_term, &context_);
  };

  void FinishRestoration(RestorationState* restoration, int64_t leader_term) REQUIRES(mutex_) {
    bool tablet_list_empty = restoration->Empty();

    if (!tablet_list_empty) {
      bool batch_done = restoration->Throttler().RemoveOutstandingTask();
      if (!restoration->AllTabletsDone()) {
        if (FLAGS_schedule_restoration_rpcs_out_of_band && batch_done) {
          // Send another batch. This prevents having to wait for the regular cycle
          // of master snapshot coordinator which can be too slow.
          context_.Scheduler().io_service().post([this]() {
            LOG(INFO) << ""Rescheduling restoration RPCs out of band."";
            Poll();
          });
        }
        return;
      }
    }

    last_restorations_update_ht_ = context_.Clock()->Now();
    restoration->set_complete_time(last_restorations_update_ht_);

    LOG(INFO) << ""Setting restore complete time to "" << last_restorations_update_ht_;

    if (restoration->schedule_id()) {
      auto schedule = FindSnapshotSchedule(restoration->schedule_id());
      if (schedule.ok()) {
        docdb::KeyValueWriteBatchPB write_batch;
        schedule->mutable_options().add_restoration_times(
            last_restorations_update_ht_.ToUint64());
        Status s = schedule->StoreToWriteBatch(&write_batch);
        if (s.ok()) {
          SubmitWrite(std::move(write_batch), leader_term, &context_);
        } else {
          LOG(INFO) << ""Unable to prepare write batch for schedule ""
                    << schedule->id();
        }
      } else {
        LOG(INFO) << ""Snapshot Schedule with id "" << restoration->schedule_id()
                  << "" not found"";
      }
    }

    if (FLAGS_TEST_skip_sending_restore_finished) {
      return;
    }

    auto temp_ids = restoration->tablet_ids();
    std::vector<TabletId> tablet_ids(temp_ids.begin(), temp_ids.end());
    auto tablets = context_.GetTabletInfos(tablet_ids);
    for (const auto& tablet : tablets) {
      auto task = context_.CreateAsyncTabletSnapshotOp(
          tablet, std::string(), tserver::TabletSnapshotOpRequestPB::RESTORE_FINISHED,
          /* callback= */ nullptr);
      task->SetRestorationId(restoration->restoration_id());
      task->SetRestorationTime(restoration->complete_time());
      context_.ScheduleTabletSnapshotOp(task);
    }
    // Update restoration entry to sys catalog.
    LOG(INFO) << ""Marking restoration "" << restoration->restoration_id()
              << "" as complete in sys catalog"";
    docdb::KeyValueWriteBatchPB write_batch;
    auto status = restoration->StoreToWriteBatch(&write_batch);
    if (!status.ok()) {
      LOG(DFATAL) << ""Failed to prepare write batch for snapshot: "" << status;
      return;
    }
    SubmitWrite(std::move(write_batch), leader_term, &context_);

    // Enable tablet splitting again.
    if (restoration->schedule_id()) {
      context_.EnableTabletSplitting(""PITR"");
    }
  }

  void UpdateSchedule(const SnapshotState& snapshot) REQUIRES(mutex_) {
    auto it = schedules_.find(snapshot.schedule_id());
    if (it == schedules_.end()) {
      return;
    }

    auto state = snapshot.AggregatedState();
    Status status;
    if (!state.ok()) {
      status = state.status();
    } else {
      switch (*state) {
        case SysSnapshotEntryPB::COMPLETE:
          status = Status::OK();
          break;
        case SysSnapshotEntryPB::FAILED:
          status = snapshot.AnyFailure();
          break;
        case SysSnapshotEntryPB::DELETED:
          return;
        default:
          LOG(DFATAL) << ""Unexpected snapshot state: "" << *state << "" for "" << snapshot.id();
          return;
      }
    }
    (**it).SnapshotFinished(snapshot.id(), status);
  }

  Status FillSchedule(const SnapshotScheduleState& schedule, SnapshotScheduleInfoPB* out)
      REQUIRES(mutex_) {
    RETURN_NOT_OK(schedule.ToPB(out));
    const auto& index = snapshots_.get<ScheduleTag>();
    auto p = index.equal_range(boost::make_tuple(schedule.id()));
    for (auto i = p.first; i != p.second; ++i) {
      RETURN_NOT_OK((**i).ToPB(out->add_snapshots()));
    }
    return Status::OK();
  }

  Result<SysRowEntries> CollectEntries(const SnapshotScheduleFilterPB& filter) {
    return context_.CollectEntriesForSnapshot(filter.tables().tables());
  }

  Status ConsecutiveRestoreCheck(
      const SnapshotState& snapshot, HybridTime restore_at,
      const TxnSnapshotRestorationId& restoration_id) REQUIRES(mutex_) {
    SnapshotScheduleState& schedule =
        VERIFY_RESULT(FindSnapshotSchedule(snapshot.schedule_id()));

    // Find the latest restore.
    HybridTime latest_restore_ht = HybridTime::kMin;
    for (const auto& restoration_ht : schedule.options().restoration_times()) {
      if (HybridTime::FromPB(restoration_ht) > latest_restore_ht) {
        latest_restore_ht = HybridTime::FromPB(restoration_ht);
      }
    }
    LOG(INFO) << ""Last successful restoration completed at ""
              << latest_restore_ht;

    if (restore_at <= latest_restore_ht) {
      LOG(INFO) << ""Restore with id "" << restoration_id << "" not supported ""
                << ""because it is consecutive. Attempting to restore to ""
                << restore_at << "" while last successful restoration completed at ""
                << latest_restore_ht;
      return STATUS_FORMAT(NotSupported,
                            ""Cannot restore before the previous restoration time. ""
                              ""A Restoration was performed at $0 and the requested ""
                              ""restoration is for $1 which is before the last restoration."",
                            latest_restore_ht, restore_at);
    }
    return Status::OK();
  }

  Status SubmitRestoreWrite(RestorationState* restoration, int64_t leader_term) REQUIRES(mutex_) {
    LOG(INFO) << ""Writing restoration "" << restoration->restoration_id()
              << "" entry to sys catalog"";
    docdb::KeyValueWriteBatchPB write_batch;
    RETURN_NOT_OK(restoration->StoreToWriteBatch(&write_batch));
    SubmitWrite(std::move(write_batch), leader_term, &context_);
    return Status::OK();
  }

  Status DoRestore(
      const TxnSnapshotId& snapshot_id, HybridTime restore_at,
      const TxnSnapshotRestorationId& restoration_id, RestorePhase phase, int64_t leader_term,
      std::optional<int64_t> db_oid = std::nullopt) {
    TabletRestoreOperations operations;
    bool restore_sys_catalog;
    std::unordered_set<TabletId> snapshot_tablets;
    bool tablet_list_empty = false;
    {
      std::lock_guard<std::mutex> lock(mutex_);
      SnapshotState& snapshot = VERIFY_RESULT(FindSnapshot(snapshot_id));
      if (!VERIFY_RESULT(snapshot.Complete())) {
        return STATUS(IllegalState, ""The snapshot state is not complete"", snapshot_id.ToString(),
                      MasterError(MasterErrorPB::SNAPSHOT_IS_NOT_READY));
      }
      restore_sys_catalog = phase == RestorePhase::kInitial && !snapshot.schedule_id().IsNil();
      if (!FLAGS_allow_consecutive_restore && restore_sys_catalog) {
        RETURN_NOT_OK(ConsecutiveRestoreCheck(snapshot, restore_at, restoration_id));
      }
      // Get the restoration state. Construct if in initial phase.
      RestorationState* restoration_ptr;
      if (phase == RestorePhase::kInitial) {
        LOG(INFO) << ""Creating a new restoration entry with id "" << restoration_id;
        // We mark sys catalog restoration phase to be complete in case of restorations
        // from external backups where we don't need to restore the sys catalog.
        auto restoration = std::make_unique<RestorationState>(
            &context_, restoration_id, &snapshot, restore_at,
            (snapshot.schedule_id().IsNil() ? IsSysCatalogRestored::kTrue :
                                              IsSysCatalogRestored::kFalse),
            GetRpcLimit(FLAGS_max_concurrent_restoration_rpcs,
                        FLAGS_max_concurrent_restoration_rpcs_per_tserver, leader_term));
        restoration_ptr = restorations_.emplace(std::move(restoration)).first->get();
        last_restorations_update_ht_ = context_.Clock()->Now();
      } else {
        restoration_ptr = &VERIFY_RESULT(FindRestoration(restoration_id)).get();
      }

      if (!restore_sys_catalog) {
        // Persist and replicate restoration entry to the sys catalog.
        // This ensures that followers can continue RPCs if this leader fails.
        // For PITR restorations, it is persisted as part of RESTORE_SYS_CATALOG operation.
        if (phase == RestorePhase::kInitial) {
          // Update the current leader term so that snapshot coordinator can pick it up.
          restoration_ptr->SetLeaderTerm(leader_term);
          RETURN_NOT_OK(SubmitRestoreWrite(restoration_ptr, leader_term));
        }
        tablet_list_empty = restoration_ptr->Empty();
        auto tablet_ids = snapshot.tablet_ids();
        snapshot_tablets.insert(tablet_ids.begin(), tablet_ids.end());
        restoration_ptr->PrepareOperations(&operations, snapshot_tablets, db_oid);
      }
    }

    // If sys catalog is restored, then tablets data will be restored after that using postponed
    // restores.
    if (restore_sys_catalog) {
      return SubmitRestore(snapshot_id, restore_at, restoration_id, leader_term);
    }

    ExecuteRestoreOperations(operations, leader_term);

    // For empty tablet list, finish the restore.
    if (tablet_list_empty) {
      std::lock_guard<std::mutex> lock(mutex_);
      RestorationState* restoration_ptr = &VERIFY_RESULT(FindRestoration(restoration_id)).get();
      if (restoration_ptr) {
        FinishRestoration(restoration_ptr, leader_term);
      }
    }

    return Status::OK();
  }

  // Computes the maximum outstanding Snapshot Create/Delete RPC
  // that is permitted. If total limit is specified then it is used otherwise
  // the value is computed by multiplying tserver count with the per tserver limit.
  uint64_t GetRpcLimit(int64_t total_limit, int64_t per_tserver_limit, int64_t leader_term) {
    // NO OP for followers.
    if (leader_term < 0) {
      return std::numeric_limits<int>::max();
    }
    // Should execute only for leaders.
    if (total_limit == 0) {
      return std::numeric_limits<int>::max();
    }
    if (total_limit > 0) {
      return total_limit;
    }
    auto num_result = context_.GetNumLiveTServersForActiveCluster();
    // The cluster config could be empty for e.g. if a restore is in progress
    // or e.g. if a new master leader is elected. This is a temporary intermediate
    // state (we have bigger problems if the cluster config remains empty forever).
    // We use the limit set per tserver as the overall limit in such cases.
    if (!num_result.ok()) {
      LOG(INFO) << ""Cluster Config is not available. Using per tserver limit of ""
                << per_tserver_limit << "" as the throttled limit."";
      return per_tserver_limit;
    }
    uint64_t num_tservers = *num_result;
    return num_tservers * per_tserver_limit;
  }

  SnapshotCoordinatorContext& context_;
  enterprise::CatalogManager* cm_;
  std::mutex mutex_;
  class ScheduleTag;
  using Snapshots = boost::multi_index_container<
      std::unique_ptr<SnapshotState>,
      boost::multi_index::indexed_by<
          // Access snapshots by id.
          boost::multi_index::hashed_unique<
              boost::multi_index::const_mem_fun<
                  SnapshotState, const TxnSnapshotId&, &SnapshotState::id>
          >,
          // Group snapshots by schedule id. Ordered by hybrid time for the same schedule.
          boost::multi_index::ordered_non_unique<
              boost::multi_index::tag<ScheduleTag>,
              boost::multi_index::composite_key<
                  SnapshotState,
                  boost::multi_index::const_mem_fun<
                      SnapshotState, const SnapshotScheduleId&, &SnapshotState::schedule_id>,
                  boost::multi_index::const_mem_fun<
                      SnapshotState, HybridTime, &SnapshotState::snapshot_hybrid_time>
              >
          >
      >
  >;
  // For restorations and schedules we have to use multi_index since there are template
  // functions that expect same interface for those collections.
  using Restorations = boost::multi_index_container<
      std::unique_ptr<RestorationState>,
      boost::multi_index::indexed_by<
          boost::multi_index::hashed_unique<
              boost::multi_index::const_mem_fun<
                  RestorationState, const TxnSnapshotRestorationId&,
                  &RestorationState::restoration_id>
          >
      >
  >;
  using Schedules = boost::multi_index_container<
      std::unique_ptr<SnapshotScheduleState>,
      boost::multi_index::indexed_by<
          boost::multi_index::hashed_unique<
              boost::multi_index::const_mem_fun<
                  SnapshotScheduleState, const SnapshotScheduleId&, &SnapshotScheduleState::id>
          >
      >
  >;

  Snapshots snapshots_ GUARDED_BY(mutex_);
  Restorations restorations_ GUARDED_BY(mutex_);
  HybridTime last_restorations_update_ht_ GUARDED_BY(mutex_);
  Schedules schedules_ GUARDED_BY(mutex_);
  rpc::Poller poller_;
};

MasterSnapshotCoordinator::MasterSnapshotCoordinator(
    SnapshotCoordinatorContext* context, enterprise::CatalogManager* cm)
    : impl_(new Impl(context, cm)) {}

MasterSnapshotCoordinator::~MasterSnapshotCoordinator() {}

Result<TxnSnapshotId> MasterSnapshotCoordinator::Create(
    const SysRowEntries& entries, bool imported, int64_t leader_term, CoarseTimePoint deadline) {
  return impl_->Create(entries, imported, leader_term, deadline);
}

Status MasterSnapshotCoordinator::CreateReplicated(
    int64_t leader_term, const tablet::SnapshotOperation& operation) {
  return impl_->CreateReplicated(leader_term, operation);
}

Status MasterSnapshotCoordinator::DeleteReplicated(
    int64_t leader_term, const tablet::SnapshotOperation& operation) {
  return impl_->DeleteReplicated(leader_term, operation);
}

Status MasterSnapshotCoordinator::RestoreSysCatalogReplicated(
    int64_t leader_term, const tablet::SnapshotOperation& operation, Status* complete_status) {
  return impl_->RestoreSysCatalogReplicated(leader_term, operation, complete_status);
}

Status MasterSnapshotCoordinator::ListSnapshots(
    const TxnSnapshotId& snapshot_id, bool list_deleted, ListSnapshotsResponsePB* resp) {
  return impl_->ListSnapshots(snapshot_id, list_deleted, resp);
}

Status MasterSnapshotCoordinator::Delete(
    const TxnSnapshotId& snapshot_id, int64_t leader_term, CoarseTimePoint deadline) {
  return impl_->Delete(snapshot_id, leader_term, deadline);
}

Result<TxnSnapshotRestorationId> MasterSnapshotCoordinator::Restore(
    const TxnSnapshotId& snapshot_id, HybridTime restore_at, int64_t leader_term) {
  return impl_->Restore(snapshot_id, restore_at, leader_term);
}

Status MasterSnapshotCoordinator::ListRestorations(
    const TxnSnapshotRestorationId& restoration_id, const TxnSnapshotId& snapshot_id,
    ListSnapshotRestorationsResponsePB* resp) {
  return impl_->ListRestorations(restoration_id, snapshot_id, resp);
}

Result<SnapshotScheduleId> MasterSnapshotCoordinator::CreateSchedule(
    const CreateSnapshotScheduleRequestPB& request, int64_t leader_term,
    CoarseTimePoint deadline) {
  return impl_->CreateSchedule(request, leader_term, deadline);
}

Status MasterSnapshotCoordinator::ListSnapshotSchedules(
    const SnapshotScheduleId& snapshot_schedule_id, ListSnapshotSchedulesResponsePB* resp) {
  return impl_->ListSnapshotSchedules(snapshot_schedule_id, resp);
}

Status MasterSnapshotCoordinator::DeleteSnapshotSchedule(
    const SnapshotScheduleId& snapshot_schedule_id, int64_t leader_term, CoarseTimePoint deadline) {
  return impl_->DeleteSnapshotSchedule(snapshot_schedule_id, leader_term, deadline);
}

Status MasterSnapshotCoordinator::Load(tablet::Tablet* tablet) {
  return impl_->Load(tablet);
}

void MasterSnapshotCoordinator::Start() {
  impl_->Start();
}

void MasterSnapshotCoordinator::Shutdown() {
  impl_->Shutdown();
}

Status MasterSnapshotCoordinator::ApplyWritePair(const Slice& key, const Slice& value) {
  return impl_->ApplyWritePair(key, value);
}

Status MasterSnapshotCoordinator::FillHeartbeatResponse(TSHeartbeatResponsePB* resp) {
  return impl_->FillHeartbeatResponse(resp);
}

Result<SnapshotSchedulesToObjectIdsMap>
    MasterSnapshotCoordinator::MakeSnapshotSchedulesToObjectIdsMap(SysRowEntryType type) {
  return impl_->MakeSnapshotSchedulesToObjectIdsMap(type);
}

Result<bool> MasterSnapshotCoordinator::IsTableCoveredBySomeSnapshotSchedule(
    const TableInfo& table_info) {
  return impl_->IsTableCoveredBySomeSnapshotSchedule(table_info);
}

void MasterSnapshotCoordinator::SysCatalogLoaded(int64_t term) {
  impl_->SysCatalogLoaded(term);
}

Result<TxnSnapshotId> MasterSnapshotCoordinator::CreateForSchedule(
    const SnapshotScheduleId& schedule_id, int64_t leader_term, CoarseTimePoint deadline) {
  return impl_->CreateForSchedule(schedule_id, leader_term, deadline);
}

Result<docdb::KeyValuePairPB> MasterSnapshotCoordinator::UpdateRestorationAndGetWritePair(
    SnapshotScheduleRestoration* restoration) {
  return impl_->UpdateRestorationAndGetWritePair(restoration);
}

bool MasterSnapshotCoordinator::IsPitrActive() {
  return impl_->IsPitrActive();
}

} // namespace master
} // namespace yb
",16136,True,3512.6749119484425,median
"[[amqp-component]]
== AMQP Component

*Available as of Camel version 1.2*

The *amqp:* component supports the http://www.amqp.org/[AMQP 1.0
protocol] using the JMS Client API of the http://qpid.apache.org/[Qpid]
project. In case you want to use AMQP 0.9 (in particular RabbitMQ) you
might also be interested in the <<rabbitmq-component,Camel RabbitMQ>>
component. Please keep in mind that prior to the Camel 2.17.0 AMQP
component supported AMQP 0.9 and above, however since Camel 2.17.0 it
supports only AMQP 1.0.

Maven users will need to add the following dependency to their `pom.xml`
for this component:

[source,xml]
------------------------------------------------------------------------------------------------
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-amqp</artifactId>
    <version>${camel.version}</version> <!-- use the same version as your Camel core version -->
</dependency>
------------------------------------------------------------------------------------------------

### URI format

[source,java]
---------------------------------------------
amqp:[queue:|topic:]destinationName[?options]
---------------------------------------------

### AMQP Options

You can specify all of the various configuration options of the
link:../../../../camel-jms/src/main/docs/readme.html[JMS] component after the destination name.




// component options: START
The AMQP component supports 79 options which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *configuration* (advanced) | To use a shared JMS configuration |  | JmsConfiguration
| *acceptMessagesWhile Stopping* (consumer) | Specifies whether the consumer accept messages while it is stopping. You may consider enabling this option if you start and stop JMS routes at runtime while there are still messages enqueued on the queue. If this option is false and you stop the JMS route then messages may be rejected and the JMS broker would have to attempt redeliveries which yet again may be rejected and eventually the message may be moved at a dead letter queue on the JMS broker. To avoid this its recommended to enable this option. | false | boolean
| *allowReplyManagerQuick Stop* (consumer) | Whether the DefaultMessageListenerContainer used in the reply managers for request-reply messaging allow the DefaultMessageListenerContainer.runningAllowed flag to quick stop in case JmsConfigurationisAcceptMessagesWhileStopping is enabled and org.apache.camel.CamelContext is currently being stopped. This quick stop ability is enabled by default in the regular JMS consumers but to enable for reply managers you must enable this flag. | false | boolean
| *acknowledgementMode* (consumer) | The JMS acknowledgement mode defined as an Integer. Allows you to set vendor-specific extensions to the acknowledgment mode.For the regular modes it is preferable to use the acknowledgementModeName instead. |  | int
| *eagerLoadingOf Properties* (consumer) | Enables eager loading of JMS properties as soon as a message is loaded which generally is inefficient as the JMS properties may not be required but sometimes can catch early any issues with the underlying JMS provider and the use of JMS properties | false | boolean
| *acknowledgementModeName* (consumer) | The JMS acknowledgement name which is one of: SESSION_TRANSACTED CLIENT_ACKNOWLEDGE AUTO_ACKNOWLEDGE DUPS_OK_ACKNOWLEDGE | AUTO_ ACKNOWLEDGE | String
| *autoStartup* (consumer) | Specifies whether the consumer container should auto-startup. | true | boolean
| *cacheLevel* (consumer) | Sets the cache level by ID for the underlying JMS resources. See cacheLevelName option for more details. |  | int
| *cacheLevelName* (consumer) | Sets the cache level by name for the underlying JMS resources. Possible values are: CACHE_AUTO CACHE_CONNECTION CACHE_CONSUMER CACHE_NONE and CACHE_SESSION. The default setting is CACHE_AUTO. See the Spring documentation and Transactions Cache Levels for more information. | CACHE_AUTO | String
| *replyToCacheLevelName* (producer) | Sets the cache level by name for the reply consumer when doing request/reply over JMS. This option only applies when using fixed reply queues (not temporary). Camel will by default use: CACHE_CONSUMER for exclusive or shared w/ replyToSelectorName. And CACHE_SESSION for shared without replyToSelectorName. Some JMS brokers such as IBM WebSphere may require to set the replyToCacheLevelName=CACHE_NONE to work. Note: If using temporary queues then CACHE_NONE is not allowed and you must use a higher value such as CACHE_CONSUMER or CACHE_SESSION. |  | String
| *clientId* (common) | Sets the JMS client ID to use. Note that this value if specified must be unique and can only be used by a single JMS connection instance. It is typically only required for durable topic subscriptions. If using Apache ActiveMQ you may prefer to use Virtual Topics instead. |  | String
| *concurrentConsumers* (consumer) | Specifies the default number of concurrent consumers when consuming from JMS (not for request/reply over JMS). See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. When doing request/reply over JMS then the option replyToConcurrentConsumers is used to control number of concurrent consumers on the reply message listener. | 1 | int
| *replyToConcurrent Consumers* (producer) | Specifies the default number of concurrent consumers when doing request/reply over JMS. See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. | 1 | int
| *connectionFactory* (common) | The connection factory to be use. A connection factory must be configured either on the component or endpoint. |  | ConnectionFactory
| *username* (security) | Username to use with the ConnectionFactory. You can also configure username/password directly on the ConnectionFactory. |  | String
| *password* (security) | Password to use with the ConnectionFactory. You can also configure username/password directly on the ConnectionFactory. |  | String
| *deliveryPersistent* (producer) | Specifies whether persistent delivery is used by default. | true | boolean
| *deliveryMode* (producer) | Specifies the delivery mode to be used. Possibles values are those defined by javax.jms.DeliveryMode. NON_PERSISTENT = 1 and PERSISTENT = 2. |  | Integer
| *durableSubscriptionName* (common) | The durable subscriber name for specifying durable topic subscriptions. The clientId option must be configured as well. |  | String
| *exceptionListener* (advanced) | Specifies the JMS Exception Listener that is to be notified of any underlying JMS exceptions. |  | ExceptionListener
| *errorHandler* (advanced) | Specifies a org.springframework.util.ErrorHandler to be invoked in case of any uncaught exceptions thrown while processing a Message. By default these exceptions will be logged at the WARN level if no errorHandler has been configured. You can configure logging level and whether stack traces should be logged using errorHandlerLoggingLevel and errorHandlerLogStackTrace options. This makes it much easier to configure than having to code a custom errorHandler. |  | ErrorHandler
| *errorHandlerLogging Level* (logging) | Allows to configure the default errorHandler logging level for logging uncaught exceptions. | WARN | LoggingLevel
| *errorHandlerLogStack Trace* (logging) | Allows to control whether stacktraces should be logged or not by the default errorHandler. | true | boolean
| *explicitQosEnabled* (producer) | Set if the deliveryMode priority or timeToLive qualities of service should be used when sending messages. This option is based on Spring's JmsTemplate. The deliveryMode priority and timeToLive options are applied to the current endpoint. This contrasts with the preserveMessageQos option which operates at message granularity reading QoS properties exclusively from the Camel In message headers. | false | boolean
| *exposeListenerSession* (consumer) | Specifies whether the listener session should be exposed when consuming messages. | false | boolean
| *idleTaskExecutionLimit* (advanced) | Specifies the limit for idle executions of a receive task not having received any message within its execution. If this limit is reached the task will shut down and leave receiving to other executing tasks (in the case of dynamic scheduling; see the maxConcurrentConsumers setting). There is additional doc available from Spring. | 1 | int
| *idleConsumerLimit* (advanced) | Specify the limit for the number of consumers that are allowed to be idle at any given time. | 1 | int
| *maxConcurrentConsumers* (consumer) | Specifies the maximum number of concurrent consumers when consuming from JMS (not for request/reply over JMS). See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. When doing request/reply over JMS then the option replyToMaxConcurrentConsumers is used to control number of concurrent consumers on the reply message listener. |  | int
| *replyToMaxConcurrent Consumers* (producer) | Specifies the maximum number of concurrent consumers when using request/reply over JMS. See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. |  | int
| *replyOnTimeoutToMax ConcurrentConsumers* (producer) | Specifies the maximum number of concurrent consumers for continue routing when timeout occurred when using request/reply over JMS. | 1 | int
| *maxMessagesPerTask* (advanced) | The number of messages per task. -1 is unlimited. If you use a range for concurrent consumers (eg min max) then this option can be used to set a value to eg 100 to control how fast the consumers will shrink when less work is required. | -1 | int
| *messageConverter* (advanced) | To use a custom Spring org.springframework.jms.support.converter.MessageConverter so you can be in control how to map to/from a javax.jms.Message. |  | MessageConverter
| *mapJmsMessage* (advanced) | Specifies whether Camel should auto map the received JMS message to a suited payload type such as javax.jms.TextMessage to a String etc. | true | boolean
| *messageIdEnabled* (advanced) | When sending specifies whether message IDs should be added. This is just an hint to the JMS broker.If the JMS provider accepts this hint these messages must have the message ID set to null; if the provider ignores the hint the message ID must be set to its normal unique value | true | boolean
| *messageTimestampEnabled* (advanced) | Specifies whether timestamps should be enabled by default on sending messages. This is just an hint to the JMS broker.If the JMS provider accepts this hint these messages must have the timestamp set to zero; if the provider ignores the hint the timestamp must be set to its normal value | true | boolean
| *alwaysCopyMessage* (producer) | If true Camel will always make a JMS message copy of the message when it is passed to the producer for sending. Copying the message is needed in some situations such as when a replyToDestinationSelectorName is set (incidentally Camel will set the alwaysCopyMessage option to true if a replyToDestinationSelectorName is set) | false | boolean
| *useMessageIDAs CorrelationID* (advanced) | Specifies whether JMSMessageID should always be used as JMSCorrelationID for InOut messages. | false | boolean
| *priority* (producer) | Values greater than 1 specify the message priority when sending (where 0 is the lowest priority and 9 is the highest). The explicitQosEnabled option must also be enabled in order for this option to have any effect. | 4 | int
| *pubSubNoLocal* (advanced) | Specifies whether to inhibit the delivery of messages published by its own connection. | false | boolean
| *receiveTimeout* (advanced) | The timeout for receiving messages (in milliseconds). | 1000 | long
| *recoveryInterval* (advanced) | Specifies the interval between recovery attempts i.e. when a connection is being refreshed in milliseconds. The default is 5000 ms that is 5 seconds. | 5000 | long
| *taskExecutor* (consumer) | Allows you to specify a custom task executor for consuming messages. |  | TaskExecutor
| *timeToLive* (producer) | When sending messages specifies the time-to-live of the message (in milliseconds). | -1 | long
| *transacted* (transaction) | Specifies whether to use transacted mode | false | boolean
| *lazyCreateTransaction Manager* (transaction) | If true Camel will create a JmsTransactionManager if there is no transactionManager injected when option transacted=true. | true | boolean
| *transactionManager* (transaction) | The Spring transaction manager to use. |  | PlatformTransaction Manager
| *transactionName* (transaction) | The name of the transaction to use. |  | String
| *transactionTimeout* (transaction) | The timeout value of the transaction (in seconds) if using transacted mode. | -1 | int
| *testConnectionOn Startup* (common) | Specifies whether to test the connection on startup. This ensures that when Camel starts that all the JMS consumers have a valid connection to the JMS broker. If a connection cannot be granted then Camel throws an exception on startup. This ensures that Camel is not started with failed connections. The JMS producers is tested as well. | false | boolean
| *asyncStartListener* (advanced) | Whether to startup the JmsConsumer message listener asynchronously when starting a route. For example if a JmsConsumer cannot get a connection to a remote JMS broker then it may block while retrying and/or failover. This will cause Camel to block while starting routes. By setting this option to true you will let routes startup while the JmsConsumer connects to the JMS broker using a dedicated thread in asynchronous mode. If this option is used then beware that if the connection could not be established then an exception is logged at WARN level and the consumer will not be able to receive messages; You can then restart the route to retry. | false | boolean
| *asyncStopListener* (advanced) | Whether to stop the JmsConsumer message listener asynchronously when stopping a route. | false | boolean
| *forceSendOriginal Message* (producer) | When using mapJmsMessage=false Camel will create a new JMS message to send to a new JMS destination if you touch the headers (get or set) during the route. Set this option to true to force Camel to send the original JMS message that was received. | false | boolean
| *requestTimeout* (producer) | The timeout for waiting for a reply when using the InOut Exchange Pattern (in milliseconds). The default is 20 seconds. You can include the header CamelJmsRequestTimeout to override this endpoint configured timeout value and thus have per message individual timeout values. See also the requestTimeoutCheckerInterval option. | 20000 | long
| *requestTimeoutChecker Interval* (advanced) | Configures how often Camel should check for timed out Exchanges when doing request/reply over JMS. By default Camel checks once per second. But if you must react faster when a timeout occurs then you can lower this interval to check more frequently. The timeout is determined by the option requestTimeout. | 1000 | long
| *transferExchange* (advanced) | You can transfer the exchange over the wire instead of just the body and headers. The following fields are transferred: In body Out body Fault body In headers Out headers Fault headers exchange properties exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. You must enable this option on both the producer and consumer side so Camel knows the payloads is an Exchange and not a regular payload. | false | boolean
| *transferException* (advanced) | If enabled and you are using Request Reply messaging (InOut) and an Exchange failed on the consumer side then the caused Exception will be send back in response as a javax.jms.ObjectMessage. If the client is Camel the returned Exception is rethrown. This allows you to use Camel JMS as a bridge in your routing - for example using persistent queues to enable robust routing. Notice that if you also have transferExchange enabled this option takes precedence. The caught exception is required to be serializable. The original Exception on the consumer side can be wrapped in an outer exception such as org.apache.camel.RuntimeCamelException when returned to the producer. | false | boolean
| *transferFault* (advanced) | If enabled and you are using Request Reply messaging (InOut) and an Exchange failed with a SOAP fault (not exception) on the consumer side then the fault flag on MessageisFault() will be send back in the response as a JMS header with the key org.apache.camel.component.jms.JmsConstantsJMS_TRANSFER_FAULTJMS_TRANSFER_FAULT. If the client is Camel the returned fault flag will be set on the link org.apache.camel.MessagesetFault(boolean). You may want to enable this when using Camel components that support faults such as SOAP based such as cxf or spring-ws. | false | boolean
| *jmsOperations* (advanced) | Allows you to use your own implementation of the org.springframework.jms.core.JmsOperations interface. Camel uses JmsTemplate as default. Can be used for testing purpose but not used much as stated in the spring API docs. |  | JmsOperations
| *destinationResolver* (advanced) | A pluggable org.springframework.jms.support.destination.DestinationResolver that allows you to use your own resolver (for example to lookup the real destination in a JNDI registry). |  | DestinationResolver
| *replyToType* (producer) | Allows for explicitly specifying which kind of strategy to use for replyTo queues when doing request/reply over JMS. Possible values are: Temporary Shared or Exclusive. By default Camel will use temporary queues. However if replyTo has been configured then Shared is used by default. This option allows you to use exclusive queues instead of shared ones. See Camel JMS documentation for more details and especially the notes about the implications if running in a clustered environment and the fact that Shared reply queues has lower performance than its alternatives Temporary and Exclusive. |  | ReplyToType
| *preserveMessageQos* (producer) | Set to true if you want to send message using the QoS settings specified on the message instead of the QoS settings on the JMS endpoint. The following three headers are considered JMSPriority JMSDeliveryMode and JMSExpiration. You can provide all or only some of them. If not provided Camel will fall back to use the values from the endpoint instead. So when using this option the headers override the values from the endpoint. The explicitQosEnabled option by contrast will only use options set on the endpoint and not values from the message header. | false | boolean
| *asyncConsumer* (consumer) | Whether the JmsConsumer processes the Exchange asynchronously. If enabled then the JmsConsumer may pickup the next message from the JMS queue while the previous message is being processed asynchronously (by the Asynchronous Routing Engine). This means that messages may be processed not 100 strictly in order. If disabled (as default) then the Exchange is fully processed before the JmsConsumer will pickup the next message from the JMS queue. Note if transacted has been enabled then asyncConsumer=true does not run asynchronously as transaction must be executed synchronously (Camel 3.0 may support async transactions). | false | boolean
| *allowNullBody* (producer) | Whether to allow sending messages with no body. If this option is false and the message body is null then an JMSException is thrown. | true | boolean
| *includeSentJMS MessageID* (producer) | Only applicable when sending to JMS destination using InOnly (eg fire and forget). Enabling this option will enrich the Camel Exchange with the actual JMSMessageID that was used by the JMS client when the message was sent to the JMS destination. | false | boolean
| *includeAllJMSX Properties* (advanced) | Whether to include all JMSXxxx properties when mapping from JMS to Camel Message. Setting this to true will include properties such as JMSXAppID and JMSXUserID etc. Note: If you are using a custom headerFilterStrategy then this option does not apply. | false | boolean
| *defaultTaskExecutor Type* (consumer) | Specifies what default TaskExecutor type to use in the DefaultMessageListenerContainer for both consumer endpoints and the ReplyTo consumer of producer endpoints. Possible values: SimpleAsync (uses Spring's SimpleAsyncTaskExecutor) or ThreadPool (uses Spring's ThreadPoolTaskExecutor with optimal values - cached threadpool-like). If not set it defaults to the previous behaviour which uses a cached thread pool for consumer endpoints and SimpleAsync for reply consumers. The use of ThreadPool is recommended to reduce thread trash in elastic configurations with dynamically increasing and decreasing concurrent consumers. |  | DefaultTaskExecutor Type
| *jmsKeyFormatStrategy* (advanced) | Pluggable strategy for encoding and decoding JMS keys so they can be compliant with the JMS specification. Camel provides two implementations out of the box: default and passthrough. The default strategy will safely marshal dots and hyphens (. and -). The passthrough strategy leaves the key as is. Can be used for JMS brokers which do not care whether JMS header keys contain illegal characters. You can provide your own implementation of the org.apache.camel.component.jms.JmsKeyFormatStrategy and refer to it using the notation. |  | JmsKeyFormatStrategy
| *allowAdditionalHeaders* (producer) | This option is used to allow additional headers which may have values that are invalid according to JMS specification. For example some message systems such as WMQ do this with header names using prefix JMS_IBM_MQMD_ containing values with byte array or other invalid types. You can specify multiple header names separated by comma and use as suffix for wildcard matching. |  | String
| *queueBrowseStrategy* (advanced) | To use a custom QueueBrowseStrategy when browsing queues |  | QueueBrowseStrategy
| *messageCreatedStrategy* (advanced) | To use the given MessageCreatedStrategy which are invoked when Camel creates new instances of javax.jms.Message objects when Camel is sending a JMS message. |  | MessageCreatedStrategy
| *waitForProvision CorrelationToBeUpdated Counter* (advanced) | Number of times to wait for provisional correlation id to be updated to the actual correlation id when doing request/reply over JMS and when the option useMessageIDAsCorrelationID is enabled. | 50 | int
| *waitForProvision CorrelationToBeUpdated ThreadSleepingTime* (advanced) | Interval in millis to sleep each time while waiting for provisional correlation id to be updated. | 100 | long
| *correlationProperty* (producer) | Use this JMS property to correlate messages in InOut exchange pattern (request-reply) instead of JMSCorrelationID property. This allows you to exchange messages with systems that do not correlate messages using JMSCorrelationID JMS property. If used JMSCorrelationID will not be used or set by Camel. The value of here named property will be generated if not supplied in the header of the message under the same name. |  | String
| *subscriptionDurable* (consumer) | Set whether to make the subscription durable. The durable subscription name to be used can be specified through the subscriptionName property. Default is false. Set this to true to register a durable subscription typically in combination with a subscriptionName value (unless your message listener class name is good enough as subscription name). Only makes sense when listening to a topic (pub-sub domain) therefore this method switches the pubSubDomain flag as well. | false | boolean
| *subscriptionShared* (consumer) | Set whether to make the subscription shared. The shared subscription name to be used can be specified through the subscriptionName property. Default is false. Set this to true to register a shared subscription typically in combination with a subscriptionName value (unless your message listener class name is good enough as subscription name). Note that shared subscriptions may also be durable so this flag can (and often will) be combined with subscriptionDurable as well. Only makes sense when listening to a topic (pub-sub domain) therefore this method switches the pubSubDomain flag as well. Requires a JMS 2.0 compatible message broker. | false | boolean
| *subscriptionName* (consumer) | Set the name of a subscription to create. To be applied in case of a topic (pub-sub domain) with a shared or durable subscription. The subscription name needs to be unique within this client's JMS client id. Default is the class name of the specified message listener. Note: Only 1 concurrent consumer (which is the default of this message listener container) is allowed for each subscription except for a shared subscription (which requires JMS 2.0). |  | String
| *streamMessageType Enabled* (producer) | Sets whether StreamMessage type is enabled or not. Message payloads of streaming kind such as files InputStream etc will either by sent as BytesMessage or StreamMessage. This option controls which kind will be used. By default BytesMessage is used which enforces the entire message payload to be read into memory. By enabling this option the message payload is read into memory in chunks and each chunk is then written to the StreamMessage until no more data. | false | boolean
| *headerFilterStrategy* (filter) | To use a custom org.apache.camel.spi.HeaderFilterStrategy to filter header to and from Camel message. |  | HeaderFilterStrategy
| *resolveProperty Placeholders* (advanced) | Whether the component should resolve property placeholders on itself when starting. Only properties which are of String type can use property placeholders. | true | boolean
|===
// component options: END







// endpoint options: START
The AMQP endpoint is configured using URI syntax:

----
amqp:destinationType:destinationName
----

with the following path and query parameters:

==== Path Parameters (2 parameters):

[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *destinationType* | The kind of destination to use | queue | String
| *destinationName* | *Required* Name of the queue or topic to use as destination |  | String
|===

==== Query Parameters (90 parameters):

[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *clientId* (common) | Sets the JMS client ID to use. Note that this value if specified must be unique and can only be used by a single JMS connection instance. It is typically only required for durable topic subscriptions. If using Apache ActiveMQ you may prefer to use Virtual Topics instead. |  | String
| *connectionFactory* (common) | The connection factory to be use. A connection factory must be configured either on the component or endpoint. |  | ConnectionFactory
| *disableReplyTo* (common) | Specifies whether Camel ignores the JMSReplyTo header in messages. If true Camel does not send a reply back to the destination specified in the JMSReplyTo header. You can use this option if you want Camel to consume from a route and you do not want Camel to automatically send back a reply message because another component in your code handles the reply message. You can also use this option if you want to use Camel as a proxy between different message brokers and you want to route message from one system to another. | false | boolean
| *durableSubscriptionName* (common) | The durable subscriber name for specifying durable topic subscriptions. The clientId option must be configured as well. |  | String
| *jmsMessageType* (common) | Allows you to force the use of a specific javax.jms.Message implementation for sending JMS messages. Possible values are: Bytes Map Object Stream Text. By default Camel would determine which JMS message type to use from the In body type. This option allows you to specify it. |  | JmsMessageType
| *testConnectionOnStartup* (common) | Specifies whether to test the connection on startup. This ensures that when Camel starts that all the JMS consumers have a valid connection to the JMS broker. If a connection cannot be granted then Camel throws an exception on startup. This ensures that Camel is not started with failed connections. The JMS producers is tested as well. | false | boolean
| *acknowledgementModeName* (consumer) | The JMS acknowledgement name which is one of: SESSION_TRANSACTED CLIENT_ACKNOWLEDGE AUTO_ACKNOWLEDGE DUPS_OK_ACKNOWLEDGE | AUTO_ ACKNOWLEDGE | String
| *asyncConsumer* (consumer) | Whether the JmsConsumer processes the Exchange asynchronously. If enabled then the JmsConsumer may pickup the next message from the JMS queue while the previous message is being processed asynchronously (by the Asynchronous Routing Engine). This means that messages may be processed not 100 strictly in order. If disabled (as default) then the Exchange is fully processed before the JmsConsumer will pickup the next message from the JMS queue. Note if transacted has been enabled then asyncConsumer=true does not run asynchronously as transaction must be executed synchronously (Camel 3.0 may support async transactions). | false | boolean
| *autoStartup* (consumer) | Specifies whether the consumer container should auto-startup. | true | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler which mean any exceptions occurred while the consumer is trying to pickup incoming messages or the likes will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions that will be logged at WARN or ERROR level and ignored. | false | boolean
| *cacheLevel* (consumer) | Sets the cache level by ID for the underlying JMS resources. See cacheLevelName option for more details. |  | int
| *cacheLevelName* (consumer) | Sets the cache level by name for the underlying JMS resources. Possible values are: CACHE_AUTO CACHE_CONNECTION CACHE_CONSUMER CACHE_NONE and CACHE_SESSION. The default setting is CACHE_AUTO. See the Spring documentation and Transactions Cache Levels for more information. | CACHE_AUTO | String
| *concurrentConsumers* (consumer) | Specifies the default number of concurrent consumers when consuming from JMS (not for request/reply over JMS). See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. When doing request/reply over JMS then the option replyToConcurrentConsumers is used to control number of concurrent consumers on the reply message listener. | 1 | int
| *maxConcurrentConsumers* (consumer) | Specifies the maximum number of concurrent consumers when consuming from JMS (not for request/reply over JMS). See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. When doing request/reply over JMS then the option replyToMaxConcurrentConsumers is used to control number of concurrent consumers on the reply message listener. |  | int
| *replyTo* (consumer) | Provides an explicit ReplyTo destination which overrides any incoming value of Message.getJMSReplyTo(). |  | String
| *replyToDeliveryPersistent* (consumer) | Specifies whether to use persistent delivery by default for replies. | true | boolean
| *selector* (consumer) | Sets the JMS selector to use |  | String
| *subscriptionDurable* (consumer) | Set whether to make the subscription durable. The durable subscription name to be used can be specified through the subscriptionName property. Default is false. Set this to true to register a durable subscription typically in combination with a subscriptionName value (unless your message listener class name is good enough as subscription name). Only makes sense when listening to a topic (pub-sub domain) therefore this method switches the pubSubDomain flag as well. | false | boolean
| *subscriptionName* (consumer) | Set the name of a subscription to create. To be applied in case of a topic (pub-sub domain) with a shared or durable subscription. The subscription name needs to be unique within this client's JMS client id. Default is the class name of the specified message listener. Note: Only 1 concurrent consumer (which is the default of this message listener container) is allowed for each subscription except for a shared subscription (which requires JMS 2.0). |  | String
| *subscriptionShared* (consumer) | Set whether to make the subscription shared. The shared subscription name to be used can be specified through the subscriptionName property. Default is false. Set this to true to register a shared subscription typically in combination with a subscriptionName value (unless your message listener class name is good enough as subscription name). Note that shared subscriptions may also be durable so this flag can (and often will) be combined with subscriptionDurable as well. Only makes sense when listening to a topic (pub-sub domain) therefore this method switches the pubSubDomain flag as well. Requires a JMS 2.0 compatible message broker. | false | boolean
| *acceptMessagesWhileStopping* (consumer) | Specifies whether the consumer accept messages while it is stopping. You may consider enabling this option if you start and stop JMS routes at runtime while there are still messages enqueued on the queue. If this option is false and you stop the JMS route then messages may be rejected and the JMS broker would have to attempt redeliveries which yet again may be rejected and eventually the message may be moved at a dead letter queue on the JMS broker. To avoid this its recommended to enable this option. | false | boolean
| *allowReplyManagerQuickStop* (consumer) | Whether the DefaultMessageListenerContainer used in the reply managers for request-reply messaging allow the DefaultMessageListenerContainer.runningAllowed flag to quick stop in case JmsConfigurationisAcceptMessagesWhileStopping is enabled and org.apache.camel.CamelContext is currently being stopped. This quick stop ability is enabled by default in the regular JMS consumers but to enable for reply managers you must enable this flag. | false | boolean
| *consumerType* (consumer) | The consumer type to use which can be one of: Simple Default or Custom. The consumer type determines which Spring JMS listener to use. Default will use org.springframework.jms.listener.DefaultMessageListenerContainer Simple will use org.springframework.jms.listener.SimpleMessageListenerContainer. When Custom is specified the MessageListenerContainerFactory defined by the messageListenerContainerFactory option will determine what org.springframework.jms.listener.AbstractMessageListenerContainer to use. | Default | ConsumerType
| *defaultTaskExecutorType* (consumer) | Specifies what default TaskExecutor type to use in the DefaultMessageListenerContainer for both consumer endpoints and the ReplyTo consumer of producer endpoints. Possible values: SimpleAsync (uses Spring's SimpleAsyncTaskExecutor) or ThreadPool (uses Spring's ThreadPoolTaskExecutor with optimal values - cached threadpool-like). If not set it defaults to the previous behaviour which uses a cached thread pool for consumer endpoints and SimpleAsync for reply consumers. The use of ThreadPool is recommended to reduce thread trash in elastic configurations with dynamically increasing and decreasing concurrent consumers. |  | DefaultTaskExecutor Type
| *eagerLoadingOfProperties* (consumer) | Enables eager loading of JMS properties and payload as soon as a message is loaded which generally is inefficient as the JMS properties may not be required but sometimes can catch early any issues with the underlying JMS provider and the use of JMS properties | false | boolean
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this options is not in use. By default the consumer will deal with exceptions that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. |  | ExchangePattern
| *exposeListenerSession* (consumer) | Specifies whether the listener session should be exposed when consuming messages. | false | boolean
| *replyToSameDestination Allowed* (consumer) | Whether a JMS consumer is allowed to send a reply message to the same destination that the consumer is using to consume from. This prevents an endless loop by consuming and sending back the same message to itself. | false | boolean
| *taskExecutor* (consumer) | Allows you to specify a custom task executor for consuming messages. |  | TaskExecutor
| *deliveryMode* (producer) | Specifies the delivery mode to be used. Possibles values are those defined by javax.jms.DeliveryMode. NON_PERSISTENT = 1 and PERSISTENT = 2. |  | Integer
| *deliveryPersistent* (producer) | Specifies whether persistent delivery is used by default. | true | boolean
| *explicitQosEnabled* (producer) | Set if the deliveryMode priority or timeToLive qualities of service should be used when sending messages. This option is based on Spring's JmsTemplate. The deliveryMode priority and timeToLive options are applied to the current endpoint. This contrasts with the preserveMessageQos option which operates at message granularity reading QoS properties exclusively from the Camel In message headers. | false | Boolean
| *preserveMessageQos* (producer) | Set to true if you want to send message using the QoS settings specified on the message instead of the QoS settings on the JMS endpoint. The following three headers are considered JMSPriority JMSDeliveryMode and JMSExpiration. You can provide all or only some of them. If not provided Camel will fall back to use the values from the endpoint instead. So when using this option the headers override the values from the endpoint. The explicitQosEnabled option by contrast will only use options set on the endpoint and not values from the message header. | false | boolean
| *priority* (producer) | Values greater than 1 specify the message priority when sending (where 0 is the lowest priority and 9 is the highest). The explicitQosEnabled option must also be enabled in order for this option to have any effect. | 4 | int
| *replyToConcurrentConsumers* (producer) | Specifies the default number of concurrent consumers when doing request/reply over JMS. See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. | 1 | int
| *replyToMaxConcurrent Consumers* (producer) | Specifies the maximum number of concurrent consumers when using request/reply over JMS. See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. |  | int
| *replyToOnTimeoutMax ConcurrentConsumers* (producer) | Specifies the maximum number of concurrent consumers for continue routing when timeout occurred when using request/reply over JMS. | 1 | int
| *replyToOverride* (producer) | Provides an explicit ReplyTo destination in the JMS message which overrides the setting of replyTo. It is useful if you want to forward the message to a remote Queue and receive the reply message from the ReplyTo destination. |  | String
| *replyToType* (producer) | Allows for explicitly specifying which kind of strategy to use for replyTo queues when doing request/reply over JMS. Possible values are: Temporary Shared or Exclusive. By default Camel will use temporary queues. However if replyTo has been configured then Shared is used by default. This option allows you to use exclusive queues instead of shared ones. See Camel JMS documentation for more details and especially the notes about the implications if running in a clustered environment and the fact that Shared reply queues has lower performance than its alternatives Temporary and Exclusive. |  | ReplyToType
| *requestTimeout* (producer) | The timeout for waiting for a reply when using the InOut Exchange Pattern (in milliseconds). The default is 20 seconds. You can include the header CamelJmsRequestTimeout to override this endpoint configured timeout value and thus have per message individual timeout values. See also the requestTimeoutCheckerInterval option. | 20000 | long
| *timeToLive* (producer) | When sending messages specifies the time-to-live of the message (in milliseconds). | -1 | long
| *allowAdditionalHeaders* (producer) | This option is used to allow additional headers which may have values that are invalid according to JMS specification. For example some message systems such as WMQ do this with header names using prefix JMS_IBM_MQMD_ containing values with byte array or other invalid types. You can specify multiple header names separated by comma and use as suffix for wildcard matching. |  | String
| *allowNullBody* (producer) | Whether to allow sending messages with no body. If this option is false and the message body is null then an JMSException is thrown. | true | boolean
| *alwaysCopyMessage* (producer) | If true Camel will always make a JMS message copy of the message when it is passed to the producer for sending. Copying the message is needed in some situations such as when a replyToDestinationSelectorName is set (incidentally Camel will set the alwaysCopyMessage option to true if a replyToDestinationSelectorName is set) | false | boolean
| *correlationProperty* (producer) | When using InOut exchange pattern use this JMS property instead of JMSCorrelationID JMS property to correlate messages. If set messages will be correlated solely on the value of this property JMSCorrelationID property will be ignored and not set by Camel. |  | String
| *disableTimeToLive* (producer) | Use this option to force disabling time to live. For example when you do request/reply over JMS then Camel will by default use the requestTimeout value as time to live on the message being sent. The problem is that the sender and receiver systems have to have their clocks synchronized so they are in sync. This is not always so easy to archive. So you can use disableTimeToLive=true to not set a time to live value on the sent message. Then the message will not expire on the receiver system. See below in section About time to live for more details. | false | boolean
| *forceSendOriginalMessage* (producer) | When using mapJmsMessage=false Camel will create a new JMS message to send to a new JMS destination if you touch the headers (get or set) during the route. Set this option to true to force Camel to send the original JMS message that was received. | false | boolean
| *includeSentJMSMessageID* (producer) | Only applicable when sending to JMS destination using InOnly (eg fire and forget). Enabling this option will enrich the Camel Exchange with the actual JMSMessageID that was used by the JMS client when the message was sent to the JMS destination. | false | boolean
| *replyToCacheLevelName* (producer) | Sets the cache level by name for the reply consumer when doing request/reply over JMS. This option only applies when using fixed reply queues (not temporary). Camel will by default use: CACHE_CONSUMER for exclusive or shared w/ replyToSelectorName. And CACHE_SESSION for shared without replyToSelectorName. Some JMS brokers such as IBM WebSphere may require to set the replyToCacheLevelName=CACHE_NONE to work. Note: If using temporary queues then CACHE_NONE is not allowed and you must use a higher value such as CACHE_CONSUMER or CACHE_SESSION. |  | String
| *replyToDestinationSelector Name* (producer) | Sets the JMS Selector using the fixed name to be used so you can filter out your own replies from the others when using a shared queue (that is if you are not using a temporary reply queue). |  | String
| *streamMessageTypeEnabled* (producer) | Sets whether StreamMessage type is enabled or not. Message payloads of streaming kind such as files InputStream etc will either by sent as BytesMessage or StreamMessage. This option controls which kind will be used. By default BytesMessage is used which enforces the entire message payload to be read into memory. By enabling this option the message payload is read into memory in chunks and each chunk is then written to the StreamMessage until no more data. | false | boolean
| *allowSerializedHeaders* (advanced) | Controls whether or not to include serialized headers. Applies only when transferExchange is true. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *asyncStartListener* (advanced) | Whether to startup the JmsConsumer message listener asynchronously when starting a route. For example if a JmsConsumer cannot get a connection to a remote JMS broker then it may block while retrying and/or failover. This will cause Camel to block while starting routes. By setting this option to true you will let routes startup while the JmsConsumer connects to the JMS broker using a dedicated thread in asynchronous mode. If this option is used then beware that if the connection could not be established then an exception is logged at WARN level and the consumer will not be able to receive messages; You can then restart the route to retry. | false | boolean
| *asyncStopListener* (advanced) | Whether to stop the JmsConsumer message listener asynchronously when stopping a route. | false | boolean
| *destinationResolver* (advanced) | A pluggable org.springframework.jms.support.destination.DestinationResolver that allows you to use your own resolver (for example to lookup the real destination in a JNDI registry). |  | DestinationResolver
| *errorHandler* (advanced) | Specifies a org.springframework.util.ErrorHandler to be invoked in case of any uncaught exceptions thrown while processing a Message. By default these exceptions will be logged at the WARN level if no errorHandler has been configured. You can configure logging level and whether stack traces should be logged using errorHandlerLoggingLevel and errorHandlerLogStackTrace options. This makes it much easier to configure than having to code a custom errorHandler. |  | ErrorHandler
| *exceptionListener* (advanced) | Specifies the JMS Exception Listener that is to be notified of any underlying JMS exceptions. |  | ExceptionListener
| *headerFilterStrategy* (advanced) | To use a custom HeaderFilterStrategy to filter header to and from Camel message. |  | HeaderFilterStrategy
| *idleConsumerLimit* (advanced) | Specify the limit for the number of consumers that are allowed to be idle at any given time. | 1 | int
| *idleTaskExecutionLimit* (advanced) | Specifies the limit for idle executions of a receive task not having received any message within its execution. If this limit is reached the task will shut down and leave receiving to other executing tasks (in the case of dynamic scheduling; see the maxConcurrentConsumers setting). There is additional doc available from Spring. | 1 | int
| *includeAllJMSXProperties* (advanced) | Whether to include all JMSXxxx properties when mapping from JMS to Camel Message. Setting this to true will include properties such as JMSXAppID and JMSXUserID etc. Note: If you are using a custom headerFilterStrategy then this option does not apply. | false | boolean
| *jmsKeyFormatStrategy* (advanced) | Pluggable strategy for encoding and decoding JMS keys so they can be compliant with the JMS specification. Camel provides two implementations out of the box: default and passthrough. The default strategy will safely marshal dots and hyphens (. and -). The passthrough strategy leaves the key as is. Can be used for JMS brokers which do not care whether JMS header keys contain illegal characters. You can provide your own implementation of the org.apache.camel.component.jms.JmsKeyFormatStrategy and refer to it using the notation. |  | String
| *mapJmsMessage* (advanced) | Specifies whether Camel should auto map the received JMS message to a suited payload type such as javax.jms.TextMessage to a String etc. | true | boolean
| *maxMessagesPerTask* (advanced) | The number of messages per task. -1 is unlimited. If you use a range for concurrent consumers (eg min max) then this option can be used to set a value to eg 100 to control how fast the consumers will shrink when less work is required. | -1 | int
| *messageConverter* (advanced) | To use a custom Spring org.springframework.jms.support.converter.MessageConverter so you can be in control how to map to/from a javax.jms.Message. |  | MessageConverter
| *messageCreatedStrategy* (advanced) | To use the given MessageCreatedStrategy which are invoked when Camel creates new instances of javax.jms.Message objects when Camel is sending a JMS message. |  | MessageCreatedStrategy
| *messageIdEnabled* (advanced) | When sending specifies whether message IDs should be added. This is just an hint to the JMS broker.If the JMS provider accepts this hint these messages must have the message ID set to null; if the provider ignores the hint the message ID must be set to its normal unique value | true | boolean
| *messageListenerContainer Factory* (advanced) | Registry ID of the MessageListenerContainerFactory used to determine what org.springframework.jms.listener.AbstractMessageListenerContainer to use to consume messages. Setting this will automatically set consumerType to Custom. |  | MessageListener ContainerFactory
| *messageTimestampEnabled* (advanced) | Specifies whether timestamps should be enabled by default on sending messages. This is just an hint to the JMS broker.If the JMS provider accepts this hint these messages must have the timestamp set to zero; if the provider ignores the hint the timestamp must be set to its normal value | true | boolean
| *pubSubNoLocal* (advanced) | Specifies whether to inhibit the delivery of messages published by its own connection. | false | boolean
| *receiveTimeout* (advanced) | The timeout for receiving messages (in milliseconds). | 1000 | long
| *recoveryInterval* (advanced) | Specifies the interval between recovery attempts i.e. when a connection is being refreshed in milliseconds. The default is 5000 ms that is 5 seconds. | 5000 | long
| *requestTimeoutChecker Interval* (advanced) | Configures how often Camel should check for timed out Exchanges when doing request/reply over JMS. By default Camel checks once per second. But if you must react faster when a timeout occurs then you can lower this interval to check more frequently. The timeout is determined by the option requestTimeout. | 1000 | long
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported). | false | boolean
| *transferException* (advanced) | If enabled and you are using Request Reply messaging (InOut) and an Exchange failed on the consumer side then the caused Exception will be send back in response as a javax.jms.ObjectMessage. If the client is Camel the returned Exception is rethrown. This allows you to use Camel JMS as a bridge in your routing - for example using persistent queues to enable robust routing. Notice that if you also have transferExchange enabled this option takes precedence. The caught exception is required to be serializable. The original Exception on the consumer side can be wrapped in an outer exception such as org.apache.camel.RuntimeCamelException when returned to the producer. | false | boolean
| *transferExchange* (advanced) | You can transfer the exchange over the wire instead of just the body and headers. The following fields are transferred: In body Out body Fault body In headers Out headers Fault headers exchange properties exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. You must enable this option on both the producer and consumer side so Camel knows the payloads is an Exchange and not a regular payload. | false | boolean
| *transferFault* (advanced) | If enabled and you are using Request Reply messaging (InOut) and an Exchange failed with a SOAP fault (not exception) on the consumer side then the fault flag on MessageisFault() will be send back in the response as a JMS header with the key org.apache.camel.component.jms.JmsConstantsJMS_TRANSFER_FAULTJMS_TRANSFER_FAULT. If the client is Camel the returned fault flag will be set on the link org.apache.camel.MessagesetFault(boolean). You may want to enable this when using Camel components that support faults such as SOAP based such as cxf or spring-ws. | false | boolean
| *useMessageIDAsCorrelation ID* (advanced) | Specifies whether JMSMessageID should always be used as JMSCorrelationID for InOut messages. | false | boolean
| *waitForProvisionCorrelation ToBeUpdatedCounter* (advanced) | Number of times to wait for provisional correlation id to be updated to the actual correlation id when doing request/reply over JMS and when the option useMessageIDAsCorrelationID is enabled. | 50 | int
| *waitForProvisionCorrelation ToBeUpdatedThreadSleeping Time* (advanced) | Interval in millis to sleep each time while waiting for provisional correlation id to be updated. | 100 | long
| *errorHandlerLoggingLevel* (logging) | Allows to configure the default errorHandler logging level for logging uncaught exceptions. | WARN | LoggingLevel
| *errorHandlerLogStackTrace* (logging) | Allows to control whether stacktraces should be logged or not by the default errorHandler. | true | boolean
| *password* (security) | Password to use with the ConnectionFactory. You can also configure username/password directly on the ConnectionFactory. |  | String
| *username* (security) | Username to use with the ConnectionFactory. You can also configure username/password directly on the ConnectionFactory. |  | String
| *transacted* (transaction) | Specifies whether to use transacted mode | false | boolean
| *lazyCreateTransaction Manager* (transaction) | If true Camel will create a JmsTransactionManager if there is no transactionManager injected when option transacted=true. | true | boolean
| *transactionManager* (transaction) | The Spring transaction manager to use. |  | PlatformTransaction Manager
| *transactionName* (transaction) | The name of the transaction to use. |  | String
| *transactionTimeout* (transaction) | The timeout value of the transaction (in seconds) if using transacted mode. | -1 | int
|===
// endpoint options: END




### Usage

As AMQP component is inherited from JMS component, the usage of the
former is almost identical to the latter:

*Using AMQP component*

[source,java]
------------------------------------
// Consuming from AMQP queue
from(""amqp:queue:incoming"").
  to(...);
 
// Sending message to the AMQP topic
from(...).
  to(""amqp:topic:notify"");
------------------------------------

### Configuring AMQP component

Starting from the Camel 2.16.1 you can also use the
`AMQPComponent#amqp10Component(String connectionURI)` factory method to
return the AMQP 1.0 component with the pre-configured topic prefix: 

*Creating AMQP 1.0 component*

[source,java]
-----------------------------------------------------------------------------------------
 AMQPComponent amqp = AMQPComponent.amqp10Component(""amqp://guest:guest@localhost:5672"");
-----------------------------------------------------------------------------------------

Keep in mind that starting from the
Camel 2.17 the `AMQPComponent#amqp10Component(String connectionURI)` factory
method has been deprecated on the behalf of the
`AMQPComponent#amqpComponent(String connectionURI)`: 

*Creating AMQP 1.0 component*

[source,java]
--------------------------------------------------------------------------------------------------------
AMQPComponent amqp = AMQPComponent.amqpComponent(""amqp://localhost:5672"");
 
AMQPComponent authorizedAmqp = AMQPComponent.amqpComponent(""amqp://localhost:5672"", ""user"", ""password"");
--------------------------------------------------------------------------------------------------------

Starting from Camel 2.17, in order to automatically configure the AMQP
component, you can also add an instance
of `org.apache.camel.component.amqp.AMQPConnectionDetails` to the
registry. For example for Spring Boot you just have to define bean:

*AMQP connection details auto-configuration*

[source,java]
-------------------------------------------------------------------------------------
@Bean
AMQPConnectionDetails amqpConnection() {
  return new AMQPConnectionDetails(""amqp://localhost:5672""); 
}
 
@Bean
AMQPConnectionDetails securedAmqpConnection() {
  return new AMQPConnectionDetails(""amqp://lcoalhost:5672"", ""username"", ""password""); 
}
-------------------------------------------------------------------------------------

Likewise, you can also use CDI producer methods when using Camel-CDI

*AMQP connection details auto-configuration for CDI*

[source,java]
-------------------------------------------------------------------------------------
@Produces
AMQPConnectionDetails amqpConnection() {
  return new AMQPConnectionDetails(""amqp://localhost:5672"");
}
------------------------------------------------------------------------------------- 

You can also rely on the <<properties-component,Camel properties>> to read
the AMQP connection details. Factory
method `AMQPConnectionDetails.discoverAMQP()` attempts to read Camel
properties in a Kubernetes-like convention, just as demonstrated on the
snippet below:

 

*AMQP connection details auto-configuration*

[source,java]
-----------------------------------------------
export AMQP_SERVICE_HOST = ""mybroker.com""
export AMQP_SERVICE_PORT = ""6666""
export AMQP_SERVICE_USERNAME = ""username""
export AMQP_SERVICE_PASSWORD = ""password""
 
...
 
@Bean
AMQPConnectionDetails amqpConnection() {
  return AMQPConnectionDetails.discoverAMQP(); 
}
-----------------------------------------------

### Using topics

To have using topics working with `camel-amqp` you need to configure the
component to use `topic://` as topic prefix, as shown below:

[source,java]
-------------------------------------------------------------------------------------------------------------------------------
 <bean id=""amqp"" class=""org.apache.camel.component.amqp.AmqpComponent"">
   <property name=""connectionFactory"">
     <bean class=""org.apache.qpid.jms.JmsConnectionFactory"" factory-method=""createFromURL"">
       <property name=""remoteURI"" value=""amqp://localhost:5672"" />
       <property name=""topicPrefix"" value=""topic://"" />  <!-- only necessary when connecting to ActiveMQ over AMQP 1.0 -->
     </bean>
   </property>
 </bean>
-------------------------------------------------------------------------------------------------------------------------------

Keep in mind that both  `AMQPComponent#amqpComponent()` methods and
`AMQPConnectionDetails` pre-configure the component with the topic
prefix, so you don't have to configure it explicitly.

### See Also

* Configuring Camel
* Component
* Endpoint
* Getting Started
",12486,True,2960.1689984961,median
"/*
 * Copyright (c) 2010-2013 ARM Limited
 * All rights reserved.
 *
 * The license below extends only to copyright in the software and shall
 * not be construed as granting a license to any other intellectual
 * property including but not limited to intellectual property relating
 * to a hardware implementation of the functionality of the software
 * licensed hereunder.  You may use the software subject to the license
 * terms below provided that you ensure that this notice is replicated
 * unmodified and in its entirety in all distributions of the software,
 * modified or unmodified, in source code or in binary form.
 *
 * Copyright (c) 2002-2005 The Regents of The University of Michigan
 * Copyright (c) 2010 Advanced Micro Devices, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met: redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer;
 * redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution;
 * neither the name of the copyright holders nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Authors: Erik Hallnor
 *          Dave Greene
 *          Nathan Binkert
 *          Steve Reinhardt
 *          Ron Dreslinski
 *          Andreas Sandberg
 */

#ifndef __MEM_CACHE_CACHE_IMPL_HH__
#define __MEM_CACHE_CACHE_IMPL_HH__

/**
 * @file
 * Cache definitions.
 */

#include ""base/misc.hh""
#include ""base/types.hh""
#include ""debug/Cache.hh""
#include ""debug/CachePort.hh""
#include ""debug/CacheTags.hh""
#include ""mem/cache/prefetch/base.hh""
#include ""mem/cache/blk.hh""
#include ""mem/cache/cache.hh""
#include ""mem/cache/mshr.hh""
#include ""sim/sim_exit.hh""

template<class TagStore>
Cache<TagStore>::Cache(const Params *p)
    : BaseCache(p),
      tags(dynamic_cast<TagStore*>(p->tags)),
      prefetcher(p->prefetcher),
      doFastWrites(true),
      prefetchOnAccess(p->prefetch_on_access)
{
    tempBlock = new BlkType();
    tempBlock->data = new uint8_t[blkSize];

    cpuSidePort = new CpuSidePort(p->name + "".cpu_side"", this,
                                  ""CpuSidePort"");
    memSidePort = new MemSidePort(p->name + "".mem_side"", this,
                                  ""MemSidePort"");

    tags->setCache(this);
    if (prefetcher)
        prefetcher->setCache(this);
}

template<class TagStore>
Cache<TagStore>::~Cache()
{
    delete [] tempBlock->data;
    delete tempBlock;

    delete cpuSidePort;
    delete memSidePort;
}

template<class TagStore>
void
Cache<TagStore>::regStats()
{
    BaseCache::regStats();
}

template<class TagStore>
void
Cache<TagStore>::cmpAndSwap(BlkType *blk, PacketPtr pkt)
{
    uint64_t overwrite_val;
    bool overwrite_mem;
    uint64_t condition_val64;
    uint32_t condition_val32;

    int offset = tags->extractBlkOffset(pkt->getAddr());
    uint8_t *blk_data = blk->data + offset;

    assert(sizeof(uint64_t) >= pkt->getSize());

    overwrite_mem = true;
    // keep a copy of our possible write value, and copy what is at the
    // memory address into the packet
    pkt->writeData((uint8_t *)&overwrite_val);
    pkt->setData(blk_data);

    if (pkt->req->isCondSwap()) {
        if (pkt->getSize() == sizeof(uint64_t)) {
            condition_val64 = pkt->req->getExtraData();
            overwrite_mem = !std::memcmp(&condition_val64, blk_data,
                                         sizeof(uint64_t));
        } else if (pkt->getSize() == sizeof(uint32_t)) {
            condition_val32 = (uint32_t)pkt->req->getExtraData();
            overwrite_mem = !std::memcmp(&condition_val32, blk_data,
                                         sizeof(uint32_t));
        } else
            panic(""Invalid size for conditional read/write\\n"");
    }

    if (overwrite_mem) {
        std::memcpy(blk_data, &overwrite_val, pkt->getSize());
        blk->status |= BlkDirty;
    }
}


template<class TagStore>
void
Cache<TagStore>::satisfyCpuSideRequest(PacketPtr pkt, BlkType *blk,
                                       bool deferred_response,
                                       bool pending_downgrade)
{
    assert(blk && blk->isValid());
    // Occasionally this is not true... if we are a lower-level cache
    // satisfying a string of Read and ReadEx requests from
    // upper-level caches, a Read will mark the block as shared but we
    // can satisfy a following ReadEx anyway since we can rely on the
    // Read requester(s) to have buffered the ReadEx snoop and to
    // invalidate their blocks after receiving them.
    // assert(!pkt->needsExclusive() || blk->isWritable());
    assert(pkt->getOffset(blkSize) + pkt->getSize() <= blkSize);

    // Check RMW operations first since both isRead() and
    // isWrite() will be true for them
    if (pkt->cmd == MemCmd::SwapReq) {
        cmpAndSwap(blk, pkt);
    } else if (pkt->isWrite()) {
        if (blk->checkWrite(pkt)) {
            pkt->writeDataToBlock(blk->data, blkSize);
            blk->status |= BlkDirty;
        }
    } else if (pkt->isRead()) {
        if (pkt->isLLSC()) {
            blk->trackLoadLocked(pkt);
        }
        pkt->setDataFromBlock(blk->data, blkSize);
        if (pkt->getSize() == blkSize) {
            // special handling for coherent block requests from
            // upper-level caches
            if (pkt->needsExclusive()) {
                // if we have a dirty copy, make sure the recipient
                // keeps it marked dirty
                if (blk->isDirty()) {
                    pkt->assertMemInhibit();
                }
                // on ReadExReq we give up our copy unconditionally
                if (blk != tempBlock)
                    tags->invalidate(blk);
                blk->invalidate();
            } else if (blk->isWritable() && !pending_downgrade
                      && !pkt->sharedAsserted() && !pkt->req->isInstFetch()) {
                // we can give the requester an exclusive copy (by not
                // asserting shared line) on a read request if:
                // - we have an exclusive copy at this level (& below)
                // - we don't have a pending snoop from below
                //   signaling another read request
                // - no other cache above has a copy (otherwise it
                //   would have asseretd shared line on request)
                // - we are not satisfying an instruction fetch (this
                //   prevents dirty data in the i-cache)

                if (blk->isDirty()) {
                    // special considerations if we're owner:
                    if (!deferred_response && !isTopLevel) {
                        // if we are responding immediately and can
                        // signal that we're transferring ownership
                        // along with exclusivity, do so
                        pkt->assertMemInhibit();
                        blk->status &= ~BlkDirty;
                    } else {
                        // if we're responding after our own miss,
                        // there's a window where the recipient didn't
                        // know it was getting ownership and may not
                        // have responded to snoops correctly, so we
                        // can't pass off ownership *or* exclusivity
                        pkt->assertShared();
                    }
                }
            } else {
                // otherwise only respond with a shared copy
                pkt->assertShared();
            }
        }
    } else {
        // Not a read or write... must be an upgrade.  it's OK
        // to just ack those as long as we have an exclusive
        // copy at this level.
        assert(pkt->isUpgrade());
        assert(blk != tempBlock);
        tags->invalidate(blk);
        blk->invalidate();
    }
}


/////////////////////////////////////////////////////
//
// MSHR helper functions
//
/////////////////////////////////////////////////////


template<class TagStore>
void
Cache<TagStore>::markInService(MSHR *mshr, PacketPtr pkt)
{
    markInServiceInternal(mshr, pkt);
#if 0
        if (mshr->originalCmd == MemCmd::HardPFReq) {
            DPRINTF(HWPrefetch, ""%s:Marking a HW_PF in service\\n"",
                    name());
            //Also clear pending if need be
            if (!prefetcher->havePending())
            {
                deassertMemSideBusRequest(Request_PF);
            }
        }
#endif
}


template<class TagStore>
void
Cache<TagStore>::squash(int threadNum)
{
    bool unblock = false;
    BlockedCause cause = NUM_BLOCKED_CAUSES;

    if (noTargetMSHR && noTargetMSHR->threadNum == threadNum) {
        noTargetMSHR = NULL;
        unblock = true;
        cause = Blocked_NoTargets;
    }
    if (mshrQueue.isFull()) {
        unblock = true;
        cause = Blocked_NoMSHRs;
    }
    mshrQueue.squash(threadNum);
    if (unblock && !mshrQueue.isFull()) {
        clearBlocked(cause);
    }
}

/////////////////////////////////////////////////////
//
// Access path: requests coming in from the CPU side
//
/////////////////////////////////////////////////////

template<class TagStore>
bool
Cache<TagStore>::access(PacketPtr pkt, BlkType *&blk,
                        Cycles &lat, PacketList &writebacks)
{
    DPRINTF(Cache, ""%s for %s address %x size %d\\n"", __func__,
            pkt->cmdString(), pkt->getAddr(), pkt->getSize());
    if (pkt->req->isUncacheable()) {
        uncacheableFlush(pkt);
        blk = NULL;
        lat = hitLatency;
        return false;
    }

    int id = pkt->req->hasContextId() ? pkt->req->contextId() : -1;
    blk = tags->accessBlock(pkt->getAddr(), pkt->isSecure(), lat, id);

    DPRINTF(Cache, ""%s%s %x (%s) %s %s\\n"", pkt->cmdString(),
            pkt->req->isInstFetch() ? "" (ifetch)"" : """",
            pkt->getAddr(), pkt->isSecure() ? ""s"" : ""ns"",
            blk ? ""hit"" : ""miss"", blk ? blk->print() : """");

    if (blk != NULL) {

        if (pkt->needsExclusive() ? blk->isWritable() : blk->isReadable()) {
            // OK to satisfy access
            incHitCount(pkt);
            satisfyCpuSideRequest(pkt, blk);
            return true;
        }
    }

    // Can't satisfy access normally... either no block (blk == NULL)
    // or have block but need exclusive & only have shared.

    // Writeback handling is special case.  We can write the block
    // into the cache without having a writeable copy (or any copy at
    // all).
    if (pkt->cmd == MemCmd::Writeback) {
        assert(blkSize == pkt->getSize());
        if (blk == NULL) {
            // need to do a replacement
            blk = allocateBlock(pkt->getAddr(), pkt->isSecure(), writebacks);
            if (blk == NULL) {
                // no replaceable block available, give up.
                // writeback will be forwarded to next level.
                incMissCount(pkt);
                return false;
            }
            tags->insertBlock(pkt, blk);
            blk->status = BlkValid | BlkReadable;
        }
        std::memcpy(blk->data, pkt->getPtr<uint8_t>(), blkSize);
        blk->status |= BlkDirty;
        if (pkt->isSupplyExclusive()) {
            blk->status |= BlkWritable;
        }
        // nothing else to do; writeback doesn't expect response
        assert(!pkt->needsResponse());
        DPRINTF(Cache, ""%s new state is %s\\n"", __func__, blk->print());
        incHitCount(pkt);
        return true;
    }

    incMissCount(pkt);

    if (blk == NULL && pkt->isLLSC() && pkt->isWrite()) {
        // complete miss on store conditional... just give up now
        pkt->req->setExtraData(0);
        return true;
    }

    return false;
}


class ForwardResponseRecord : public Packet::SenderState
{
  public:

    PortID prevSrc;

    ForwardResponseRecord(PortID prev_src) : prevSrc(prev_src)
    {}
};

template<class TagStore>
void
Cache<TagStore>::recvTimingSnoopResp(PacketPtr pkt)
{
    DPRINTF(Cache, ""%s for %s address %x size %d\\n"", __func__,
            pkt->cmdString(), pkt->getAddr(), pkt->getSize());
    Tick time = clockEdge(hitLatency);

    assert(pkt->isResponse());

    // must be cache-to-cache response from upper to lower level
    ForwardResponseRecord *rec =
        dynamic_cast<ForwardResponseRecord *>(pkt->senderState);
    assert(!system->bypassCaches());

    if (rec == NULL) {
        assert(pkt->cmd == MemCmd::HardPFResp);
        // Check if it's a prefetch response and handle it. We shouldn't
        // get any other kinds of responses without FRRs.
        DPRINTF(Cache, ""Got prefetch response from above for addr %#x (%s)\\n"",
                pkt->getAddr(), pkt->isSecure() ? ""s"" : ""ns"");
        recvTimingResp(pkt);
        return;
    }

    pkt->popSenderState();
    pkt->setDest(rec->prevSrc);
    delete rec;
    // @todo someone should pay for this
    pkt->busFirstWordDelay = pkt->busLastWordDelay = 0;
    memSidePort->schedTimingSnoopResp(pkt, time);
}

template<class TagStore>
bool
Cache<TagStore>::recvTimingReq(PacketPtr pkt)
{
    DPRINTF(CacheTags, ""%s tags: %s\\n"", __func__, tags->print());
//@todo Add back in MemDebug Calls
//    MemDebug::cacheAccess(pkt);


    /// @todo temporary hack to deal with memory corruption issue until
    /// 4-phase transactions are complete
    for (int x = 0; x < pendingDelete.size(); x++)
        delete pendingDelete[x];
    pendingDelete.clear();

    // we charge hitLatency for doing just about anything here
    Tick time = clockEdge(hitLatency);

    assert(pkt->isRequest());

    // Just forward the packet if caches are disabled.
    if (system->bypassCaches()) {
        memSidePort->sendTimingReq(pkt);
        return true;
    }

    if (pkt->memInhibitAsserted()) {
        DPRINTF(Cache, ""mem inhibited on 0x%x (%s): not responding\\n"",
                pkt->getAddr(), pkt->isSecure() ? ""s"" : ""ns"");
        assert(!pkt->req->isUncacheable());
        // Special tweak for multilevel coherence: snoop downward here
        // on invalidates since there may be other caches below here
        // that have shared copies.  Not necessary if we know that
        // supplier had exclusive copy to begin with.
        if (pkt->needsExclusive() && !pkt->isSupplyExclusive()) {
            Packet *snoopPkt = new Packet(pkt, true);  // clear flags
            // also reset the bus time that the original packet has
            // not yet paid for
            snoopPkt->busFirstWordDelay = snoopPkt->busLastWordDelay = 0;
            snoopPkt->setExpressSnoop();
            snoopPkt->assertMemInhibit();
            memSidePort->sendTimingReq(snoopPkt);
            // main memory will delete snoopPkt
        }
        // since we're the official target but we aren't responding,
        // delete the packet now.

        /// @todo nominally we should just delete the packet here,
        /// however, until 4-phase stuff we can't because sending
        /// cache is still relying on it
        pendingDelete.push_back(pkt);
        return true;
    }

    if (pkt->req->isUncacheable()) {
        uncacheableFlush(pkt);

        // @todo: someone should pay for this
        pkt->busFirstWordDelay = pkt->busLastWordDelay = 0;

        // writes go in write buffer, reads use MSHR
        if (pkt->isWrite() && !pkt->isRead()) {
            allocateWriteBuffer(pkt, time, true);
        } else {
            allocateUncachedReadBuffer(pkt, time, true);
        }
        assert(pkt->needsResponse()); // else we should delete it here??
        return true;
    }

    Cycles lat = hitLatency;
    BlkType *blk = NULL;
    PacketList writebacks;

    bool satisfied = access(pkt, blk, lat, writebacks);

#if 0
    /** @todo make the fast write alloc (wh64) work with coherence. */

    // If this is a block size write/hint (WH64) allocate the block here
    // if the coherence protocol allows it.
    if (!blk && pkt->getSize() >= blkSize && coherence->allowFastWrites() &&
        (pkt->cmd == MemCmd::WriteReq
         || pkt->cmd == MemCmd::WriteInvalidateReq) ) {
        // not outstanding misses, can do this
        MSHR *outstanding_miss = mshrQueue.findMatch(pkt->getAddr(),
                                                     pkt->isSecure());
        if (pkt->cmd == MemCmd::WriteInvalidateReq || !outstanding_miss) {
            if (outstanding_miss) {
                warn(""WriteInv doing a fastallocate""
                     ""with an outstanding miss to the same address\\n"");
            }
            blk = handleFill(NULL, pkt, BlkValid | BlkWritable,
                                   writebacks);
            ++fastWrites;
        }
    }
#endif

    // track time of availability of next prefetch, if any
    Tick next_pf_time = 0;

    bool needsResponse = pkt->needsResponse();

    if (satisfied) {
        if (prefetcher && (prefetchOnAccess || (blk && blk->wasPrefetched()))) {
            if (blk)
                blk->status &= ~BlkHWPrefetched;
            next_pf_time = prefetcher->notify(pkt, time);
        }

        if (needsResponse) {
            pkt->makeTimingResponse();
            // @todo: Make someone pay for this
            pkt->busFirstWordDelay = pkt->busLastWordDelay = 0;
            cpuSidePort->schedTimingResp(pkt, clockEdge(lat));
        } else {
            /// @todo nominally we should just delete the packet here,
            /// however, until 4-phase stuff we can't because sending
            /// cache is still relying on it
            pendingDelete.push_back(pkt);
        }
    } else {
        // miss

        // @todo: Make someone pay for this
        pkt->busFirstWordDelay = pkt->busLastWordDelay = 0;

        Addr blk_addr = blockAlign(pkt->getAddr());
        MSHR *mshr = mshrQueue.findMatch(blk_addr, pkt->isSecure());

        if (mshr) {
            /// MSHR hit
            /// @note writebacks will be checked in getNextMSHR()
            /// for any conflicting requests to the same block

            //@todo remove hw_pf here
            assert(pkt->req->masterId() < system->maxMasters());
            mshr_hits[pkt->cmdToIndex()][pkt->req->masterId()]++;
            if (mshr->threadNum != 0/*pkt->req->threadId()*/) {
                mshr->threadNum = -1;
            }
            mshr->allocateTarget(pkt, time, order++);
            if (mshr->getNumTargets() == numTarget) {
                noTargetMSHR = mshr;
                setBlocked(Blocked_NoTargets);
                // need to be careful with this... if this mshr isn't
                // ready yet (i.e. time > curTick()_, we don't want to
                // move it ahead of mshrs that are ready
                // mshrQueue.moveToFront(mshr);
            }

            // We should call the prefetcher reguardless if the request is
            // satisfied or not, reguardless if the request is in the MSHR or
            // not.  The request could be a ReadReq hit, but still not
            // satisfied (potentially because of a prior write to the same
            // cache line.  So, even when not satisfied, tehre is an MSHR
            // already allocated for this, we need to let the prefetcher know
            // about the request
            if (prefetcher) {
                next_pf_time = prefetcher->notify(pkt, time);
            }
        } else {
            // no MSHR
            assert(pkt->req->masterId() < system->maxMasters());
            mshr_misses[pkt->cmdToIndex()][pkt->req->masterId()]++;
            // always mark as cache fill for now... if we implement
            // no-write-allocate or bypass accesses this will have to
            // be changed.
            if (pkt->cmd == MemCmd::Writeback) {
                allocateWriteBuffer(pkt, time, true);
            } else {
                if (blk && blk->isValid()) {
                    // If we have a write miss to a valid block, we
                    // need to mark the block non-readable.  Otherwise
                    // if we allow reads while there's an outstanding
                    // write miss, the read could return stale data
                    // out of the cache block... a more aggressive
                    // system could detect the overlap (if any) and
                    // forward data out of the MSHRs, but we don't do
                    // that yet.  Note that we do need to leave the
                    // block valid so that it stays in the cache, in
                    // case we get an upgrade response (and hence no
                    // new data) when the write miss completes.
                    // As long as CPUs do proper store/load forwarding
                    // internally, and have a sufficiently weak memory
                    // model, this is probably unnecessary, but at some
                    // point it must have seemed like we needed it...
                    assert(pkt->needsExclusive() && !blk->isWritable());
                    blk->status &= ~BlkReadable;
                }

                allocateMissBuffer(pkt, time, true);
            }

            if (prefetcher) {
                next_pf_time = prefetcher->notify(pkt, time);
            }
        }
    }

    if (next_pf_time != 0)
        requestMemSideBus(Request_PF, std::max(time, next_pf_time));

    // copy writebacks to write buffer
    while (!writebacks.empty()) {
        PacketPtr wbPkt = writebacks.front();
        allocateWriteBuffer(wbPkt, time, true);
        writebacks.pop_front();
    }

    return true;
}


// See comment in cache.hh.
template<class TagStore>
PacketPtr
Cache<TagStore>::getBusPacket(PacketPtr cpu_pkt, BlkType *blk,
                              bool needsExclusive) const
{
    bool blkValid = blk && blk->isValid();

    if (cpu_pkt->req->isUncacheable()) {
        //assert(blk == NULL);
        return NULL;
    }

    if (!blkValid &&
        (cpu_pkt->cmd == MemCmd::Writeback || cpu_pkt->isUpgrade())) {
        // Writebacks that weren't allocated in access() and upgrades
        // from upper-level caches that missed completely just go
        // through.
        return NULL;
    }

    assert(cpu_pkt->needsResponse());

    MemCmd cmd;
    // @TODO make useUpgrades a parameter.
    // Note that ownership protocols require upgrade, otherwise a
    // write miss on a shared owned block will generate a ReadExcl,
    // which will clobber the owned copy.
    const bool useUpgrades = true;
    if (blkValid && useUpgrades) {
        // only reason to be here is that blk is shared
        // (read-only) and we need exclusive
        assert(needsExclusive && !blk->isWritable());
        cmd = cpu_pkt->isLLSC() ? MemCmd::SCUpgradeReq : MemCmd::UpgradeReq;
    } else {
        // block is invalid
        cmd = needsExclusive ? MemCmd::ReadExReq : MemCmd::ReadReq;
    }
    PacketPtr pkt = new Packet(cpu_pkt->req, cmd, blkSize);

    pkt->allocate();
    DPRINTF(Cache, ""%s created %s address %x size %d\\n"",
            __func__, pkt->cmdString(), pkt->getAddr(), pkt->getSize());
    return pkt;
}


template<class TagStore>
Tick
Cache<TagStore>::recvAtomic(PacketPtr pkt)
{
    Cycles lat = hitLatency;

    // @TODO: make this a parameter
    bool last_level_cache = false;

    // Forward the request if the system is in cache bypass mode.
    if (system->bypassCaches())
        return ticksToCycles(memSidePort->sendAtomic(pkt));

    if (pkt->memInhibitAsserted()) {
        assert(!pkt->req->isUncacheable());
        // have to invalidate ourselves and any lower caches even if
        // upper cache will be responding
        if (pkt->isInvalidate()) {
            BlkType *blk = tags->findBlock(pkt->getAddr(), pkt->isSecure());
            if (blk && blk->isValid()) {
                tags->invalidate(blk);
                blk->invalidate();
                DPRINTF(Cache, ""rcvd mem-inhibited %s on 0x%x (%s):""
                        "" invalidating\\n"",
                        pkt->cmdString(), pkt->getAddr(),
                        pkt->isSecure() ? ""s"" : ""ns"");
            }
            if (!last_level_cache) {
                DPRINTF(Cache, ""forwarding mem-inhibited %s on 0x%x (%s)\\n"",
                        pkt->cmdString(), pkt->getAddr(),
                        pkt->isSecure() ? ""s"" : ""ns"");
                lat += ticksToCycles(memSidePort->sendAtomic(pkt));
            }
        } else {
            DPRINTF(Cache, ""rcvd mem-inhibited %s on 0x%x: not responding\\n"",
                    pkt->cmdString(), pkt->getAddr());
        }

        return lat * clockPeriod();
    }

    // should assert here that there are no outstanding MSHRs or
    // writebacks... that would mean that someone used an atomic
    // access in timing mode

    BlkType *blk = NULL;
    PacketList writebacks;

    if (!access(pkt, blk, lat, writebacks)) {
        // MISS
        PacketPtr bus_pkt = getBusPacket(pkt, blk, pkt->needsExclusive());

        bool is_forward = (bus_pkt == NULL);

        if (is_forward) {
            // just forwarding the same request to the next level
            // no local cache operation involved
            bus_pkt = pkt;
        }

        DPRINTF(Cache, ""Sending an atomic %s for %x (%s)\\n"",
                bus_pkt->cmdString(), bus_pkt->getAddr(),
                bus_pkt->isSecure() ? ""s"" : ""ns"");

#if TRACING_ON
        CacheBlk::State old_state = blk ? blk->status : 0;
#endif

        lat += ticksToCycles(memSidePort->sendAtomic(bus_pkt));

        DPRINTF(Cache, ""Receive response: %s for addr %x (%s) in state %i\\n"",
                bus_pkt->cmdString(), bus_pkt->getAddr(),
                bus_pkt->isSecure() ? ""s"" : ""ns"",
                old_state);

        // If packet was a forward, the response (if any) is already
        // in place in the bus_pkt == pkt structure, so we don't need
        // to do anything.  Otherwise, use the separate bus_pkt to
        // generate response to pkt and then delete it.
        if (!is_forward) {
            if (pkt->needsResponse()) {
                assert(bus_pkt->isResponse());
                if (bus_pkt->isError()) {
                    pkt->makeAtomicResponse();
                    pkt->copyError(bus_pkt);
                } else if (bus_pkt->isRead() ||
                           bus_pkt->cmd == MemCmd::UpgradeResp) {
                    // we're updating cache state to allow us to
                    // satisfy the upstream request from the cache
                    blk = handleFill(bus_pkt, blk, writebacks);
                    satisfyCpuSideRequest(pkt, blk);
                } else {
                    // we're satisfying the upstream request without
                    // modifying cache state, e.g., a write-through
                    pkt->makeAtomicResponse();
                }
            }
            delete bus_pkt;
        }
    }

    // Note that we don't invoke the prefetcher at all in atomic mode.
    // It's not clear how to do it properly, particularly for
    // prefetchers that aggressively generate prefetch candidates and
    // rely on bandwidth contention to throttle them; these will tend
    // to pollute the cache in atomic mode since there is no bandwidth
    // contention.  If we ever do want to enable prefetching in atomic
    // mode, though, this is the place to do it... see timingAccess()
    // for an example (though we'd want to issue the prefetch(es)
    // immediately rather than calling requestMemSideBus() as we do
    // there).

    // Handle writebacks if needed
    while (!writebacks.empty()){
        PacketPtr wbPkt = writebacks.front();
        memSidePort->sendAtomic(wbPkt);
        writebacks.pop_front();
        delete wbPkt;
    }

    // We now have the block one way or another (hit or completed miss)

    if (pkt->needsResponse()) {
        pkt->makeAtomicResponse();
    }

    return lat * clockPeriod();
}


template<class TagStore>
void
Cache<TagStore>::functionalAccess(PacketPtr pkt, bool fromCpuSide)
{
    if (system->bypassCaches()) {
        // Packets from the memory side are snoop request and
        // shouldn't happen in bypass mode.
        assert(fromCpuSide);

        // The cache should be flushed if we are in cache bypass mode,
        // so we don't need to check if we need to update anything.
        memSidePort->sendFunctional(pkt);
        return;
    }

    Addr blk_addr = blockAlign(pkt->getAddr());
    bool is_secure = pkt->isSecure();
    BlkType *blk = tags->findBlock(pkt->getAddr(), is_secure);
    MSHR *mshr = mshrQueue.findMatch(blk_addr, is_secure);

    pkt->pushLabel(name());

    CacheBlkPrintWrapper cbpw(blk);

    // Note that just because an L2/L3 has valid data doesn't mean an
    // L1 doesn't have a more up-to-date modified copy that still
    // needs to be found.  As a result we always update the request if
    // we have it, but only declare it satisfied if we are the owner.

    // see if we have data at all (owned or otherwise)
    bool have_data = blk && blk->isValid()
        && pkt->checkFunctional(&cbpw, blk_addr, is_secure, blkSize,
                                blk->data);

    // data we have is dirty if marked as such or if valid & ownership
    // pending due to outstanding UpgradeReq
    bool have_dirty =
        have_data && (blk->isDirty() ||
                      (mshr && mshr->inService && mshr->isPendingDirty()));

    bool done = have_dirty
        || cpuSidePort->checkFunctional(pkt)
        || mshrQueue.checkFunctional(pkt, blk_addr)
        || writeBuffer.checkFunctional(pkt, blk_addr)
        || memSidePort->checkFunctional(pkt);

    DPRINTF(Cache, ""functional %s %x (%s) %s%s%s\\n"",
            pkt->cmdString(), pkt->getAddr(), is_secure ? ""s"" : ""ns"",
            (blk && blk->isValid()) ? ""valid "" : """",
            have_data ? ""data "" : """", done ? ""done "" : """");

    // We're leaving the cache, so pop cache->name() label
    pkt->popLabel();

    if (done) {
        pkt->makeResponse();
    } else {
        // if it came as a request from the CPU side then make sure it
        // continues towards the memory side
        if (fromCpuSide) {
            memSidePort->sendFunctional(pkt);
        } else if (forwardSnoops && cpuSidePort->isSnooping()) {
            // if it came from the memory side, it must be a snoop request
            // and we should only forward it if we are forwarding snoops
            cpuSidePort->sendFunctionalSnoop(pkt);
        }
    }
}


/////////////////////////////////////////////////////
//
// Response handling: responses from the memory side
//
/////////////////////////////////////////////////////


template<class TagStore>
void
Cache<TagStore>::recvTimingResp(PacketPtr pkt)
{
    assert(pkt->isResponse());

    Tick time = clockEdge(hitLatency);
    MSHR *mshr = dynamic_cast<MSHR*>(pkt->senderState);
    bool is_error = pkt->isError();

    assert(mshr);

    if (is_error) {
        DPRINTF(Cache, ""Cache received packet with error for address %x (%s), ""
                ""cmd: %s\\n"", pkt->getAddr(), pkt->isSecure() ? ""s"" : ""ns"",
                pkt->cmdString());
    }

    DPRINTF(Cache, ""Handling response to %s for address %x (%s)\\n"",
            pkt->cmdString(), pkt->getAddr(), pkt->isSecure() ? ""s"" : ""ns"");

    MSHRQueue *mq = mshr->queue;
    bool wasFull = mq->isFull();

    if (mshr == noTargetMSHR) {
        // we always clear at least one target
        clearBlocked(Blocked_NoTargets);
        noTargetMSHR = NULL;
    }

    // Initial target is used just for stats
    MSHR::Target *initial_tgt = mshr->getTarget();
    BlkType *blk = tags->findBlock(pkt->getAddr(), pkt->isSecure());
    int stats_cmd_idx = initial_tgt->pkt->cmdToIndex();
    Tick miss_latency = curTick() - initial_tgt->recvTime;
    PacketList writebacks;

    if (pkt->req->isUncacheable()) {
        assert(pkt->req->masterId() < system->maxMasters());
        mshr_uncacheable_lat[stats_cmd_idx][pkt->req->masterId()] +=
            miss_latency;
    } else {
        assert(pkt->req->masterId() < system->maxMasters());
        mshr_miss_latency[stats_cmd_idx][pkt->req->masterId()] +=
            miss_latency;
    }

    bool is_fill = !mshr->isForward &&
        (pkt->isRead() || pkt->cmd == MemCmd::UpgradeResp);

    if (is_fill && !is_error) {
        DPRINTF(Cache, ""Block for addr %x being updated in Cache\\n"",
                pkt->getAddr());

        // give mshr a chance to do some dirty work
        mshr->handleFill(pkt, blk);

        blk = handleFill(pkt, blk, writebacks);
        assert(blk != NULL);
    }

    // First offset for critical word first calculations
    int initial_offset = 0;

    if (mshr->hasTargets()) {
        initial_offset = mshr->getTarget()->pkt->getOffset(blkSize);
    }

    while (mshr->hasTargets()) {
        MSHR::Target *target = mshr->getTarget();

        switch (target->source) {
          case MSHR::Target::FromCPU:
            Tick completion_time;
            if (is_fill) {
                satisfyCpuSideRequest(target->pkt, blk,
                                      true, mshr->hasPostDowngrade());
                // How many bytes past the first request is this one
                int transfer_offset =
                    target->pkt->getOffset(blkSize) - initial_offset;
                if (transfer_offset < 0) {
                    transfer_offset += blkSize;
                }

                // If critical word (no offset) return first word time.
                // responseLatency is the latency of the return path
                // from lower level caches/memory to an upper level cache or
                // the core.
                completion_time = clockEdge(responseLatency) +
                    (transfer_offset ? pkt->busLastWordDelay :
                     pkt->busFirstWordDelay);

                assert(!target->pkt->req->isUncacheable());

                assert(target->pkt->req->masterId() < system->maxMasters());
                missLatency[target->pkt->cmdToIndex()][target->pkt->req->masterId()] +=
                    completion_time - target->recvTime;
            } else if (pkt->cmd == MemCmd::UpgradeFailResp) {
                // failed StoreCond upgrade
                assert(target->pkt->cmd == MemCmd::StoreCondReq ||
                       target->pkt->cmd == MemCmd::StoreCondFailReq ||
                       target->pkt->cmd == MemCmd::SCUpgradeFailReq);
                // responseLatency is the latency of the return path
                // from lower level caches/memory to an upper level cache or
                // the core.
                completion_time = clockEdge(responseLatency) +
                    pkt->busLastWordDelay;
                target->pkt->req->setExtraData(0);
            } else {
                // not a cache fill, just forwarding response
                // responseLatency is the latency of the return path
                // from lower level cahces/memory to the core.
                completion_time = clockEdge(responseLatency) +
                    pkt->busLastWordDelay;
                if (pkt->isRead() && !is_error) {
                    target->pkt->setData(pkt->getPtr<uint8_t>());
                }
            }
            target->pkt->makeTimingResponse();
            // if this packet is an error copy that to the new packet
            if (is_error)
                target->pkt->copyError(pkt);
            if (target->pkt->cmd == MemCmd::ReadResp &&
                (pkt->isInvalidate() || mshr->hasPostInvalidate())) {
                // If intermediate cache got ReadRespWithInvalidate,
                // propagate that.  Response should not have
                // isInvalidate() set otherwise.
                target->pkt->cmd = MemCmd::ReadRespWithInvalidate;
                DPRINTF(Cache, ""%s updated cmd to %s for address %x\\n"",
                        __func__, target->pkt->cmdString(),
                        target->pkt->getAddr());
            }
            // reset the bus additional time as it is now accounted for
            target->pkt->busFirstWordDelay = target->pkt->busLastWordDelay = 0;
            cpuSidePort->schedTimingResp(target->pkt, completion_time);
            break;

          case MSHR::Target::FromPrefetcher:
            assert(target->pkt->cmd == MemCmd::HardPFReq);
            if (blk)
                blk->status |= BlkHWPrefetched;
            delete target->pkt->req;
            delete target->pkt;
            break;

          case MSHR::Target::FromSnoop:
            // I don't believe that a snoop can be in an error state
            assert(!is_error);
            // response to snoop request
            DPRINTF(Cache, ""processing deferred snoop...\\n"");
            assert(!(pkt->isInvalidate() && !mshr->hasPostInvalidate()));
            handleSnoop(target->pkt, blk, true, true,
                        mshr->hasPostInvalidate());
            break;

          default:
            panic(""Illegal target->source enum %d\\n"", target->source);
        }

        mshr->popTarget();
    }

    if (blk && blk->isValid()) {
        if (pkt->isInvalidate() || mshr->hasPostInvalidate()) {
            assert(blk != tempBlock);
            tags->invalidate(blk);
            blk->invalidate();
        } else if (mshr->hasPostDowngrade()) {
            blk->status &= ~BlkWritable;
        }
    }

    if (mshr->promoteDeferredTargets()) {
        // avoid later read getting stale data while write miss is
        // outstanding.. see comment in timingAccess()
        if (blk) {
            blk->status &= ~BlkReadable;
        }
        mq = mshr->queue;
        mq->markPending(mshr);
        requestMemSideBus((RequestCause)mq->index, clockEdge() +
                          pkt->busLastWordDelay);
    } else {
        mq->deallocate(mshr);
        if (wasFull && !mq->isFull()) {
            clearBlocked((BlockedCause)mq->index);
        }
    }

    // copy writebacks to write buffer
    while (!writebacks.empty()) {
        PacketPtr wbPkt = writebacks.front();
        allocateWriteBuffer(wbPkt, time, true);
        writebacks.pop_front();
    }
    // if we used temp block, clear it out
    if (blk == tempBlock) {
        if (blk->isDirty()) {
            allocateWriteBuffer(writebackBlk(blk), time, true);
        }
        blk->invalidate();
    }

    DPRINTF(Cache, ""Leaving %s with %s for address %x\\n"", __func__,
            pkt->cmdString(), pkt->getAddr());
    delete pkt;
}




template<class TagStore>
PacketPtr
Cache<TagStore>::writebackBlk(BlkType *blk)
{
    assert(blk && blk->isValid() && blk->isDirty());

    writebacks[Request::wbMasterId]++;

    Request *writebackReq =
        new Request(tags->regenerateBlkAddr(blk->tag, blk->set), blkSize, 0,
                Request::wbMasterId);
    if (blk->isSecure())
        writebackReq->setFlags(Request::SECURE);

    writebackReq->taskId(blk->task_id);
    blk->task_id= ContextSwitchTaskId::Unknown;
    blk->tickInserted = curTick();

    PacketPtr writeback = new Packet(writebackReq, MemCmd::Writeback);
    if (blk->isWritable()) {
        writeback->setSupplyExclusive();
    }
    writeback->allocate();
    std::memcpy(writeback->getPtr<uint8_t>(), blk->data, blkSize);

    blk->status &= ~BlkDirty;
    return writeback;
}

template<class TagStore>
void
Cache<TagStore>::memWriteback()
{
    WrappedBlkVisitor visitor(*this, &Cache<TagStore>::writebackVisitor);
    tags->forEachBlk(visitor);
}

template<class TagStore>
void
Cache<TagStore>::memInvalidate()
{
    WrappedBlkVisitor visitor(*this, &Cache<TagStore>::invalidateVisitor);
    tags->forEachBlk(visitor);
}

template<class TagStore>
bool
Cache<TagStore>::isDirty() const
{
    CacheBlkIsDirtyVisitor<BlkType> visitor;
    tags->forEachBlk(visitor);

    return visitor.isDirty();
}

template<class TagStore>
bool
Cache<TagStore>::writebackVisitor(BlkType &blk)
{
    if (blk.isDirty()) {
        assert(blk.isValid());

        Request request(tags->regenerateBlkAddr(blk.tag, blk.set),
                        blkSize, 0, Request::funcMasterId);
        request.taskId(blk.task_id);

        Packet packet(&request, MemCmd::WriteReq);
        packet.dataStatic(blk.data);

        memSidePort->sendFunctional(&packet);

        blk.status &= ~BlkDirty;
    }

    return true;
}

template<class TagStore>
bool
Cache<TagStore>::invalidateVisitor(BlkType &blk)
{

    if (blk.isDirty())
        warn_once(""Invalidating dirty cache lines. Expect things to break.\\n"");

    if (blk.isValid()) {
        assert(!blk.isDirty());
        tags->invalidate(dynamic_cast< BlkType *>(&blk));
        blk.invalidate();
    }

    return true;
}

template<class TagStore>
void
Cache<TagStore>::uncacheableFlush(PacketPtr pkt)
{
    DPRINTF(Cache, ""%s%s %x uncacheable\\n"", pkt->cmdString(),
            pkt->req->isInstFetch() ? "" (ifetch)"" : """",
            pkt->getAddr());

    if (pkt->req->isClearLL())
        tags->clearLocks();

    BlkType *blk(tags->findBlock(pkt->getAddr(), pkt->isSecure()));
    if (blk) {
        writebackVisitor(*blk);
        invalidateVisitor(*blk);
    }
}


template<class TagStore>
typename Cache<TagStore>::BlkType*
Cache<TagStore>::allocateBlock(Addr addr, bool is_secure,
                               PacketList &writebacks)
{
    BlkType *blk = tags->findVictim(addr);

    if (blk->isValid()) {
        Addr repl_addr = tags->regenerateBlkAddr(blk->tag, blk->set);
        MSHR *repl_mshr = mshrQueue.findMatch(repl_addr, blk->isSecure());
        if (repl_mshr) {
            // must be an outstanding upgrade request on block
            // we're about to replace...
            assert(!blk->isWritable());
            assert(repl_mshr->needsExclusive());
            // too hard to replace block with transient state
            // allocation failed, block not inserted
            return NULL;
        } else {
            DPRINTF(Cache, ""replacement: replacing %x (%s) with %x (%s): %s\\n"",
                    repl_addr, blk->isSecure() ? ""s"" : ""ns"",
                    addr, is_secure ? ""s"" : ""ns"",
                    blk->isDirty() ? ""writeback"" : ""clean"");

            if (blk->isDirty()) {
                // Save writeback packet for handling by caller
                writebacks.push_back(writebackBlk(blk));
            }
        }
    }

    return blk;
}


// Note that the reason we return a list of writebacks rather than
// inserting them directly in the write buffer is that this function
// is called by both atomic and timing-mode accesses, and in atomic
// mode we don't mess with the write buffer (we just perform the
// writebacks atomically once the original request is complete).
template<class TagStore>
typename Cache<TagStore>::BlkType*
Cache<TagStore>::handleFill(PacketPtr pkt, BlkType *blk,
                            PacketList &writebacks)
{
    Addr addr = pkt->getAddr();
    bool is_secure = pkt->isSecure();
#if TRACING_ON
    CacheBlk::State old_state = blk ? blk->status : 0;
#endif

    if (blk == NULL) {
        // better have read new data...
        assert(pkt->hasData());
        // need to do a replacement
        blk = allocateBlock(addr, is_secure, writebacks);
        if (blk == NULL) {
            // No replaceable block... just use temporary storage to
            // complete the current request and then get rid of it
            assert(!tempBlock->isValid());
            blk = tempBlock;
            tempBlock->set = tags->extractSet(addr);
            tempBlock->tag = tags->extractTag(addr);
            // @todo: set security state as well...
            DPRINTF(Cache, ""using temp block for %x (%s)\\n"", addr,
                    is_secure ? ""s"" : ""ns"");
        } else {
            tags->insertBlock(pkt, blk);
        }

        // we should never be overwriting a valid block
        assert(!blk->isValid());
    } else {
        // existing block... probably an upgrade
        assert(blk->tag == tags->extractTag(addr));
        // either we're getting new data or the block should already be valid
        assert(pkt->hasData() || blk->isValid());
        // don't clear block status... if block is already dirty we
        // don't want to lose that
    }

    if (is_secure)
        blk->status |= BlkSecure;
    blk->status |= BlkValid | BlkReadable;

    if (!pkt->sharedAsserted()) {
        blk->status |= BlkWritable;
        // If we got this via cache-to-cache transfer (i.e., from a
        // cache that was an owner) and took away that owner's copy,
        // then we need to write it back.  Normally this happens
        // anyway as a side effect of getting a copy to write it, but
        // there are cases (such as failed store conditionals or
        // compare-and-swaps) where we'll demand an exclusive copy but
        // end up not writing it.
        if (pkt->memInhibitAsserted())
            blk->status |= BlkDirty;
    }

    DPRINTF(Cache, ""Block addr %x (%s) moving from state %x to %s\\n"",
            addr, is_secure ? ""s"" : ""ns"", old_state, blk->print());

    // if we got new data, copy it in
    if (pkt->isRead()) {
        std::memcpy(blk->data, pkt->getPtr<uint8_t>(), blkSize);
    }

    blk->whenReady = clockEdge() + responseLatency * clockPeriod() +
        pkt->busLastWordDelay;

    return blk;
}


/////////////////////////////////////////////////////
//
// Snoop path: requests coming in from the memory side
//
/////////////////////////////////////////////////////

template<class TagStore>
void
Cache<TagStore>::
doTimingSupplyResponse(PacketPtr req_pkt, uint8_t *blk_data,
                       bool already_copied, bool pending_inval)
{
    DPRINTF(Cache, ""%s for %s address %x size %d\\n"", __func__,
            req_pkt->cmdString(), req_pkt->getAddr(), req_pkt->getSize());
    // timing-mode snoop responses require a new packet, unless we
    // already made a copy...
    PacketPtr pkt = already_copied ? req_pkt : new Packet(req_pkt);
    assert(req_pkt->isInvalidate() || pkt->sharedAsserted());
    pkt->allocate();
    pkt->makeTimingResponse();
    // @todo Make someone pay for this
    pkt->busFirstWordDelay = pkt->busLastWordDelay = 0;
    if (pkt->isRead()) {
        pkt->setDataFromBlock(blk_data, blkSize);
    }
    if (pkt->cmd == MemCmd::ReadResp && pending_inval) {
        // Assume we defer a response to a read from a far-away cache
        // A, then later defer a ReadExcl from a cache B on the same
        // bus as us.  We'll assert MemInhibit in both cases, but in
        // the latter case MemInhibit will keep the invalidation from
        // reaching cache A.  This special response tells cache A that
        // it gets the block to satisfy its read, but must immediately
        // invalidate it.
        pkt->cmd = MemCmd::ReadRespWithInvalidate;
    }
    DPRINTF(Cache, ""%s created response: %s address %x size %d\\n"",
            __func__, pkt->cmdString(), pkt->getAddr(), pkt->getSize());
    memSidePort->schedTimingSnoopResp(pkt, clockEdge(hitLatency));
}

template<class TagStore>
void
Cache<TagStore>::handleSnoop(PacketPtr pkt, BlkType *blk,
                             bool is_timing, bool is_deferred,
                             bool pending_inval)
{
    DPRINTF(Cache, ""%s for %s address %x size %d\\n"", __func__,
            pkt->cmdString(), pkt->getAddr(), pkt->getSize());
    // deferred snoops can only happen in timing mode
    assert(!(is_deferred && !is_timing));
    // pending_inval only makes sense on deferred snoops
    assert(!(pending_inval && !is_deferred));
    assert(pkt->isRequest());

    // the packet may get modified if we or a forwarded snooper
    // responds in atomic mode, so remember a few things about the
    // original packet up front
    bool invalidate = pkt->isInvalidate();
    bool M5_VAR_USED needs_exclusive = pkt->needsExclusive();

    if (forwardSnoops) {
        // first propagate snoop upward to see if anyone above us wants to
        // handle it.  save & restore packet src since it will get
        // rewritten to be relative to cpu-side bus (if any)
        bool alreadyResponded = pkt->memInhibitAsserted();
        if (is_timing) {
            Packet snoopPkt(pkt, true);  // clear flags
            snoopPkt.setExpressSnoop();
            snoopPkt.pushSenderState(new ForwardResponseRecord(pkt->getSrc()));
            // the snoop packet does not need to wait any additional
            // time
            snoopPkt.busFirstWordDelay = snoopPkt.busLastWordDelay = 0;
            cpuSidePort->sendTimingSnoopReq(&snoopPkt);
            if (snoopPkt.memInhibitAsserted()) {
                // cache-to-cache response from some upper cache
                assert(!alreadyResponded);
                pkt->assertMemInhibit();
            } else {
                delete snoopPkt.popSenderState();
            }
            if (snoopPkt.sharedAsserted()) {
                pkt->assertShared();
            }
        } else {
            cpuSidePort->sendAtomicSnoop(pkt);
            if (!alreadyResponded && pkt->memInhibitAsserted()) {
                // cache-to-cache response from some upper cache:
                // forward response to original requester
                assert(pkt->isResponse());
            }
        }
    }

     if (!blk || !blk->isValid()) {
         DPRINTF(Cache, ""%s snoop miss for %s address %x size %d\\n"",
                 __func__, pkt->cmdString(), pkt->getAddr(), pkt->getSize());
         return;
     } else {
        DPRINTF(Cache, ""%s snoop hit for %s for address %x size %d, ""
                ""old state is %s\\n"", __func__, pkt->cmdString(),
                pkt->getAddr(), pkt->getSize(), blk->print());
     }

    // we may end up modifying both the block state and the packet (if
    // we respond in atomic mode), so just figure out what to do now
    // and then do it later
    bool respond = blk->isDirty() && pkt->needsResponse();
    bool have_exclusive = blk->isWritable();

    if (pkt->isRead() && !invalidate) {
        assert(!needs_exclusive);
        pkt->assertShared();
        int bits_to_clear = BlkWritable;
        const bool haveOwnershipState = true; // for now
        if (!haveOwnershipState) {
            // if we don't support pure ownership (dirty && !writable),
            // have to clear dirty bit here, assume memory snarfs data
            // on cache-to-cache xfer
            bits_to_clear |= BlkDirty;
        }
        blk->status &= ~bits_to_clear;
    }

    if (respond) {
        assert(!pkt->memInhibitAsserted());
        pkt->assertMemInhibit();
        if (have_exclusive) {
            pkt->setSupplyExclusive();
        }
        if (is_timing) {
            doTimingSupplyResponse(pkt, blk->data, is_deferred, pending_inval);
        } else {
            pkt->makeAtomicResponse();
            pkt->setDataFromBlock(blk->data, blkSize);
        }
    } else if (is_timing && is_deferred) {
        // if it's a deferred timing snoop then we've made a copy of
        // the packet, and so if we're not using that copy to respond
        // then we need to delete it here.
        delete pkt;
    }

    // Do this last in case it deallocates block data or something
    // like that
    if (invalidate) {
        if (blk != tempBlock)
            tags->invalidate(blk);
        blk->invalidate();
    }

    DPRINTF(Cache, ""new state is %s\\n"", blk->print());
}


template<class TagStore>
void
Cache<TagStore>::recvTimingSnoopReq(PacketPtr pkt)
{
    DPRINTF(Cache, ""%s for %s address %x size %d\\n"", __func__,
            pkt->cmdString(), pkt->getAddr(), pkt->getSize());

    // Snoops shouldn't happen when bypassing caches
    assert(!system->bypassCaches());

    // check if the packet is for an address range covered by this
    // cache, partly to not waste time looking for it, but also to
    // ensure that we only forward the snoop upwards if it is within
    // our address ranges
    bool in_range = false;
    for (AddrRangeList::const_iterator r = addrRanges.begin();
         r != addrRanges.end(); ++r) {
        if (r->contains(pkt->getAddr())) {
            in_range = true;
            break;
        }
    }

    // Note that some deferred snoops don't have requests, since the
    // original access may have already completed
    if ((pkt->req && pkt->req->isUncacheable()) ||
        pkt->cmd == MemCmd::Writeback || !in_range) {
        //Can't get a hit on an uncacheable address
        //Revisit this for multi level coherence
        return;
    }

    bool is_secure = pkt->isSecure();
    BlkType *blk = tags->findBlock(pkt->getAddr(), is_secure);

    Addr blk_addr = blockAlign(pkt->getAddr());
    MSHR *mshr = mshrQueue.findMatch(blk_addr, is_secure);

    // Let the MSHR itself track the snoop and decide whether we want
    // to go ahead and do the regular cache snoop
    if (mshr && mshr->handleSnoop(pkt, order++)) {
        DPRINTF(Cache, ""Deferring snoop on in-service MSHR to blk %x (%s).""
                ""mshrs: %s\\n"", blk_addr, is_secure ? ""s"" : ""ns"",
                mshr->print());

        if (mshr->getNumTargets() > numTarget)
            warn(""allocating bonus target for snoop""); //handle later
        return;
    }

    //We also need to check the writeback buffers and handle those
    std::vector<MSHR *> writebacks;
    if (writeBuffer.findMatches(blk_addr, is_secure, writebacks)) {
        DPRINTF(Cache, ""Snoop hit in writeback to addr: %x (%s)\\n"",
                pkt->getAddr(), is_secure ? ""s"" : ""ns"");

        //Look through writebacks for any non-uncachable writes, use that
        if (writebacks.size()) {
            // We should only ever find a single match
            assert(writebacks.size() == 1);
            mshr = writebacks[0];
            assert(!mshr->isUncacheable());
            assert(mshr->getNumTargets() == 1);
            PacketPtr wb_pkt = mshr->getTarget()->pkt;
            assert(wb_pkt->cmd == MemCmd::Writeback);

            assert(!pkt->memInhibitAsserted());
            pkt->assertMemInhibit();
            if (!pkt->needsExclusive()) {
                pkt->assertShared();
                // the writeback is no longer the exclusive copy in the system
                wb_pkt->clearSupplyExclusive();
            } else {
                // if we're not asserting the shared line, we need to
                // invalidate our copy.  we'll do that below as long as
                // the packet's invalidate flag is set...
                assert(pkt->isInvalidate());
            }
            doTimingSupplyResponse(pkt, wb_pkt->getPtr<uint8_t>(),
                                   false, false);

            if (pkt->isInvalidate()) {
                // Invalidation trumps our writeback... discard here
                markInService(mshr);
                delete wb_pkt;
            }
        } // writebacks.size()
    }

    // If this was a shared writeback, there may still be
    // other shared copies above that require invalidation.
    // We could be more selective and return here if the
    // request is non-exclusive or if the writeback is
    // exclusive.
    handleSnoop(pkt, blk, true, false, false);
}

template<class TagStore>
bool
Cache<TagStore>::CpuSidePort::recvTimingSnoopResp(PacketPtr pkt)
{
    // Express snoop responses from master to slave, e.g., from L1 to L2
    cache->recvTimingSnoopResp(pkt);
    return true;
}

template<class TagStore>
Tick
Cache<TagStore>::recvAtomicSnoop(PacketPtr pkt)
{
    // Snoops shouldn't happen when bypassing caches
    assert(!system->bypassCaches());

    if (pkt->req->isUncacheable() || pkt->cmd == MemCmd::Writeback) {
        // Can't get a hit on an uncacheable address
        // Revisit this for multi level coherence
        return 0;
    }

    BlkType *blk = tags->findBlock(pkt->getAddr(), pkt->isSecure());
    handleSnoop(pkt, blk, false, false, false);
    return hitLatency * clockPeriod();
}


template<class TagStore>
MSHR *
Cache<TagStore>::getNextMSHR()
{
    // Check both MSHR queue and write buffer for potential requests
    MSHR *miss_mshr  = mshrQueue.getNextMSHR();
    MSHR *write_mshr = writeBuffer.getNextMSHR();

    // Now figure out which one to send... some cases are easy
    if (miss_mshr && !write_mshr) {
        return miss_mshr;
    }
    if (write_mshr && !miss_mshr) {
        return write_mshr;
    }

    if (miss_mshr && write_mshr) {
        // We have one of each... normally we favor the miss request
        // unless the write buffer is full
        if (writeBuffer.isFull() && writeBuffer.inServiceEntries == 0) {
            // Write buffer is full, so we'd like to issue a write;
            // need to search MSHR queue for conflicting earlier miss.
            MSHR *conflict_mshr =
                mshrQueue.findPending(write_mshr->addr, write_mshr->size,
                                      write_mshr->isSecure);

            if (conflict_mshr && conflict_mshr->order < write_mshr->order) {
                // Service misses in order until conflict is cleared.
                return conflict_mshr;
            }

            // No conflicts; issue write
            return write_mshr;
        }

        // Write buffer isn't full, but need to check it for
        // conflicting earlier writeback
        MSHR *conflict_mshr =
            writeBuffer.findPending(miss_mshr->addr, miss_mshr->size,
                                    miss_mshr->isSecure);
        if (conflict_mshr) {
            // not sure why we don't check order here... it was in the
            // original code but commented out.

            // The only way this happens is if we are
            // doing a write and we didn't have permissions
            // then subsequently saw a writeback (owned got evicted)
            // We need to make sure to perform the writeback first
            // To preserve the dirty data, then we can issue the write

            // should we return write_mshr here instead?  I.e. do we
            // have to flush writes in order?  I don't think so... not
            // for Alpha anyway.  Maybe for x86?
            return conflict_mshr;
        }

        // No conflicts; issue read
        return miss_mshr;
    }

    // fall through... no pending requests.  Try a prefetch.
    assert(!miss_mshr && !write_mshr);
    if (prefetcher && !mshrQueue.isFull()) {
        // If we have a miss queue slot, we can try a prefetch
        PacketPtr pkt = prefetcher->getPacket();
        if (pkt) {
            Addr pf_addr = blockAlign(pkt->getAddr());
            if (!tags->findBlock(pf_addr, pkt->isSecure()) &&
                !mshrQueue.findMatch(pf_addr, pkt->isSecure()) &&
                !writeBuffer.findMatch(pf_addr, pkt->isSecure())) {
                // Update statistic on number of prefetches issued
                // (hwpf_mshr_misses)
                assert(pkt->req->masterId() < system->maxMasters());
                mshr_misses[pkt->cmdToIndex()][pkt->req->masterId()]++;
                // Don't request bus, since we already have it
                return allocateMissBuffer(pkt, curTick(), false);
            } else {
                // free the request and packet
                delete pkt->req;
                delete pkt;
            }
        }
    }

    return NULL;
}


template<class TagStore>
PacketPtr
Cache<TagStore>::getTimingPacket()
{
    MSHR *mshr = getNextMSHR();

    if (mshr == NULL) {
        return NULL;
    }

    // use request from 1st target
    PacketPtr tgt_pkt = mshr->getTarget()->pkt;
    PacketPtr pkt = NULL;

    DPRINTF(CachePort, ""%s %s for address %x size %d\\n"", __func__,
            tgt_pkt->cmdString(), tgt_pkt->getAddr(), tgt_pkt->getSize());

    if (tgt_pkt->cmd == MemCmd::SCUpgradeFailReq ||
        tgt_pkt->cmd == MemCmd::StoreCondFailReq) {
        // SCUpgradeReq or StoreCondReq saw invalidation while queued
        // in MSHR, so now that we are getting around to processing
        // it, just treat it as if we got a failure response
        pkt = new Packet(tgt_pkt);
        pkt->cmd = MemCmd::UpgradeFailResp;
        pkt->senderState = mshr;
        pkt->busFirstWordDelay = pkt->busLastWordDelay = 0;
        recvTimingResp(pkt);
        return NULL;
    } else if (mshr->isForwardNoResponse()) {
        // no response expected, just forward packet as it is
        assert(tags->findBlock(mshr->addr, mshr->isSecure) == NULL);
        pkt = tgt_pkt;
    } else {
        BlkType *blk = tags->findBlock(mshr->addr, mshr->isSecure);

        if (tgt_pkt->cmd == MemCmd::HardPFReq) {
            // It might be possible for a writeback to arrive between
            // the time the prefetch is placed in the MSHRs and when
            // it's selected to send... if so, this assert will catch
            // that, and then we'll have to figure out what to do.
            assert(blk == NULL);

            // We need to check the caches above us to verify that
            // they don't have a copy of this block in the dirty state
            // at the moment. Without this check we could get a stale
            // copy from memory that might get used in place of the
            // dirty one.
            Packet snoop_pkt(tgt_pkt, true);
            snoop_pkt.setExpressSnoop();
            snoop_pkt.senderState = mshr;
            cpuSidePort->sendTimingSnoopReq(&snoop_pkt);

            if (snoop_pkt.memInhibitAsserted()) {
                markInService(mshr, &snoop_pkt);
                DPRINTF(Cache, ""Upward snoop of prefetch for addr""
                        "" %#x (%s) hit\\n"",
                        tgt_pkt->getAddr(), tgt_pkt->isSecure()? ""s"": ""ns"");
                return NULL;
            }
        }

        pkt = getBusPacket(tgt_pkt, blk, mshr->needsExclusive());

        mshr->isForward = (pkt == NULL);

        if (mshr->isForward) {
            // not a cache block request, but a response is expected
            // make copy of current packet to forward, keep current
            // copy for response handling
            pkt = new Packet(tgt_pkt);
            pkt->allocate();
            if (pkt->isWrite()) {
                pkt->setData(tgt_pkt->getPtr<uint8_t>());
            }
        }
    }

    assert(pkt != NULL);
    pkt->senderState = mshr;
    return pkt;
}


template<class TagStore>
Tick
Cache<TagStore>::nextMSHRReadyTime() const
{
    Tick nextReady = std::min(mshrQueue.nextMSHRReadyTime(),
                              writeBuffer.nextMSHRReadyTime());

    if (prefetcher) {
        nextReady = std::min(nextReady,
                             prefetcher->nextPrefetchReadyTime());
    }

    return nextReady;
}

template<class TagStore>
void
Cache<TagStore>::serialize(std::ostream &os)
{
    bool dirty(isDirty());

    if (dirty) {
        warn(""*** The cache still contains dirty data. ***\\n"");
        warn(""    Make sure to drain the system using the correct flags.\\n"");
        warn(""    This checkpoint will not restore correctly and dirty data in ""
             ""the cache will be lost!\\n"");
    }

    // Since we don't checkpoint the data in the cache, any dirty data
    // will be lost when restoring from a checkpoint of a system that
    // wasn't drained properly. Flag the checkpoint as invalid if the
    // cache contains dirty data.
    bool bad_checkpoint(dirty);
    SERIALIZE_SCALAR(bad_checkpoint);
}

template<class TagStore>
void
Cache<TagStore>::unserialize(Checkpoint *cp, const std::string &section)
{
    bool bad_checkpoint;
    UNSERIALIZE_SCALAR(bad_checkpoint);
    if (bad_checkpoint) {
        fatal(""Restoring from checkpoints with dirty caches is not supported ""
              ""in the classic memory system. Please remove any caches or ""
              "" drain them properly before taking checkpoints.\\n"");
    }
}

///////////////
//
// CpuSidePort
//
///////////////

template<class TagStore>
AddrRangeList
Cache<TagStore>::CpuSidePort::getAddrRanges() const
{
    return cache->getAddrRanges();
}

template<class TagStore>
bool
Cache<TagStore>::CpuSidePort::recvTimingReq(PacketPtr pkt)
{
    // always let inhibited requests through even if blocked
    if (!pkt->memInhibitAsserted() && blocked) {
        assert(!cache->system->bypassCaches());
        DPRINTF(Cache,""Scheduling a retry while blocked\\n"");
        mustSendRetry = true;
        return false;
    }

    cache->recvTimingReq(pkt);
    return true;
}

template<class TagStore>
Tick
Cache<TagStore>::CpuSidePort::recvAtomic(PacketPtr pkt)
{
    return cache->recvAtomic(pkt);
}

template<class TagStore>
void
Cache<TagStore>::CpuSidePort::recvFunctional(PacketPtr pkt)
{
    // functional request
    cache->functionalAccess(pkt, true);
}

template<class TagStore>
Cache<TagStore>::
CpuSidePort::CpuSidePort(const std::string &_name, Cache<TagStore> *_cache,
                         const std::string &_label)
    : BaseCache::CacheSlavePort(_name, _cache, _label), cache(_cache)
{
}

///////////////
//
// MemSidePort
//
///////////////

template<class TagStore>
bool
Cache<TagStore>::MemSidePort::recvTimingResp(PacketPtr pkt)
{
    cache->recvTimingResp(pkt);
    return true;
}

// Express snooping requests to memside port
template<class TagStore>
void
Cache<TagStore>::MemSidePort::recvTimingSnoopReq(PacketPtr pkt)
{
    // handle snooping requests
    cache->recvTimingSnoopReq(pkt);
}

template<class TagStore>
Tick
Cache<TagStore>::MemSidePort::recvAtomicSnoop(PacketPtr pkt)
{
    return cache->recvAtomicSnoop(pkt);
}

template<class TagStore>
void
Cache<TagStore>::MemSidePort::recvFunctionalSnoop(PacketPtr pkt)
{
    // functional snoop (note that in contrast to atomic we don't have
    // a specific functionalSnoop method, as they have the same
    // behaviour regardless)
    cache->functionalAccess(pkt, false);
}

template<class TagStore>
void
Cache<TagStore>::MemSidePacketQueue::sendDeferredPacket()
{
    // if we have a response packet waiting we have to start with that
    if (deferredPacketReady()) {
        // use the normal approach from the timing port
        trySendTiming();
    } else {
        // check for request packets (requests & writebacks)
        PacketPtr pkt = cache.getTimingPacket();
        if (pkt == NULL) {
            // can happen if e.g. we attempt a writeback and fail, but
            // before the retry, the writeback is eliminated because
            // we snoop another cache's ReadEx.
            waitingOnRetry = false;
        } else {
            MSHR *mshr = dynamic_cast<MSHR*>(pkt->senderState);

            waitingOnRetry = !masterPort.sendTimingReq(pkt);

            if (waitingOnRetry) {
                DPRINTF(CachePort, ""now waiting on a retry\\n"");
                if (!mshr->isForwardNoResponse()) {
                    // we are awaiting a retry, but we
                    // delete the packet and will be creating a new packet
                    // when we get the opportunity
                    delete pkt;
                }
                // note that we have now masked any requestBus and
                // schedSendEvent (we will wait for a retry before
                // doing anything), and this is so even if we do not
                // care about this packet and might override it before
                // it gets retried
            } else {
                cache.markInService(mshr, pkt);
            }
        }
    }

    // if we succeeded and are not waiting for a retry, schedule the
    // next send, not only looking at the response transmit list, but
    // also considering when the next MSHR is ready
    if (!waitingOnRetry) {
        scheduleSend(cache.nextMSHRReadyTime());
    }
}

template<class TagStore>
Cache<TagStore>::
MemSidePort::MemSidePort(const std::string &_name, Cache<TagStore> *_cache,
                         const std::string &_label)
    : BaseCache::CacheMasterPort(_name, _cache, _queue),
      _queue(*_cache, *this, _label), cache(_cache)
{
}

#endif//__MEM_CACHE_CACHE_IMPL_HH__
",16284,True,3490.8618650652998,median
"= NetSuite Connector
:keywords: anypoint studio, connector, endpoint, netsuite
:page-aliases: 3.7@mule-runtime::netsuite-connector.adoc

*_Select_*

MuleSoft's Anypoint™ Connector for NetSuite synchronizes data and automates business processes between NetSuite and third party applications, either on-premises or in the cloud.

*Release Notes*: xref:release-notes::connector/netsuite-connector-release-notes.adoc[NetSuite Connector Release Notes]

== Introduction

NetSuite is the world’s leading provider of cloud-based business management software. NetSuite helps companies manage core business processes with a single, fully integrated system covering ERP/financials, CRM, e-commerce, inventory, and more.

The NetSuite connector makes use of the SuiteTalk WSDL to provide SOAP-based integration and generate NetSuite business objects, make use of different authentication levels, and support error handling.

== Prerequisites

This document assumes that you are familiar with Mule, xref:3.7@mule-runtime::anypoint-connectors.adoc[Anypoint™ Connectors], and the xref:5@studio::index.adoc[Anypoint Studio interface]. To increase your familiarity with Studio, consider completing one or more  xref:5@studio::basic-studio-tutorial.adoc[Anypoint Studio Tutorials]. Further, this page assumes that you have a basic understanding of xref:3.7@mule-runtime::mule-concepts.adoc[Mule flows] and xref:3.7@mule-runtime::global-elements.adoc[Mule Global Elements].

To use this connector, you need a NetSuite account with Web Services Features enabled, and Anypoint Studio installed on your development machine.

== Compatibility

The NetSuite connector v7.1.0 is compatible with:

[%header,cols=""2*""]
|===
a|
Application/Service

 a|
Version

|*Mule Runtime* |3.5 and later
|*API* |SuiteTalks 2015_2
|===

== To Install this Connector

. In Anypoint Studio, click the Exchange icon in the Studio taskbar.
. Click Login in Anypoint Exchange.
. Search for the connector and click Install.
. Follow the prompts to install the connector.

When Studio has an update, a message displays in the lower right corner, which you can click to install the update.

However, to use the NetSuite connector in a production environment, you must have either:

* An *Enterprise Mule license*.
* A *CloudHub* Starter, Professional, or Enterprise account.

Contact the https://www.mulesoft.com/lp/contact[MuleSoft Sales Team] to obtain either of these. (Read more about xref:3.7@mule-runtime::installing-an-enterprise-license.adoc[Installing an Enterprise License].)

== Creating a New Project

To use the NetSuite connector in a Mule application project:

. In Studio, click File > MuleNew > Mule Project.
. Enter a name for your new project and leave the remaining options with their default values.
+
image::netsuite-new-mule-project.png[netsuite_new_mule_project]
+
. If you plan to use Git, select *Create a .gitignore file* for the project with default ignores for Studio Projects, and click *Next*.
. Click *Finish* to create the project.

== Configuring the NetSuite Connector Global Element

To use the NetSuite connector in your Mule application, you must configure a global NetSuite element that can be used by all the NetSuite connectors in the application (read more about xref:3.7@mule-runtime::global-elements.adoc[global elements]).

Not much has changed on this front, and as before (starting from v6.0.0) you are presented with a number of different Global Elements, each representing a different way of authenticating to NetSuite, but this release includes a new method of authentication: *NetSuite: Request Level Token Based Authentication*:

[%header,cols=""2*""]
|===
|Configuration |Description
|*Login Authentication* |Makes use of the SuiteTalks login API call on the first request sent by the connector to establish a session with NetSuite.
|*Request Level Authentication* |Using this strategy, you can send user credentials in the SOAP header of each request instead of authenticating to NetSuite by invoking login.
|*Single Sign-On Login Authentication* |This is a token based authentication system that avoids the use of environment username and password. Here you supply a privateKey together with other information. The connector is then responsible for generating an authentication token and establishing a session with NetSuite via the `ssoLogin` API call on the first request.
|*Request Level Token Based Authentication* |Similar to Single Sign-On Login Authentication, this is a token based authentication system. However, instead of using a privateKey generated via openssl, this uses a consumer and token key/secret pairs which are established within the NetSuite environment.
|===

Follow these steps to configure NetSuite connector global element in a Mule application:

[.ex]
=====
[discrete.view]
=== Studio Visual Editor

. Click the *Global Elements* tab at the base of the canvas.
. On the Global Mule Configuration Elements screen, click *Create*.
. In the ""Choose Global Type"" wizard, expand  *Connector Configuration,* and then select  *NetSuite: Login Authentication, NetSuite: Request Level Authentication,* *NetSuite: SSO Login Authentication,* or *NetSuite: Request Level Token Based Authentication* depending on your NetSuite authentication.
+
image::netsuite-global-configuration.png[netsuite_global_configuration]
+
. Click *Ok*.
. Enter global element properties.
.. For *NetSuite: Login Authentication* and *NetSuite: Request Level Authentication*:
+
[%header,cols=""2*""]
|===
|Parameter |Description
|*Name* |Enter a name for the configuration with which to reference it later.
|*Email* |Enter the login email of the NetSuite UI.
|*Password* |Enter the corresponding password to log into NetSuite UI.
|*Account* |Enter the account ID of the SuiteTalk NetSuite web services. This is usually found within NetSuite sandbox UI under *Setup* > *Integration* > *Web Service Preferences.*
|*Role Id* |Enter the role ID for the user in SuiteTalk, which determines the Processor privileges.
|*Application Id* |Enter the application ID corresponding to the Integration record to be used (*New in NetSuite Connector version 7.0.0*).
|*Connection Timeout* |Enter the amount of time, in milliseconds, that the client must attempt to establish a connection before timing out.
|*Receive Timeout* |Enter the amount of time, in milliseconds, that the client must wait for a response before timing out.
|*Enable DataSense* |If you select this option, DataSense extracts metadata for NetSuite standard objects to automatically determine the data type and format that your application must deliver to, or can expect from, NetSuite. By enabling this functionality, Mule does the heavy lifting of discovering the type of data you must send to, or be prepared to receive from NetSuite. For more information, see xref:5@studio::datasense.adoc[DataSense].
|*Endpoint* a|
Enter the URL of the service endpoint.

[NOTE]
Make sure that the endpoint uses the version of NetSuite that the connector supports.

|*Separator* |Enter the separator used to support the keys that are required to provide a better support for custom fields.
|===
+
.. For *NetSuite: SSO Login Authentication:* +
To use the SSO Login Authentication, enable this feature in your sandbox environment by NetSuite’s Support. NetSuite provides an SSO Kit and information on how to proceed with setting up private and public keys for use in generating authentication tokens. They also provide you with a Partner ID. After this setup is established, a mapping has to be created between the standard NetSuite credentials, the partner ID, company ID, and user ID. A developer or administrator should perform this mapping. It is not handled by the connector and it is only done once for each user ID that is allowed to authenticate using SSO within your company.
+
For this mapping, start by generating a token using the SSO Kit provided by NetSuite. To establish the mapping, invoke the SuiteTalks Web Service API call `mapSso` using an external Java application or any other method of your choice. A sample SOAP request of the `mapSso` API call looks as follows:
+
[source,xml,linenums]
----
<soapenv:Envelope xmlns:soapenv=""http://schemas.xmlsoap.org/soap/envelope/"" xmlns:urn=""urn:messages_2015_1.platform.webservices.netsuite.com"" xmlns:urn1=""urn:core_2015_1.platform.webservices.netsuite.com"">
   <soapenv:Header></soapenv:Header>
   <soapenv:Body>
      <urn:mapSso>
         <urn:ssoCredentials>
            <urn1:email>Your NetSuite email</urn1:email>
            <urn1:password>Your NetSuite password</urn1:password>
            <urn1:account>Your NetSuite account Id</urn1:account>
            <urn1:role internalId=""The account role Id""></urn1:role>
            <urn1:authenticationToken>The token string generated using the SSO kit</urn1:authenticationToken>
            <urn1:partnerId>Your NetSuite partner Id</urn1:partnerId>
         </urn:ssoCredentials>
      </urn:mapSso>
   </soapenv:Body>
</soapenv:Envelope>
----
+
[%header,cols=""2*""]
|===
|Parameter |Description
|*Name* |Enter a name for the configuration so it can be referenced later.
|*Partner Id* |Enter the partner ID used in the mapping process.
|*Partner Account* |Enter the account ID of the SuiteTalk NetSuite web services.
|*Company ID* |Enter the company ID used in the mapping process for the connector to generate a token.
|*User ID* |Enter the user ID used in the mapping process for the connector to generate a token.
|*Key File* |Enter the *privateKey* file name to pick up from the project. This file should be the *.der* file generated as per NetSuite’s specifications. This is used to encrypt the company ID and user ID into a token for *ssoLogin*.
|*Application Id* |Enter the application ID corresponding to the Integration record to be used (*New in NetSuite Connector version 7.0.0*).
|*Connection Timeout* |Enter the amount of time, in milliseconds, that the client must attempt to establish a connection before timing out.
|*Receive Timeout* |Enter the amount of time, in milliseconds, that the client must wait for a response before timing out.
|*Enable DataSense* |If you select this option, DataSense extracts metadata for NetSuite standard objects to automatically determine the data type and format that your application must deliver to, or can expect from, NetSuite. By enabling this functionality, Mule does the heavy lifting of discovering the type of data you must send to, or be prepared to receive from NetSuite. For more information, see xref:5@studio::datasense.adoc[DataSense].
|*Endpoint* |Enter the URL of the service endpoint.
|*Separator* |Enter the separator used to support the keys that are required to provide a better support for custom fields.
|*Required Libraries* |Click Add File to add the SSO jar that you acquire via NetSuite support.
|===
+
.. For *NetSuite: Request Level Token Based Authentication:* +
To use this authentication mechanism you will need to set up an Integration Record within NetSuite and enable Token Based Authentication. This will automatically generate a consumer key and secret for you.
+
Furthermore you must set up an access token from within your NetSuite environment that combines the Integration Record with a User. This could be done assuming that your NetSuite account has the required permissions enabled in order to generate such tokens and login using them.
+
Please refer to NetSuite's Help Center or SuiteAnswers for detailed information on how to navigate NetSuite and set this up.
+
[%header,cols=""2*""]
|===
|Parameter |Description
|*Consumer Key* |Enter the consumer key value for the token based authentication enabled integration record being used.
|*Consumer Secret* |Enter the consumer secret value for the token based authentication enabled integration record being used.
|*Token Id* |Enter the token id representing the unique combination of a user and integration generated within the NetSuite environment.
|*Token Secret* |Enter the respective token secret for the user/integration pair.
|*Account* |Enter the account ID of the SuiteTalk NetSuite web services. This is usually found within NetSuite sandbox UI under *Setup* > *Integration* > *Web Service Preferences.*
|*Connection Timeout* |Enter the amount of time, in milliseconds, that the client must attempt to establish a connection before timing out.
|*Receive Timeout* |Enter the amount of time, in milliseconds, that the client must wait for a response before timing out.
|*Enable DataSense* |If you select this option, DataSense extracts metadata for NetSuite standard objects to automatically determine the data type and format that your application must deliver to, or can expect from, NetSuite. By enabling this functionality, Mule does the heavy lifting of discovering the type of data you must send to, or be prepared to receive from NetSuite. For more information, see xref:5@studio::datasense.adoc[DataSense].
|*Endpoint* a|
Enter the URL of the service endpoint.

[NOTE]
Make sure that the endpoint uses the version of NetSuite that the connector supports.

|*Separator* |Enter the separator used to support the keys that are required to provide a better support for custom fields.
|===
+
. Access the *Pooling Profile* tab to configure any settings relevant to managing multiple connections via a connection pool.
. Access the *Reconnection* tab to configure any settings relevant to reconnection strategies that Mule should execute if it loses its connection to NetSuite.
. Click *OK* to save the global connector configurations.
. Return to the Message Flow tab in Studio.

[discrete.view]
=== XML Editor

. Ensure that you include the NetSuite namespaces in your configuration file.
+
[source,xml,linenums]
----
<mule xmlns=""http://www.mulesoft.org/schema/mule/core""
      xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance""
      xmlns:netsuite=""http://www.mulesoft.org/schema/mule/netsuite""
      xsi:schemaLocation=""
               http://www.mulesoft.org/schema/mule/core
               http://www.mulesoft.org/schema/mule/core/current/mule.xsd
               http://www.mulesoft.org/schema/mule/netsuite
               http://www.mulesoft.org/schema/mule/netsuite/current/mule-netsuite.xsd"">

</mule>
----
+
. Create a global NetSuite configuration outside and above your flows, using one of the following global configuration codes:
+
[source,xml,linenums]
----
<netsuite:config-login-authentication name=""NetSuite"" email=""${email}"" password=""${password}"" account=""${account}"" roleId=""${roleId}"" applicationId=""${applicationId}""/>
----
+
[source,xml,linenums]
----
<netsuite:config-request-level-authentication name=""NetSuite"" email=""${email}"" password=""${password}"" account=""${account}"" roleId=""${roleId}"" applicationId=""${applicationId}""/>
----
+
[source,xml,linenums]
----
<netsuite:config-sso-login-authentication name=""NetSuite"" email=""${email}"" password=""${password}"" account=""${account}"" roleId=""${roleId}"" applicationId=""${applicationId}""/>
----
+
[source,xml,linenums]
----
<netsuite:config-request-level-token-based-authentication name=""NetSuite"" consumerKey=""${consumerKey}"" consumerSecret=""${consumerSecret}"" tokenId=""${tokenId}"" tokenSecret=""${tokenSecret}"" account=""${account}"" />
----
=====

== Using the Connector

NetSuite connector is an operation-based connector, which means that when you add the connector to your flow, you need to configure a specific web service operation for the connector to perform. NetSuite connector v7.1.0 supports 50 operations.

=== Adding to a Flow

. Create a new Mule project in Anypoint Studio.
. Add a suitable Mule inbound endpoint, such as the HTTP listener or File endpoint, to begin the flow.
. Drag the NetSuite connector onto the canvas, then select it to open the properties editor.
. Configure the connector's parameters as follows:
+
[%header,cols=""2*""]
|===
|Field |Description
|*Display Name* |Enter a unique label for the connector in your application.
|*Config Reference* |Connect to a global element linked to this connector. Global elements encapsulate reusable data about the connection to the target resource or service. Select the global NetSuite connector element you create.
|*Operation* |Select the action this component must perform.
|===

== Custom Field DataSense

In NetSuite one can add different types of custom fields and have these customizations apply to different record types. With DataSense enabled, the NetSuite connector retrieves and shows these fields. Note however that we do not fully support all the customization types that NetSuite users are able to define.
The following lists outline what fields we do and do not handle, and where they currently appear in relation to the record type's attributes. For the most part you can see that customizations are usually present within a list field called _customFieldList_, but in some cases these might reside elsewhere.

=== Entity Fields

[%header,cols=""2*""]
|===
|Record Type |Custom Field Placement
|*CONTACT* |Contact > customFieldList > customField
|*CUSTOMER* |Customer > customFieldList > customField
|*EMPLOYEE* |Employee > customFieldList > customField
|*ENTITY_GROUP* |EntityGroup > customFieldList > customField
|*PARTNER* |Partner > customFieldList > customField
|*PROJECT_TASK* |ProjectTask > customFieldList > customField
|*VENDOR* |Vendor > customFieldList > customField
|===

=== Item Fields

[%header,cols=""2*""]
|===
|Record Type |Custom Field Placement
|*ASSEMBLY_ITEM* |AssemblyItem > customFieldList > customField
|*ENTITY_GROUP* |EntityGroup > customFieldList > customField
|*INVENTORY_ITEM* |InventoryItem > customFieldList > customField
|*KIT_ITEM* |KitItem > customFieldList > customField
|*NON_INVENTORY_PURCHASE_ITEM* |NonInventoryPurchaseItem > customFieldList > customField
|*NON_INVENTORY_RESALE_ITEM* |NonInventoryResaleItem > customFieldList > customField
|*NON_INVENTORY_SALE_ITEM* |NonInventorySaleItem > customFieldList > customField
|*OTHER_CHARGE_PURCHASE_ITEM* |OtherChargePurchaseItem > customFieldList > customField
|*OTHER_CHARGE_RESALE_ITEM* |OtherChargeResaleItem > customFieldList > customField
|*OTHER_CHARGE_SALE_ITEM* |OtherChargeSaleItem > customFieldList > customField
|*SERVICE_PURCHASE_ITEM* |ServicePurchaseItem > customFieldList > customField
|*SERVICE_RESALE_ITEM* |ServiceResaleItem > customFieldList > customField
|*SERVICE_SALE_ITEM* |ServiceSaleItem > customFieldList > customField
|===

=== CRM Fields

[%header,cols=""2*""]
|===
|Record Type |Custom Field Placement
|*CALENDAR_EVENT* |CalendarEvent > customFieldList > customField
|*CAMPAIGN* |Campaign > customFieldList > customField
|*ISSUE* |Issue > customFieldList > customField
|*MANUFACTURING_OPERATION_TASK* |ManufacturingOperationTask > customFieldList > customField
|*PHONE_CALL* |PhoneCall > customFieldList > customField
|*PROJECT_TASK* |ProjectTask > customFieldList > customField
|*SOLUTION* |Solution > customFieldList > customField
|*SUPPORT_CASE* |SupportCase > customFieldList > customField
|*TASK* |Task > customFieldList > customField
|===

=== Transaction Body Fields

[%header,cols=""2*""]
|===
|Record Type |Custom Field Placement
|*ASSEMBLY_BUILD* |AssemblyBuild > customFieldList > customField
|*CASH_SALE* |CashSale > customFieldList > customField
|*CUSTOMER_PAYMENT* |CustomerPayment > customFieldList > customField
|*DEPOSIT* |Deposit > customFieldList > customField
|*ESTIMATE* |Estimate > customFieldList > customField
|*EXPENSE_REPORT* |ExpenseReport > customFieldList > customField
|*INVENTORY_ADJUSTMENT* |InventoryAdjustment > customFieldList > customField
|*INVOICE* |Invoice > customFieldList > customField
|*ITEM_FULFILLMENT* |ItemFulfillment > customFieldList > customField
|*ITEM_RECEIPT* |ItemReceipt > customFieldList > customField
|*JOURNAL_ENTRY* |JournalEntry > customFieldList > customField
|*OPPORTUNITY* |Opportunity > customFieldList > customField
|*PURCHASE_ORDER* |PurchaseOrder > customFieldList > customField
|*PURCHASE_REQUISITION* |PurchaseRequisition > customFieldList > customField
|*SALES_ORDER* |SalesOrder > customFieldList > customField
|*TRANSFER_ORDER* |TransferOrder > customFieldList > customField
|*VENDOR_BILL* |VendorBill > customFieldList > customField
|*VENDOR_CREDIT* |VendorCredit > customFieldList > customField
|*VENDOR_PAYMENT* |VendorPayment > customFieldList > customField
|*VENDOR_RETURN_AUTHORIZATION* |VendorReturnAuthorization > customFieldList > customField
|*WORK_ORDER* |WorkOrder > customFieldList > customField
|===

=== Transaction Column Fields

[%header,cols=""2*""]
|===
|Record Type |Custom Field Placement
|*CASH_SALE* |CashSale > itemList > item > customFieldList > customField
|*ESTIMATE* |Estimate > itemList > item > customFieldList > customField
|*EXPENSE_REPORT* |ExpenseReport > expenseList > expense > customFieldList > customField
|*INVOICE* |Invoice > itemList > item > customFieldList > customField
|*ITEM_FULFILLMENT* |ItemFulfillment > itemList > item > customFieldList > customField
|*ITEM_RECEIPT* |ItemReceipt > itemList > item > customFieldList > customField
|*JOURNAL_ENTRY* |JournalEntry > lineList > line > customFieldList > customField
|*OPPORTUNITY* |Opportunity > itemList > item > customFieldList > customField
|*PURCHASE_ORDER* |PurchaseOrder > itemList > item > customFieldList > customField
|*PURCHASE_REQUISITION* |PurchaseRequisition > itemList > item > customFieldList > customField
|*SALES_ORDER* |SalesOrder > itemList > item > customFieldList > customField
|*TIME_BILL* |TimeBill > customFieldList > customField
|*TRANSFER_ORDER* |TransferOrder > itemList > item > customFieldList > customField
|*VENDOR_BILL* |VendorBill > itemList > item > customFieldList > customField
|*VENDOR_CREDIT* |VendorCredit > itemList > item > customFieldList > customField
|*VENDOR_PAYMENT* |VendorPayment > itemList > item > customFieldList > customField
|*VENDOR_RETURN_AUTHORIZATION* |VendorReturnAuthorization > itemList > item > customFieldList > customField
|*WORK_ORDER* |WorkOrder > itemList > item > customFieldList > customField
|===

=== Transaction Item Options

Currently DataSense cannot detect NetSuite's Transaction Item Options.

=== Item Number Fields

Currently DataSense cannot detect NetSuite's Item Number Fields.

=== Other Custom Fields

[%header,cols=""2*""]
|===
|Record Type |Custom Field Placement
|*ACCOUNT* |Account > customFieldList > customField
|*BIN* |Bin > customFieldList > customField
|*CLASSIFICATION* |Classification > customFieldList > customField
|*EXPENSE_CATEGORY* |ExpenseCategory > customFieldList > customField
|*ITEM_DEMAND_PLAN* |ItemDemandPlan > customFieldList > customField
|*ITEM_SUPPLY_PLAN* |ItemSupplyPlan > customFieldList > customField
|*LOCATION* |Location > customFieldList > customField
|*MANUFACTURING_COST_TEMPLATE* |ManufacturingCostTemplate > customFieldList > customField
|*MANUFACTURING_ROUTING* |ManufacturingRouting > customFieldList > customField
|*NOTE* |Note > customFieldList > customField
|*PROMOTION_CODE* |PromotionCode > customFieldList > customField
|*SUBSIDIARY* |Subsidiary > customFieldList > customField
|===

== Example Use Case

Add a new Employee record in NetSuite using a Mule application; use Login Authentication.

image::netsuitedemoflow.png[NetSuiteDemoFlow]

[.ex]
=====
[discrete.view]
=== Studio Visual Editor

. Drag an *HTTP* connector into a new flow, and configure it as follows:
+
image::netsuite-http.jpg[netsuite_http]
+
[%header,cols=""2*""]
|===
|*Field* |Value
|*Display Name* |HTTP (or any other name you prefer)
|*config-ref* |Configure a global element with the desired host and port, we use 0.0.0.0 and 8081 respectively
|*path* |/addEmployee
|===
+
. Drag the *NetSuite* connector onto the canvas, then select it to open the properties editor console.
. Click the *+* sign next to the *Connector Configuration* field to add a new NetSuite global element.
+
image::netsuite-demonetsuite1.jpg[netsuite_demonetsuite1]
+
. Configure the global element as follows:
+
[%header,cols=""2*""]
|===
|Field |Value
|*Name* |NetSuite (or any other name you prefer)
|*Email* |<Your NetSuite Email>
|*Password* |<Your NetSuite password>
|*Account* |<Your NetSuite account>
|*Role Id* |Enter the ID of the role you use to login in SuiteTalk, which determines the Processor privileges.
|*Application Id* |Enter the application ID corresponding to the Integration record to be used (*New in NetSuite Connector version 7.0.0*).
|===
+
. In the properties editor of the NetSuite connector, configure the remaining parameters:
+
image::netsuite-addrecord.jpg[netsuite_addrecord]
+
[%header%autowidth.spread]
|===
|Field |Value
|*Display Name* |NetSuite (or any other name you prefer)
|*Config Reference* |NetSuite (name of the global element you have created)
|*Operation* |Add record
|*Record Type* |Employee
|===
+
. Drag a *Transform Message* transformer before the NetSuite connector, then click the component to open its properties editor.
. Once metadata has been retrieved, select the respective fields to populate for the Employee.
. The DataWeave script in your Transform Message component should look similar to the following: +
[source,json,linenums]
----
%dw 1.0
%output application/java
---
{
	email: inboundProperties.""http.query.params"".email,
	externalId:  inboundProperties.""http.query.params"".externalId,
	firstName:  inboundProperties.""http.query.params"".name,
	lastName:  inboundProperties.""http.query.params"".lastname,
	subsidiary: {
		internalId: 3
	}
}
----
. Add an *Object to JSON* transformer into the flow to capture the response from the NetSuite connector and display it as a HTTP response.
. Run the project as a *Mule Application* (right-click the project name in the explorer, then select *Run As* > *Mule Application* ).
. From a browser, enter the employee's e-mail address, externalId, lastname, and name in the form of the following query parameters:  `http://localhost:8081/addEmployee? email=<employee's email address> &externalId=<employee's externalId> &lastname= <employee's last name>&name=<employee's firstname>`
. Mule conducts the query, and adds the Employee record to NetSuite.

[discrete.view]
=== XML Editor

. Add a *netsuite:config* element to your project, then configure its attributes according to the  table below.
+

[source,xml,linenums]
----
<netsuite:config-login-authentication name=""NetSuite"" email=""email@youremail.com""
    password=""netsuite_password"" account=""netsuite_account"" roleId=""netsuite_role""
    applicationId=""netsuite_applicationId"" doc:name=""Netsuite""/>
----
+
[%header%autowidth.spread]
|===
|Attribute |Value
|*name* |NetSuite
|*email* |<Your NetSuite Email>
|*password* |<Your NetSuite password>
|*account* |<Your NetSuite account>
|*roleId* |Enter the ID of the role you use to login in SuiteTalk, which determines the Processor privileges.
|*Application Id* |Enter the application ID corresponding to the Integration record to be used (*New in NetSuite Connector version 7.0.0*).
|*doc:name* |NetSuite
|===
+
. Create a Mule flow with an HTTP endpoint, configuring the endpoint as follows:
+
[source,xml,linenums]
----
<http:inbound-endpoint exchange-pattern=""request-response"" host=""localhost"" port=""8081"" path=""accountWithCustomFields"" doc:name=""HTTP""/>
----
+
[%header,cols=""2*""]
|===
|Attribute |Value
|*exchange-pattern* |request-response
|*host* |localhost
|*port* |8081
|*path* a|
`accountWithCustomFields`
|*doc:name* |HTTP
|===
+

. Add a *Transform Message* transformer to pass the message payload to NetSuite.
+
[source,xml,linenums]
----
<dw:transform-message doc:name=""Transform Message""/>
----
+
. Add a *netsuite:add-record* element to your flow as follows:
+
[source,xml,linenums]
----
<netsuite:add-record config-ref=""Netsuite"" doc:name=""Netsuite Add Record"" recordType=""EMPLOYEE""/>
----
+
. Configure the Transform Message through the Visual Editor. Switch the view to Message Flow view, then click the *Transform Message* transformer to set its properties.
. Once metadata is retrieved, select the respective fields to populate for the Employee.
. The script should look similar to the following: +
[source,json,linenums]
----
%dw 1.0
%output application/java
---
{
	email: inboundProperties.""http.query.params"".email,
	externalId:  inboundProperties.""http.query.params"".externalId,
	firstName:  inboundProperties.""http.query.params"".name,
	lastName:  inboundProperties.""http.query.params"".lastname,
	subsidiary: {
		internalId: 3
	}
}
----
. Add a *json:object-to-json-transformer* element to the flow to capture the response from the NetSuite connector and display it as an HTTP response.
+
[source,xml,linenums]
----
<json:object-to-json-transformer doc:name=""Object to JSON""/>
----
+
. Run the project as a Mule Application (right-click project name, then select *Run As > Mule Application*).
. From a browser, enter the employee's e-mail address, externalId, lastname, and name in the form of the following query parameters: `http://localhost:8081/accountWithCustomFields ?email =<employee's email address> &externalId=<employee's externalId> &lname= <employee's last name>&name=<employee's firstname>`
. Mule conducts the query, and adds the Employee record to NetSuite.
=====

== Example Use Case Code

[NOTE]
====
Note that for this example code to work, you must manually configure the following values of the *global element for your NetSuite connector* to match your instance of NetSuite:

* Email
* Password
* Account
* Role ID
* Application ID
====

[source,xml,linenums]
----
<?xml version=""1.0"" encoding=""UTF-8""?>

<mule xmlns:tracking=""http://www.mulesoft.org/schema/mule/ee/tracking"" xmlns:dw=""http://www.mulesoft.org/schema/mule/ee/dw"" xmlns:netsuite=""http://www.mulesoft.org/schema/mule/netsuite""
	xmlns:json=""http://www.mulesoft.org/schema/mule/json""
	xmlns:http=""http://www.mulesoft.org/schema/mule/http""
	xmlns=""http://www.mulesoft.org/schema/mule/core"" xmlns:doc=""http://www.mulesoft.org/schema/mule/documentation""
	xmlns:spring=""http://www.springframework.org/schema/beans""
	xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance""
	xsi:schemaLocation=""http://www.mulesoft.org/schema/mule/netsuite http://www.mulesoft.org/schema/mule/netsuite/current/mule-netsuite.xsd
http://www.mulesoft.org/schema/mule/json http://www.mulesoft.org/schema/mule/json/current/mule-json.xsd
http://www.mulesoft.org/schema/mule/http http://www.mulesoft.org/schema/mule/http/current/mule-http.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-current.xsd
http://www.mulesoft.org/schema/mule/core http://www.mulesoft.org/schema/mule/core/current/mule.xsd
http://www.mulesoft.org/schema/mule/ee/dw http://www.mulesoft.org/schema/mule/ee/dw/current/dw.xsd
http://www.mulesoft.org/schema/mule/ee/tracking http://www.mulesoft.org/schema/mule/ee/tracking/current/mule-tracking-ee.xsd"">
	<netsuite:config-login-authentication name=""NetSuite"" email=""suchi.deshpande@mulesoft.com"" password=""Mules0ft1!"" account=""TSTDRV1372796"" roleId=""3"" applicationId=""250FA966-3A66-4512-87C6-4AF27B929F49"" doc:name=""NetSuite: Login Authentication""/>
	<http:listener-config name=""HTTP_Listener_Configuration"" host=""localhost"" port=""8081"" doc:name=""HTTP Listener Configuration""/>
	<flow name=""netsuite-demoFlow"" >
        <http:listener config-ref=""HTTP_Listener_Configuration"" path=""/addEmployee"" doc:name=""HTTP""/>
		<dw:transform-message doc:name=""Transform Message"">
			<dw:input-payload />
			<dw:set-payload><![CDATA[%dw 1.0
%output application/java
---
{
	email: inboundProperties.""http.query.params"".email,
	externalId:  inboundProperties.""http.query.params"".externalId,
	firstName:  inboundProperties.""http.query.params"".name,
	lastName:  inboundProperties.""http.query.params"".lastname,
	subsidiary: {
		internalId: 3
	}
}]]></dw:set-payload>
		</dw:transform-message>
		<netsuite:add-record config-ref=""NetSuite"" recordType=""EMPLOYEE"" doc:name=""Netsuite Add Record""/><json:object-to-json-transformer doc:name=""Object to JSON""/>
	</flow>
</mule>
----

== Other Code Examples

=== Working with Asynchronous Operations

This code example demonstrates how to use `async-add-list` together with the `check-async-status`, `get-async-result`, and `delete` operations, using a custom record type.

[NOTE]
====
Note that for this example code to work, you must use a custom record type of your own (or just a regular type), and manually configure the following values of the global NetSuite config to match your instance of NetSuite:

* email
* password
* account
* roleId
* applicationId
====

image::netsuite-async1.jpg[netsuite_async1]

[source,xml,linenums]
----
<?xml version=""1.0"" encoding=""UTF-8""?>

<mule xmlns:tracking=""http://www.mulesoft.org/schema/mule/ee/tracking""
	xmlns:dw=""http://www.mulesoft.org/schema/mule/ee/dw"" xmlns:netsuite=""http://www.mulesoft.org/schema/mule/netsuite""
	xmlns:json=""http://www.mulesoft.org/schema/mule/json"" xmlns:http=""http://www.mulesoft.org/schema/mule/http""
	xmlns=""http://www.mulesoft.org/schema/mule/core"" xmlns:doc=""http://www.mulesoft.org/schema/mule/documentation""
	xmlns:spring=""http://www.springframework.org/schema/beans"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance""
	xsi:schemaLocation=""http://www.mulesoft.org/schema/mule/netsuite http://www.mulesoft.org/schema/mule/netsuite/current/mule-netsuite.xsd
http://www.mulesoft.org/schema/mule/json http://www.mulesoft.org/schema/mule/json/current/mule-json.xsd
http://www.mulesoft.org/schema/mule/http http://www.mulesoft.org/schema/mule/http/current/mule-http.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-current.xsd
http://www.mulesoft.org/schema/mule/core http://www.mulesoft.org/schema/mule/core/current/mule.xsd
http://www.mulesoft.org/schema/mule/ee/tracking http://www.mulesoft.org/schema/mule/ee/tracking/current/mule-tracking-ee.xsd"">
	<http:listener-config name=""HTTP_Listener_Configuration""
		host=""0.0.0.0"" port=""8081"" doc:name=""HTTP Listener Configuration"" />

	<netsuite:config-login-authentication
		name=""NetSuite__Login_Authentication"" email=""${netsuite.email}""
		password=""${netsuite.password}"" account=""${netsuite.account}"" roleId=""${netsuite.roleId}""
		applicationId=""${netsuite.applicationId}"" doc:name=""NetSuite: Login Authentication"" />


	<flow name=""asyncAddList"" >

		<http:listener config-ref=""HTTP_Listener_Configuration""
			path=""/asyncAddList"" doc:name=""HTTP"" />

		<logger message=""Process Started ..."" level=""INFO"" doc:name=""Logger"" />

		<netsuite:async-add-list config-ref=""NetSuite__Login_Authentication""
			recordType=""__customRecordType__customrecordcustomaccount__22""
			doc:name=""Async Add List"">

			<netsuite:records-attributes>

				<netsuite:records-attribute>

					<netsuite:inner-records-attribute
						key=""externalId"">addListExt1</netsuite:inner-records-attribute>

					<netsuite:inner-records-attribute
						key=""name"">addListName1</netsuite:inner-records-attribute>

				</netsuite:records-attribute>

				<netsuite:records-attribute>

					<netsuite:inner-records-attribute
						key=""externalId"">addListExt2</netsuite:inner-records-attribute>

					<netsuite:inner-records-attribute
						key=""name"">addListName2</netsuite:inner-records-attribute>

				</netsuite:records-attribute>

			</netsuite:records-attributes>

		</netsuite:async-add-list>

		<set-variable variableName=""jobId"" value=""#[payload.getJobId()]""
			doc:name=""Set Variable: jobId"" />

		<flow-ref name=""check_async_status"" doc:name=""Check Async Status"" />
	</flow>

	<sub-flow name=""check_async_status"" >

		<logger message=""===== Checking status for jobId: #[flowVars.jobId] =====""
			level=""INFO"" doc:name=""Logger"" />

		<until-successful maxRetries=""180""
			failureExpression=""#[payload.getStatus() == com.netsuite.webservices.platform.core.types.AsyncStatusType.PENDING || payload.getStatus() == com.netsuite.webservices.platform.core.types.AsyncStatusType.PROCESSING]""
			synchronous=""true"" doc:name=""Until Successful"" millisBetweenRetries=""10000"">


			<processor-chain doc:name=""Processor Chain"">

				<netsuite:check-async-status config-ref=""NetSuite__Login_Authentication""
					jobId=""#[flowVars.jobId]"" doc:name=""Check Async Status"" />

				<logger message=""Status is: #[payload.getStatus()]"" level=""INFO""
					doc:name=""Status"" />

			</processor-chain>

		</until-successful>

		<choice doc:name=""Choice"">

			<when
				expression=""#[payload.getStatus() == com.netsuite.webservices.platform.core.types.AsyncStatusType.FINISHED]"">

				<logger message=""Records have been added successfully.""
					level=""INFO"" doc:name=""FINISHED"" />


			</when>

			<otherwise>

				<logger
					message=""An error has been encountered for jobId: #[flowVars.jobId] Navigate to Setup &gt; Integration &gt; Web Services Process Status on your sandbox for more information.""
					level=""ERROR"" doc:name=""FAILED / FINISHED_WITH_ERRORS"" />


			</otherwise>

		</choice>
	</sub-flow>

	<sub-flow name=""get_async_result"" >

		<http:listener config-ref=""HTTP_Listener_Configuration""
			path=""/getAsyncResult"" doc:name=""HTTP"" />

		<set-variable variableName=""jobId""
			value=""#[message.inboundProperties.'http.query.params'.jobId]""
			doc:name=""Set Variable: jobId"" />

		<logger message=""===== Results for jobId: #[flowVars.jobId] =====""
			level=""INFO"" doc:name=""Logger"" />

		<netsuite:get-async-result config-ref=""NetSuite__Login_Authentication""
			jobId=""#[flowVars.jobId]"" doc:name=""Get Async Result"" />

		<set-payload value=""#[payload.getWriteResponseList().getWriteResponse()]""
			doc:name=""Get Response List"" />

		<foreach doc:name=""For Each"">

			<logger
				message=""Custom record with externalId: #[payload.getBaseRef().getExternalId()] and typeId: #[payload.getBaseRef().getTypeId()] ... Deleting it!""
				level=""INFO"" doc:name=""Result Info"" />

			<netsuite:delete config-ref=""Netsuite"" doc:name=""Delete"">

				<netsuite:base-ref type=""CUSTOM_RECORD_REF"" externalId=""#[payload.getBaseRef().getExternalId()]"">

					<netsuite:specific-fields>

						<netsuite:specific-field key=""typeId"">#[payload.getBaseRef().getTypeId()]</netsuite:specific-field>

					</netsuite:specific-fields>

				</netsuite:base-ref>

			</netsuite:delete>

		</foreach>

		<logger message=""Process Complete"" level=""INFO"" doc:name=""Logger"" />
	</sub-flow>
</mule>
----

*Code Description*

. `netsuite:config-login-authentication` is the NetSuite global configuration.
. The first flow, labeled ""asyncAddList"" is triggered via an HTTP request.
. `netsuite:async-add-list` provides the configuration for the `async-add-list` operation showing `externalIds` and names we defined for the custom record.
. Store the `jobId` returned from the `async-add-list` operation in a flow variable called ""jobId"". See `set-variable`.
. Calls a sub-flow named ""check_async_status"" that monitors the status of the async process.
. The `until-successful` block queries NetSuite using the `check-async-result` operation to see whether the async job is finished or pending/processing. This loops for a number of defined retries and resumes control of the flow after the condition is satisfied.
. A `choice` router directs the message based on whether the async operation finished successfully or not.
. Displays a message in the console notifying that the async process is successful.
. Displays a message in the console if it has failed.
. The second flow is also triggered via an HTTP request, passing the `jobId` as a query parameter.
. Uses the `get-async-result` operation to obtain the result for the async process using the `jobId` that is saved.
. Extracts the response list from the `AsyncResult` object.
. For each result list item, logs some details and delete the record we added.
. Removes the custom records that are just added from the NetSuite sandbox using their `externalId`.


=== Using the Search Operation

In NetSuite, the `search` operation can be used to execute a *Basic Search*, *Joined Search* or an *Advanced Search*. To this end, you need to instantiate one of these three search types for the record type you want to query:

[cols=""2*""]
|===
|`<Record>SearchBasic`|Used to execute a search on a record type based on search filter fields that are specific to that type.
|`<Record>Search` +
|Used to execute a search on a record type based on search filter fields specific to that type and others that are associated with a related record type.
|`<Record>SearchAdvanced` +
|Used to execute a search on a record type in which you specify search filter fields and/or search return columns or joined search columns. Using advanced search, you can also return an existing saved search.
|===

This also applies for the asynchronous equivalent of search, the `asyncSearch` operation.

==== Search Pagination Support

Support for pagination was added to `search` for NetSuite connector version 7.0.0.

The connector's search capability is now unified under one operation. Other search-related processors have been removed. Thus, `search` will always retrieve the whole set of results. Therefore users will *not* need to work with `searchNext` or `searchMore` in order to get the rest of the records from subsequent pages. The return type is also different; the processor will output a List of Maps representing each and every record obtained by your search criteria.

An important aspect to note is that pagination could not be applied to the asynchronous equivalent of `search` (`asyncSearch`). This is due to the fact that the actual pagination would have to be applied to the `getAsyncResult` operation. This would mean that only the first page would end up being retrieved asynchronously. Furthermore, `getAsyncResult` is common to all async operations. Hence we cannot even apply pagination here since the return type of this operation depends on what async operation was invoked.

Regarding the new *search* configuration, the connector is the same apart from a new attribute called `fetchSize`:

[source,xml,linenums]
----
<netsuite:paged-search config-ref=""NetSuite__Login_Authentication"" searchRecord=""CUSTOMER_BASIC"" fetchSize=""5"" doc:name=""Customer Basic Search""/>
----

==== ItemSearchAdvanced and returnSearchColumns

When using `search`, the connector outputs a list of maps representing the Record objects returned by your `search` operation. If using an advanced search and the `returnSearchColumns` flag is set to true, NetSuite returns a `SearchRowList` containing the search results.

However, in the case of `ItemSearchAdvanced` the connector does not do this mapping and simply provides the user with the SearchRows. This is the case due to the fact that ITEMs in NetSuite can be of various types and we cannot assume the item type from an `ItemSearchRow`. This issue would also occur with any other record type that behaves similar to `ITEM`, but we are currently not aware of others.

==== Example of Basic Search

For this example, we set up a basic search operation for Customers (`CustomerSearchBasic`) with the criteria below:

* `companyName` starts with ""A"".
* The customer is not an individual.
* The customer has a priority of 50, which is handled by a `customField`.

Below is the Studio flow and the corresponding code:

image::netsuite-basic-search.jpg[netsuite_basic_search]

[source,xml,linenums]
----
<http:listener-config name=""HTTP_Listener_Configuration"" host=""0.0.0.0"" port=""8081"" doc:name=""HTTP Listener Configuration""/>

<netsuite:config-login-authentication name=""NetSuite__Login_Authentication"" email=""${netsuite.email}"" password=""${netsuite.password}"" account=""${netsuite.account}"" roleId=""${netsuite.roleId}"" applicationId=""${netsuite.applicationId}"" doc:name=""NetSuite: Login Authentication""/>

<flow name=""customer-basic-search"">
    <http:listener config-ref=""HTTP_Listener_Configuration"" path=""/basicSearch"" doc:name=""HTTP""/>
    <component class=""CustomerBasicSearchComponent"" doc:name=""Create Customer Search Basic criteria""/>
    <netsuite:search config-ref=""NetSuite__Login_Authentication"" searchRecord=""CUSTOMER_BASIC"" fetchSize=""5"" doc:name=""Customer Basic Search""/>
    <json:object-to-json-transformer doc:name=""Object to JSON""/>
</flow>
----

*Java Component Code*

[source,java,linenums]
----
public class CustomerBasicSearchComponent implements Callable {

    @Override
    public Object onCall(MuleEventContext eventContext) throws Exception {
        CustomerSearchBasic searchCriteria = new CustomerSearchBasic();

        SearchStringField companyNameFilter = new SearchStringField();
        companyNameFilter.setOperator(SearchStringFieldOperator.STARTS_WITH);
        companyNameFilter.setSearchValue(""A"");
        searchCriteria.setCompanyName(companyNameFilter);

        SearchBooleanField isPersonFilter = new SearchBooleanField();
        isPersonFilter.setSearchValue(false);
        searchCriteria.setIsPerson(isPersonFilter);

        SearchCustomFieldList customFieldListFilter = new SearchCustomFieldList();
        List<SearchCustomField> customFieldList = new ArrayList<SearchCustomField>();
        SearchLongCustomField priority = new SearchLongCustomField();
        priority.setScriptId(""custentity_cust_priority"");
        priority.setOperator(SearchLongFieldOperator.EQUAL_TO);
        priority.setSearchValue(50l);
        customFieldList.add(priority);
        customFieldListFilter.setCustomField(customFieldList);
        searchCriteria.setCustomFieldList(customFieldListFilter);

        return searchCriteria;
    }

}
----

==== Example of a Joined Search

This example here searches for all inventory items with a pricing join (ItemSearch) where the price rate is of 10.00. +
The search criteria is set within a custom Java component.

image::netsuite-joined-search.jpg[netsuite_joined_search]

[source,xml,linenums]
----
<flow name=""item-search-pricing-join"">
    <http:listener config-ref=""HTTP_Listener_Configuration"" path=""/joinedSearch"" doc:name=""HTTP""/>
    <component class=""ItemSearchPricingJoinComponent"" doc:name=""Create Item Search Pricing Join criteria""/>
    <netsuite:search config-ref=""NetSuite__Login_Authentication"" searchRecord=""ITEM"" doc:name=""Item Search Pricing Join""/>
    <json:object-to-json-transformer doc:name=""Object to JSON""/>
</flow>
----

*Java Component Code*

[source,java,linenums]
----
public class ItemSearchPricingJoinComponent implements Callable {

    @Override
    public Object onCall(MuleEventContext eventContext) throws Exception {
        ItemSearch searchCriteria = new ItemSearch();

        ItemSearchBasic basicCriteria = new ItemSearchBasic();
        SearchEnumMultiSelectField typeFilter = new SearchEnumMultiSelectField();
        List<String> typeList = new ArrayList<String>();
        typeList.add(""_inventoryItem"");
        typeFilter.setOperator(SearchEnumMultiSelectFieldOperator.ANY_OF);
        typeFilter.setSearchValue(typeList);
        basicCriteria.setType(typeFilter);
        searchCriteria.setBasic(basicCriteria);

        PricingSearchBasic pricingJoinCriteria = new PricingSearchBasic();
        SearchDoubleField rateFilter = new SearchDoubleField();
        rateFilter.setOperator(SearchDoubleFieldOperator.EQUAL_TO);
        rateFilter.setSearchValue(10.00d);
        pricingJoinCriteria.setRate(rateFilter);
        searchCriteria.setPricingJoin(pricingJoinCriteria);

        return searchCriteria;
    }

}
----

==== Example of Advanced Search

The example constructs a simple Java component that creates a criteria to get the result of an Employee saved search in our NetSuite environment (EmployeeSearchAdvanced). Each saved search in NetSuite has a particular id. Here, we use the scriptId customsearch130.

image::netsuite-code-example-search-advanced.jpg[netsuite_code_example_search_advanced]

[source,xml,linenums]
----
<flow name=""employee-search-advanced-saved-search"">
    <http:listener config-ref=""HTTP_Listener_Configuration"" path=""/advancedSearch"" doc:name=""HTTP""/>
    <component class=""EmployeeSearchAdvancedSavedComponent"" doc:name=""Create Employee Search Advanced Saved Search criteria""/>
    <netsuite:search config-ref=""NetSuite__Login_Authentication"" searchRecord=""EMPLOYEE_ADVANCED"" doc:name=""NetSuite""/>
    <json:object-to-json-transformer doc:name=""Object to JSON""/>
</flow>
----

*Java Component Code*

[source,java,linenums]
----
public class EmployeeSearchAdvancedSavedComponent implements Callable {

    @Override
    public Object onCall(MuleEventContext eventContext) throws Exception {
        EmployeeSearchAdvanced searchCriteria = new EmployeeSearchAdvanced();

        searchCriteria.setSavedSearchScriptId(""customsearch130"");

        return searchCriteria;
    }

}
----

=== NetSuite and DataWeave

The NetSuite connector’s DataSense capability coupled with that of DataWeave via the Transform Message component makes integrating with your NetSuite environment straightforward. For the following two examples, we use a JSON input string and extract the necessary data from it to form our NetSuite request.

. This example code adds a Journal Entry to NetSuite from the following JSON input:
+

[source,json,linenums]
----
{
   ""tranId"":""SampleJournal123"",
   ""subsidiary"":{
      ""internalId"":""1""
   },
   ""customFieldList"":{
      ""customField"":[
         {
            ""StringCustomFieldRef__custbodytestbodyfield"":""Sample Transaction Body Custom Field""
         }
      ]
   },
   ""lineList"":{
      ""line"":[
         {
            ""account"":{
               ""internalId"":""1""
            },
            ""debit"":100.0,
            ""customFieldList"":{
               ""customField"":[
                  {
                     ""SelectCustomFieldRef__custcol_far_trn_relatedasset"":{
                         ""internalId"":""1""
                     }
                  },
                  {
                     ""StringCustomFieldRef__custcoltestcolumnfield"": ""Sample Transaction Column Custom Field 1""
                  }
               ]
            }
         },
         {
            ""account"":{
               ""internalId"":""1""
            },
            ""credit"":100.0,
            ""customFieldList"":{
               ""customField"":[
                  {
                     ""SelectCustomFieldRef__custcol_far_trn_relatedasset"":{
                         ""internalId"":""2""
                     }
                  },
                  {
                     ""StringCustomFieldRef__custcoltestcolumnfield"": ""Sample Transaction Column Custom Field 2""
                  }
               ]
            }
         }
      ]
   }
}
----

+
The ""add"" operation for the connector expects a Map as input. The DataWeave script looks as follows:

+
image::netsuite-dataweave1.jpg[netsuite_dataweave1]
+

. In this example, we use the same scenario for basic search as described in the previous section. However, instead of constructing the criteria in a java component, we transform a JSON string:
+

[source,json,linenums]
----
{
   ""companyName"": {
      ""operator"": ""STARTS_WITH"",
      ""searchValue"": ""A""
   },
   ""isPerson"": false,
   ""priority"": {
      ""operator"": ""EQUAL_TO"",
      ""searchValue"": 50
   }
}
----

+
image::netsuite-code-example-dataweave02.jpg[netsuite_code_example_dataweave02]

== See Also

* Learn more about working with xref:3.7@mule-runtime::anypoint-connectors.adoc[Anypoint Connectors].
* xref:release-notes::connector/netsuite-connector-release-notes.adoc[NetSuite Connector Release Notes].
* https://www.mulesoft.com/exchange/org.mule.modules/mule-module-netsuite/[NetSuite Connector on Exchange]
",12278,False,1896.228048294749,median
"/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.

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.
==============================================================================*/

#include <memory>

#include ""Python.h""
#include ""absl/strings/str_format.h""
#include ""pybind11/chrono.h""
#include ""pybind11/complex.h""
#include ""pybind11/functional.h""
#include ""pybind11/pybind11.h""
#include ""pybind11/stl.h""
#include ""tensorflow/c/c_api.h""
#include ""tensorflow/c/c_api_experimental.h""
#include ""tensorflow/c/eager/c_api.h""
#include ""tensorflow/c/eager/c_api_experimental.h""
#include ""tensorflow/c/eager/c_api_internal.h""
#include ""tensorflow/c/eager/dlpack.h""
#include ""tensorflow/c/eager/tfe_tensorhandle_internal.h""
#include ""tensorflow/c/tf_status.h""
#include ""tensorflow/c/tf_status_helper.h""
#include ""tensorflow/compiler/jit/flags.h""
#include ""tensorflow/compiler/jit/get_compiler_ir.h""
#include ""tensorflow/python/eager/pywrap_tensor_conversion.h""
#include ""tensorflow/python/eager/pywrap_tfe.h""
#include ""tensorflow/python/lib/core/py_exception_registry.h""
#include ""tensorflow/python/lib/core/pybind11_lib.h""
#include ""tensorflow/python/lib/core/pybind11_status.h""
#include ""tensorflow/python/lib/core/safe_ptr.h""
#include ""tensorflow/python/lib/core/safe_pyobject_ptr.h""
#include ""tensorflow/python/util/util.h""

namespace py = pybind11;

PYBIND11_MAKE_OPAQUE(TFE_Executor);
PYBIND11_MAKE_OPAQUE(TFE_ContextOptions);
PYBIND11_MAKE_OPAQUE(TFE_CancellationManager);

PYBIND11_MAKE_OPAQUE(TFE_MonitoringCounter0);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringCounter1);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringCounter2);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringStringGauge0);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringStringGauge1);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringStringGauge2);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringIntGauge0);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringIntGauge1);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringIntGauge2);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringBoolGauge0);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringBoolGauge1);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringBoolGauge2);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringSampler0);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringSampler1);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringSampler2);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringCounterCell);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringIntGaugeCell);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringStringGaugeCell);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringBoolGaugeCell);
PYBIND11_MAKE_OPAQUE(TFE_MonitoringSamplerCell);

PYBIND11_MAKE_OPAQUE(TF_DeviceList);
PYBIND11_MAKE_OPAQUE(TF_Function);
PYBIND11_MAKE_OPAQUE(TF_Buffer);

// Eager helper functions migrated from pywrap_tfe.i.

namespace tensorflow {

// We cannot use Context as an opaque type. SWIG also had
// difficult directly passing the pointer around. These
// typemaps are migrated over from pywrap_tfe.i. I tried
// using a custom type caster, but we get segfaults periodically.

// TODO(amitpatankar): Move input and output logic of Context into a
// pybind11 custom type caster.

TFE_Context* InputTFE_Context(const py::handle& ctx) {
  return static_cast<TFE_Context*>(PyCapsule_GetPointer(ctx.ptr(), nullptr));
}

PyObject* OutputTFE_Context(TFE_Context* context) {
  return PyCapsule_New(context, nullptr, TFE_DeleteContextCapsule);
}

TF_Buffer* ProtoStringToTFBuffer(PyObject* input) {
  // Convert a Python string object to TF_Buffer.
  char* c_string;
  Py_ssize_t py_size;
  // PyBytes_AsStringAndSize() does not copy but simply interprets the input
  if (PyBytes_AsStringAndSize(input, &c_string, &py_size) == -1) {
    // Python has raised an error (likely TypeError or UnicodeEncodeError).
    throw py::error_already_set();
  }
  return TF_NewBufferFromString(static_cast<void*>(c_string),
                                static_cast<size_t>(py_size));
}

// These functions are typemaps from the Python side. I did not use
// a custom type caster since the logic is slightly harder to follow. This
// converter is also only used once in `TFE_Py_ExecuteCancelable_wrapper`.
TFE_InputTensorHandles InputTFE_InputTensorHandles(
    const py::handle& input_tensors) {
  TFE_InputTensorHandles input_tensor_handles;
  if (input_tensors.ptr() != Py_None) {
    if (!PyList_Check(input_tensors.ptr())) {
      tensorflow::ThrowTypeError(""must provide a list of Tensors as inputs"");
    }
    Py_ssize_t len = PyList_Size(input_tensors.ptr());
    input_tensor_handles.resize(len);
    for (Py_ssize_t i = 0; i < len; ++i) {
      PyObject* elem = PyList_GetItem(input_tensors.ptr(), i);
      if (!elem) {
        tensorflow::ThrowTypeError(""Input Tensor does not exist."");
      }
      if (EagerTensor_CheckExact(elem)) {
        (input_tensor_handles)[i] = EagerTensor_Handle(elem);
      } else if (tensorflow::swig::IsEagerTensorSlow(elem)) {
        // Use equivalent of object.__getattribute__ to get the underlying
        // tf wrapped EagerTensor (if there is one).
        tensorflow::Safe_PyObjectPtr tf_should_use_attr(
#if PY_MAJOR_VERSION < 3
            PyString_InternFromString(""_tf_should_use_wrapped_value"")
#else
            PyUnicode_InternFromString(""_tf_should_use_wrapped_value"")
#endif
        );
        tensorflow::Safe_PyObjectPtr value_attr(
            PyObject_GenericGetAttr(elem, tf_should_use_attr.get()));
        if (value_attr) {
          // This is an EagerTensor wrapped inside a TFShouldUse wrapped object.
          (input_tensor_handles)[i] = EagerTensor_Handle(value_attr.get());
        } else {
          // This is a subclass of EagerTensor that we don't support.
          PyErr_Clear();
          tensorflow::ThrowTypeError(
              tensorflow::strings::StrCat(
                  ""Saw an object that is an instance of a strict subclass of ""
                  ""EagerTensor, which is not supported.  Item "",
                  i, "" is type: "", elem->ob_type->tp_name)
                  .c_str());
        }
      } else if (tensorflow::swig::IsTensor(elem)) {
        // If it isnt an EagerTensor, but is still a Tensor, it must be a graph
        // tensor.
        tensorflow::Safe_PyObjectPtr name_attr(
            PyObject_GetAttrString(elem, ""name""));
        tensorflow::ThrowTypeError(
            tensorflow::strings::StrCat(
                ""An op outside of the function building code is being passed\\n""
                ""a \\""Graph\\"" tensor. It is possible to have Graph tensors\\n""
                ""leak out of the function building context by including a\\n""
                ""tf.init_scope in your function building code.\\n""
                ""For example, the following function will fail:\\n"",
                ""  @tf.function\\n"", ""  def has_init_scope():\\n"",
                ""    my_constant = tf.constant(1.)\\n"",
                ""    with tf.init_scope():\\n"",
                ""      added = my_constant * 2\\n"",
                ""The graph tensor has name: "",
                name_attr ? TFE_GetPythonString(name_attr.get()) : ""<unknown>"")
                .c_str());
      } else {
        tensorflow::ThrowTypeError(
            tensorflow::strings::StrCat(
                ""provided list of inputs contains objects other ""
                ""than 'EagerTensor'. Item "",
                i, "" is type: "", elem->ob_type->tp_name)
                .c_str());
      }
    }
  }
  return input_tensor_handles;
}

// These functions are typemaps from the Python side. I did not use
// a custom type caster since the logic is slightly harder to follow. This
// converter is also only used once in `TFE_Py_ExecuteCancelable_wrapper`.
// This function actually takes a number rather than an output Tensor holder.
TFE_OutputTensorHandles InputTFE_OutputTensorHandles(
    const py::handle& num_outputs) {
  TFE_OutputTensorHandles output_tensor_handles;
#if PY_MAJOR_VERSION < 3
  if (!PyInt_Check(num_outputs.ptr())) {
#else
  if (!PyLong_Check(num_outputs.ptr())) {
#endif
    PyErr_SetString(PyExc_TypeError,
                    ""expected an integer value (size of the number of ""
                    ""outputs of the operation)"");
    throw py::error_already_set();
  }
#if PY_MAJOR_VERSION < 3
  long sz = PyInt_AsLong(num_outputs.ptr());  // NOLINT
#else
  long sz = PyLong_AsLong(num_outputs.ptr());  // NOLINT
#endif
  if (sz > 0) {
#if PY_MAJOR_VERSION < 3
    output_tensor_handles.resize(PyInt_AsLong(num_outputs.ptr()), nullptr);
#else
    output_tensor_handles.resize(PyLong_AsLong(num_outputs.ptr()), nullptr);
#endif
  }
  return output_tensor_handles;
}

// Packs multiple `EagerTensor`s of the same dtype and shape into one
// `EagerTensor`.
py::object TFE_Py_PackEagerTensors_wrapper(const py::handle& context,
                                           const py::handle& tensors) {
  TFE_Context* ctx = tensorflow::InputTFE_Context(context);
  TFE_InputTensorHandles handles = InputTFE_InputTensorHandles(tensors);
  tensorflow::Safe_TF_StatusPtr status = tensorflow::make_safe(TF_NewStatus());
  int size = handles.size();
  TFE_TensorHandle* packed_handle =
      TFE_CreatePackedTensorHandle(ctx, handles.data(), &size, status.get());
  tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
  PyObject* packed_tensor =
      EagerTensorFromHandle(packed_handle, /*is_packed=*/true);
  return tensorflow::PyoOrThrow(packed_tensor);
}

// This function was created from fusing the typemap logic in platform/base.i.
py::object TFE_Py_ExecuteCancelable_wrapper(
    const py::handle& context, const char* device_name, const char* op_name,
    const py::handle& inputs, const py::handle& attrs,
    TFE_CancellationManager* cancellation_manager,
    const py::handle& num_outputs) {
  TFE_Context* ctx = tensorflow::InputTFE_Context(context);
  TFE_InputTensorHandles input_tensor_handles =
      InputTFE_InputTensorHandles(inputs);
  TFE_OutputTensorHandles output_tensor_handles =
      InputTFE_OutputTensorHandles(num_outputs);
  tensorflow::Safe_TF_StatusPtr status = tensorflow::make_safe(TF_NewStatus());
  TFE_Py_ExecuteCancelable(ctx, device_name, op_name, &input_tensor_handles,
                           attrs.ptr(), cancellation_manager,
                           &output_tensor_handles, status.get());

  int output_len = output_tensor_handles.size();
  PyObject* output_list = PyList_New(output_len);
  for (int i = 0; i < output_len; ++i) {
    PyObject* output;
    output = EagerTensorFromHandle(output_tensor_handles.at(i));
    PyList_SetItem(output_list, i, output);
  }
  tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
  return tensorflow::PyoOrThrow(output_list);
}

static py::object TF_ListPhysicalDevices() {
  std::vector<string> devices;
  tensorflow::Status s =
      tensorflow::DeviceFactory::ListAllPhysicalDevices(&devices);
  MaybeRaiseRegisteredFromStatus(s);
  PyObject* result = PyList_New(devices.size());
  int i = 0;
  for (auto& dev : devices) {
    PyObject* dev_obj = PyBytes_FromStringAndSize(dev.data(), dev.size());
    PyList_SetItem(result, i, dev_obj);
    ++i;
  }
  return tensorflow::PyoOrThrow(result);
}

static std::unordered_map<string, string> TF_GetDeviceDetails(int index) {
  tensorflow::Safe_TF_StatusPtr status = tensorflow::make_safe(TF_NewStatus());
  std::unordered_map<string, string> device_details;
  tensorflow::Status s =
      tensorflow::DeviceFactory::GetAnyDeviceDetails(index, &device_details);
  tensorflow::Set_TF_Status_from_Status(status.get(), s);
  MaybeRaiseRegisteredFromTFStatus(status.get());
  return device_details;
}

static py::object TFE_ClearScalarCache() {
  tensorflow::TFE_TensorHandleCache::Get()->Clear();
  return py::none();
}

// Returns compiler IR for a given function.
static std::string TFE_GetCompilerIr(py::handle& ctx,
                                     const char* concrete_function_name,
                                     const char* stage, const char* device_name,
                                     py::handle& inputs) {
  EagerContext* context = ContextFromInterface(
      reinterpret_cast<ImmediateExecutionContext*>(InputTFE_Context(ctx)));

  std::string s_stage(stage);
  IrExportStage selected_stage = [&] {
    if (s_stage == ""hlo"") {
      return IrExportStage::HLO;
    } else if (s_stage == ""optimized_hlo"") {
      return IrExportStage::OPTIMIZED_HLO;
    } else if (s_stage == ""optimized_hlo_dot"") {
      return IrExportStage::OPTIMIZED_HLO_DOT;
    } else {
      ThrowValueError(
          absl::StrFormat(""Invalid stage selected: '%s'. Valid values are: ""
                          ""'hlo', 'optimized_hlo', 'optimized_hlo_dot'"",
                          s_stage)
              .c_str());
    }
  }();

  TFE_InputTensorHandles handles = InputTFE_InputTensorHandles(inputs);

  std::vector<const TensorHandle*> input_handles;
  for (TFE_TensorHandle* tensor_handle : handles) {
    AbstractTensorHandle* abstract_tensor_handle = unwrap(tensor_handle);
    input_handles.push_back(TensorHandleFromInterface(abstract_tensor_handle));
  }

  DeviceNameUtils::ParsedName input_device_name;
  if (!DeviceNameUtils::ParseFullOrLocalName(device_name, &input_device_name)) {
    ThrowValueError(
        absl::StrFormat(""Failed parsing device name: '%s'"", device_name)
            .c_str());
  }

  std::vector<Device*> devices = context->local_device_mgr()->ListDevices();
  auto selected_device = absl::c_find_if(devices, [&](const Device* d) {
    return DeviceNameUtils::AreCompatibleDevNames(input_device_name,
                                                  d->parsed_name());
  });
  if (selected_device == devices.end()) {
    ThrowValueError(""No matching device found"");
  }

  xla::StatusOr<std::string> hlo_text =
      GetCompilerIr(selected_stage, context->pflr(), concrete_function_name,
                    *selected_device, context, input_handles);

  if (!hlo_text.ok()) {
    ThrowValueError(absl::StrFormat(""Failed getting HLO text: '%s'"",
                                    hlo_text.status().error_message())
                        .c_str());
  }
  return *hlo_text;
}

}  // namespace tensorflow

namespace {

// Wrapper around the EagerContextThreadLocalData struct (defined in
// pywrap_tfe.h), so it can be accessed from Python.
//
// For PyObject* fields, the get_*() methods return a new reference; and the
// set_*() methods create a new reference (i.e., they do not steal a reference).
class EagerContextThreadLocalDataWrapper {
 public:
  explicit EagerContextThreadLocalDataWrapper(py::handle py_eager_context,
                                              py::handle is_eager,
                                              py::handle device_spec)
      : py_eager_context_(py_eager_context.ptr()) {
    tensorflow::MakeEagerContextThreadLocalData(
        py_eager_context.ptr(), is_eager.ptr(), device_spec.ptr());
  }

  ~EagerContextThreadLocalDataWrapper() {
    tensorflow::DestroyEagerContextThreadLocalData(py_eager_context_);
  }

  bool get_is_eager() const { return GetData()->is_eager; }
  void set_is_eager(bool v) { GetData()->is_eager = v; }

  bool get_invoking_op_callbacks() const {
    return GetData()->invoking_op_callbacks;
  }
  void set_invoking_op_callbacks(bool v) {
    GetData()->invoking_op_callbacks = v;
  }

  py::handle get_device_name() const {
    return GetPyObject(&GetData()->device_name);
  }
  void set_device_name(py::handle v) {
    SetPyObject(v, &GetData()->device_name);
  }

  py::handle get_scope_name() const {
    return GetPyObject(&GetData()->scope_name);
  }
  void set_scope_name(py::handle v) { SetPyObject(v, &GetData()->scope_name); }

  py::handle get_device_spec() const {
    return GetPyObject(&GetData()->device_spec);
  }
  void set_device_spec(py::handle v) {
    SetPyObject(v, &GetData()->device_spec);
  }

  py::handle get_function_call_options() const {
    return GetPyObject(&GetData()->function_call_options);
  }
  void set_function_call_options(py::handle v) {
    SetPyObject(v, &GetData()->function_call_options);
  }

  py::handle get_executor() const { return GetPyObject(&GetData()->executor); }
  void set_executor(py::handle v) { SetPyObject(v, &GetData()->executor); }

  py::handle get_op_callbacks() const {
    return GetPyObject(&GetData()->op_callbacks);
  }
  void set_op_callbacks(py::handle v) {
    SetPyObject(v, &GetData()->op_callbacks);
  }

 private:
  tensorflow::EagerContextThreadLocalData* GetData() const {
    auto* result =
        tensorflow::GetEagerContextThreadLocalData(py_eager_context_);
    if (!result) {
      throw py::error_already_set();
    }
    return result;
  }

  py::handle GetPyObject(tensorflow::Safe_PyObjectPtr* obj) const {
    Py_INCREF(obj->get());
    return obj->get();
  }

  void SetPyObject(py::handle value, tensorflow::Safe_PyObjectPtr* ptr) {
    Py_INCREF(value.ptr());
    ptr->reset(value.ptr());
  }

  PyObject* py_eager_context_;  // not owned (borrowed reference).
};

}  // namespace

// py::return_value_policy::reference is defined as specified by the
// pybind11 documents listed here.
// https://pybind11.readthedocs.io/en/stable/advanced/functions.html#return-value-policies
// This means that C++ maintains ownership of the object. We
// are only assigning this to functions that return opaque types.

PYBIND11_MODULE(_pywrap_tfe, m) {
  py::class_<TFE_Executor> TFE_Executor_class(m, ""TFE_Executor"");
  py::class_<TFE_ContextOptions> TFE_ContextOptions_class(m,
                                                          ""TFE_ContextOptions"");
  py::class_<TFE_MonitoringCounter0> TFE_MonitoringCounter0_class(
      m, ""TFE_MonitoringCounter0"");
  py::class_<TFE_MonitoringCounter1> TFE_MonitoringCounter1_class(
      m, ""TFE_MonitoringCounter1"");
  py::class_<TFE_MonitoringCounter2> TFE_MonitoringCounter2_class(
      m, ""TFE_MonitoringCounter2"");
  py::class_<TFE_MonitoringStringGauge0> TFE_MonitoringStringGauge0_class(
      m, ""TFE_MonitoringStringGauge0"");
  py::class_<TFE_MonitoringStringGauge1> TFE_MonitoringStringGauge1_class(
      m, ""TFE_MonitoringStringGauge1"");
  py::class_<TFE_MonitoringStringGauge2> TFE_MonitoringStringGauge2_class(
      m, ""TFE_MonitoringStringGauge2"");
  py::class_<TFE_MonitoringIntGauge0> TFE_MonitoringIntGauge0_class(
      m, ""TFE_MonitoringIntGauge0"");
  py::class_<TFE_MonitoringIntGauge1> TFE_MonitoringIntGauge1_class(
      m, ""TFE_MonitoringIntGauge1"");
  py::class_<TFE_MonitoringIntGauge2> TFE_MonitoringIntGauge2_class(
      m, ""TFE_MonitoringIntGauge2"");
  py::class_<TFE_MonitoringBoolGauge0> TFE_MonitoringBoolGauge0_class(
      m, ""TFE_MonitoringBoolGauge0"");
  py::class_<TFE_MonitoringBoolGauge1> TFE_MonitoringBoolGauge1_class(
      m, ""TFE_MonitoringBoolGauge1"");
  py::class_<TFE_MonitoringBoolGauge2> TFE_MonitoringBoolGauge2_class(
      m, ""TFE_MonitoringBoolGauge2"");
  py::class_<TFE_MonitoringCounterCell> TFE_MonitoringCounterCell_class(
      m, ""TFE_MonitoringCounterCell"");
  py::class_<TFE_MonitoringIntGaugeCell> TFE_MonitoringIntGaugeCell_class(
      m, ""TFE_MonitoringIntGaugeCell"");
  py::class_<TFE_MonitoringStringGaugeCell> TFE_MonitoringStringGaugeCell_class(
      m, ""TFE_MonitoringStringGaugeCell"");
  py::class_<TFE_MonitoringBoolGaugeCell> TFE_MonitoringBoolGaugeCell_class(
      m, ""TFE_MonitoringBoolGaugeCell"");
  py::class_<TFE_MonitoringSamplerCell> TFE_MonitoringSamplerCell_class(
      m, ""TFE_MonitoringSamplerCell"");
  py::class_<TFE_MonitoringBuckets> TFE_MonitoringBuckets_class(
      m, ""TFE_MonitoringBuckets"");
  py::class_<TFE_MonitoringSampler0> TFE_MonitoringSampler0_class(
      m, ""TFE_MonitoringSampler0"");
  py::class_<TFE_MonitoringSampler1> TFE_MonitoringSampler1_class(
      m, ""TFE_MonitoringSampler1"");
  py::class_<TFE_MonitoringSampler2> TFE_MonitoringSampler2_class(
      m, ""TFE_MonitoringSampler2"");
  py::class_<TFE_CancellationManager> TFE_CancellationManager_class(
      m, ""TFE_CancellationManager"");

  py::class_<TF_DeviceList> TF_DeviceList_class(m, ""TF_DeviceList"");
  py::class_<TF_Function> TF_Function_class(m, ""TF_Function"");

  m.def(""TFE_Py_RegisterExceptionClass"", [](const py::handle& e) {
    return tensorflow::PyoOrThrow(TFE_Py_RegisterExceptionClass(e.ptr()));
  });
  m.def(""TFE_Py_RegisterFallbackExceptionClass"", [](const py::handle& e) {
    return tensorflow::PyoOrThrow(
        TFE_Py_RegisterFallbackExceptionClass(e.ptr()));
  });

  m.def(
      ""TFE_GetTotalMemoryUsage"", [](py::handle& ctx, const char* device_name) {
        tensorflow::EagerContext* context = tensorflow::ContextFromInterface(
            reinterpret_cast<tensorflow::ImmediateExecutionContext*>(
                tensorflow::InputTFE_Context(ctx)));

        tensorflow::DeviceNameUtils::ParsedName input_device_name;
        if (!tensorflow::DeviceNameUtils::ParseFullOrLocalName(
                device_name, &input_device_name)) {
          tensorflow::ThrowValueError(
              absl::StrFormat(""Failed parsing device name: '%s'"", device_name)
                  .c_str());
        }

        std::vector<tensorflow::Device*> devices =
            context->local_device_mgr()->ListDevices();

        tensorflow::Device* matched_device = nullptr;
        for (int device_idx = 0; device_idx < devices.size(); device_idx++) {
          tensorflow::Device* device = devices[device_idx];

          if (tensorflow::DeviceNameUtils::AreCompatibleDevNames(
                  input_device_name, device->parsed_name())) {
            if (device->device_type() == tensorflow::DEVICE_CPU) {
              tensorflow::ThrowValueError(
                  ""CPU does not support getting allocator information"");
            }

            if (matched_device != nullptr) {
              tensorflow::ThrowValueError(
                  absl::StrFormat(
                      ""Multiple devices matching the provided string ""
                      ""'%s': '%s' and ""
                      ""'%s' "",
                      device_name, matched_device->name(), device->name())
                      .c_str());
            }
            matched_device = device;
          }
        }

        if (matched_device == nullptr) {
          tensorflow::ThrowValueError(
              absl::StrFormat(""No matching devices found for '%s'"", device_name)
                  .c_str());
        }

        tensorflow::AllocatorAttributes attrs;
        tensorflow::Allocator* allocator = matched_device->GetAllocator(attrs);

        if (absl::optional<tensorflow::AllocatorStats> stats =
                allocator->GetStats()) {
          return stats->bytes_in_use;
        }

        tensorflow::ThrowTypeError(
            absl::StrFormat(""Allocator stats not available for device '%s'"",
                            matched_device->name())
                .c_str());
      });

  // XLA Eager Logic
  m.def(""TF_SetXlaEnableLazyCompilation"", &TF_SetXlaEnableLazyCompilation);
  m.def(""TF_SetTfXlaCpuGlobalJit"", &TF_SetTfXlaCpuGlobalJit);
  m.def(""TF_SetXlaAutoJitMode"", &TF_SetXlaAutoJitMode);
  m.def(""TF_SetXlaConstantFoldingDisabled"", &TF_SetXlaConstantFoldingDisabled);
  m.def(""TF_GetXlaConstantFoldingDisabled"", &TF_GetXlaConstantFoldingDisabled);
  m.def(""TF_SetXlaMinClusterSize"", &TF_SetXlaMinClusterSize);
  m.def(""TF_GetCompilerIr"", &tensorflow::TFE_GetCompilerIr);

  // MLIR Logic
  m.def(""TF_IsMlirBridgeEnabled"", [] {
    return tensorflow::GetMlirCommonFlags()->tf_mlir_enable_mlir_bridge ==
           tensorflow::ConfigProto::Experimental::MLIR_BRIDGE_ROLLOUT_ENABLED;
  });
  m.def(""TF_EnableMlirBridge"", [](bool enabled) {
    tensorflow::GetMlirCommonFlags()->tf_mlir_enable_mlir_bridge =
        enabled
            ? tensorflow::ConfigProto::Experimental::MLIR_BRIDGE_ROLLOUT_ENABLED
            : tensorflow::ConfigProto::Experimental::
                  MLIR_BRIDGE_ROLLOUT_DISABLED;
  });
  m.def(""TF_EnableXlaDevices"", [] {
    tensorflow::GetXlaDeviceFlags()->tf_xla_enable_xla_devices = true;
  });

  // // TFE_Context Logic
  m.def(
      ""TFE_NewContext"",
      [](const TFE_ContextOptions* opts) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        TFE_Context* context = TFE_NewContext(opts, status.get());
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return tensorflow::PyoOrThrow(tensorflow::OutputTFE_Context(context));
      },
      py::return_value_policy::reference);
  m.def(""TFE_DeleteContext"", [](py::handle& o) {
    TFE_DeleteContext(tensorflow::InputTFE_Context(o));
  });
  m.def(
      ""TFE_ContextListDevices"",
      [](py::handle& o) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        auto output = TFE_ContextListDevices(tensorflow::InputTFE_Context(o),
                                             status.get());
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return output;
      },
      py::return_value_policy::reference);
  m.def(""TFE_HostAddressSpace"", [](py::handle& o, TF_Buffer& buf) {
    TFE_HostAddressSpace(tensorflow::InputTFE_Context(o), &buf);
  });
  m.def(""TFE_ContextAddFunction"", [](py::handle& ctx, TF_Function* func) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    TFE_ContextAddFunction(tensorflow::InputTFE_Context(ctx), func,
                           status.get());
    tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
  });
  m.def(""TFE_ContextAddFunctionDef"",
        [](py::handle& ctx, const char* serialized_function_def, size_t size) {
          tensorflow::Safe_TF_StatusPtr status =
              tensorflow::make_safe(TF_NewStatus());
          TFE_ContextAddFunctionDef(tensorflow::InputTFE_Context(ctx),
                                    serialized_function_def, size,
                                    status.get());
          tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        });
  m.def(""TFE_ContextGetFunctionDef"",
        [](py::handle& ctx, const char* function_name, TF_Buffer& buf) {
          tensorflow::Safe_TF_StatusPtr status =
              tensorflow::make_safe(TF_NewStatus());
          TFE_ContextGetFunctionDef(tensorflow::InputTFE_Context(ctx),
                                    function_name, &buf, status.get());
          tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        });
  m.def(""TFE_ContextRemoveFunction"", [](py::handle& ctx, const char* name) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    TFE_ContextRemoveFunction(tensorflow::InputTFE_Context(ctx), name,
                              status.get());
    tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
  });
  m.def(""TFE_ContextHasFunction"", [](py::handle& ctx, const char* name) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    auto output =
        TFE_ContextHasFunction(tensorflow::InputTFE_Context(ctx), name);
    tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
    return output;
  });
  m.def(""TFE_ContextEnableRunMetadata"", [](py::handle& ctx) {
    TFE_ContextEnableRunMetadata(tensorflow::InputTFE_Context(ctx));
  });
  m.def(""TFE_ContextDisableRunMetadata"", [](py::handle& ctx) {
    TFE_ContextEnableRunMetadata(tensorflow::InputTFE_Context(ctx));
  });
  m.def(""TFE_ContextEnableGraphCollection"", [](py::handle& ctx) {
    TFE_ContextEnableGraphCollection(tensorflow::InputTFE_Context(ctx));
  });
  m.def(""TFE_ContextDisableGraphCollection"", [](py::handle& ctx) {
    TFE_ContextDisableGraphCollection(tensorflow::InputTFE_Context(ctx));
  });
  m.def(""TFE_ContextExportRunMetadata"", [](py::handle& ctx, TF_Buffer& buf) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    TFE_ContextExportRunMetadata(tensorflow::InputTFE_Context(ctx), &buf,
                                 status.get());
    tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
  });
  m.def(""TFE_ContextClearCaches"", [](py::handle& o) {
    TFE_ContextClearCaches(tensorflow::InputTFE_Context(o));
  });
  m.def(""TFE_GetContextId"", [](py::handle& ctx) {
    return TFE_GetContextId(tensorflow::InputTFE_Context(ctx));
  });
  m.def(""TFE_ContextGetDevicePlacementPolicy"", [](py::handle& ctx) {
    return TFE_ContextGetDevicePlacementPolicy(
        tensorflow::InputTFE_Context(ctx));
  });
  m.def(""TFE_ContextSetThreadLocalDevicePlacementPolicy"",
        [](py::handle& ctx, TFE_ContextDevicePlacementPolicy policy) {
          TFE_ContextSetThreadLocalDevicePlacementPolicy(
              tensorflow::InputTFE_Context(ctx), policy);
        });
  m.def(""TFE_ContextSetServerDef"", [](py::handle& ctx, int keep_alive_secs,
                                      py::bytes proto) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    tensorflow::Safe_TF_BufferPtr buf =
        tensorflow::make_safe(tensorflow::ProtoStringToTFBuffer(proto.ptr()));
    TFE_ContextSetServerDef(tensorflow::InputTFE_Context(ctx), keep_alive_secs,
                            buf.get()->data, buf.get()->length, status.get());
    tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
  });
  m.def(""TFE_ContextUpdateServerDef"", [](py::handle& ctx, int keep_alive_secs,
                                         py::bytes proto) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    tensorflow::Safe_TF_BufferPtr buf =
        tensorflow::make_safe(tensorflow::ProtoStringToTFBuffer(proto.ptr()));
    Py_BEGIN_ALLOW_THREADS;
    TFE_ContextUpdateServerDef(tensorflow::InputTFE_Context(ctx),
                               keep_alive_secs, buf.get()->data,
                               buf.get()->length, status.get());
    Py_END_ALLOW_THREADS;
    tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
  });
  m.def(""TFE_ContextCheckAlive"", [](py::handle& ctx, const char* worker_name) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    bool output = TFE_ContextCheckAlive(tensorflow::InputTFE_Context(ctx),
                                        worker_name, status.get());
    tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
    return output;
  });
  m.def(""TFE_ContextSyncExecutors"", [](py::handle& ctx) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    TFE_ContextAsyncWait(tensorflow::InputTFE_Context(ctx), status.get());
    tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
  });
  m.def(""TFE_ContextClearExecutors"", [](py::handle& ctx) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    TFE_ContextAsyncWait(tensorflow::InputTFE_Context(ctx), status.get());
    // NOTE: different from TFE_ContextSyncExecutors that raises potential
    // errors, deliberately ignore executor statuses in cleanup.
  });
  m.def(""TFE_ContextSetSoftDevicePlacement"", [](py::handle& ctx, bool enable) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    TFE_ContextSetSoftDevicePlacement(tensorflow::InputTFE_Context(ctx), enable,
                                      status.get());
  });
  m.def(""TFE_ContextSetLogDevicePlacement"", [](py::handle& ctx, bool enable) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    TFE_ContextSetSoftDevicePlacement(tensorflow::InputTFE_Context(ctx), enable,
                                      status.get());
  });

  // TFE_Executor logic
  m.def(
      ""TFE_NewExecutor"",
      [](const bool is_async) {
        TFE_Executor* exc = TFE_NewExecutor(is_async);
        return exc;
      },
      py::return_value_policy::reference);
  m.def(""TFE_DeleteExecutor"", &TFE_DeleteExecutor);
  m.def(""TFE_ExecutorIsAsync"", &TFE_ExecutorIsAsync);
  m.def(""TFE_ExecutorWaitForAllPendingNodes"", [](TFE_Executor& exc) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    // NOTE: release Python GIL for pending PyFunc ops to be executed properly.
    Py_BEGIN_ALLOW_THREADS;
    TFE_ExecutorWaitForAllPendingNodes(&exc, status.get());
    Py_END_ALLOW_THREADS;
    tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
  });
  m.def(""TFE_ExecutorClearError"", &TFE_ExecutorClearError);
  m.def(""TFE_ContextSetExecutorForThread"", [](py::handle& ctx,
                                              TFE_Executor& exc) {
    TFE_ContextSetExecutorForThread(tensorflow::InputTFE_Context(ctx), &exc);
  });
  m.def(
      ""TFE_ContextGetExecutorForThread"",
      [](py::handle& o) {
        return TFE_ContextGetExecutorForThread(tensorflow::InputTFE_Context(o));
      },
      py::return_value_policy::reference);

  m.def(""TFE_OpNameGetAttrType"",
        [](py::handle& ctx, const char* op_or_function_name,
           const char* attr_name) {
          int temp = 0;
          unsigned char* is_list = reinterpret_cast<unsigned char*>(&temp);
          tensorflow::Safe_TF_StatusPtr status =
              tensorflow::make_safe(TF_NewStatus());
          auto output = TFE_OpNameGetAttrType(tensorflow::InputTFE_Context(ctx),
                                              op_or_function_name, attr_name,
                                              is_list, status.get());
          tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
#if PY_MAJOR_VERSION < 3
          PyObject* output_pyo = PyInt_FromLong(output);
#else
          PyObject* output_pyo = PyLong_FromLong(output);
#endif
          if (*is_list == 1) {
            PyObject* list = PyList_New(1);
            PyList_SetItem(list, 0, output_pyo);
            return tensorflow::PyoOrThrow(list);
          }
          return tensorflow::PyoOrThrow(output_pyo);
        });
  m.def(""TFE_Py_InitEagerTensor"", [](const py::handle& o) {
    return tensorflow::PyoOrThrow(TFE_Py_InitEagerTensor(o.ptr()));
  });
  m.def(""TFE_Py_PackEagerTensors"",
        [](const py::handle& context, const py::handle& handles) {
          return tensorflow::TFE_Py_PackEagerTensors_wrapper(context, handles);
        });
  m.def(""TFE_Py_SetEagerTensorProfiler"", &TFE_Py_SetEagerTensorProfiler);
  m.def(""TFE_Py_RegisterJVPFunction"", [](const py::handle& o) {
    return tensorflow::PyoOrThrow(TFE_Py_RegisterJVPFunction(o.ptr()));
  });
  m.def(""TFE_Py_RegisterGradientFunction"", [](const py::handle& o) {
    return tensorflow::PyoOrThrow(TFE_Py_RegisterGradientFunction(o.ptr()));
  });
  m.def(""TFE_Py_Execute"",
        [](const py::handle& context, const char* device_name,
           const char* op_name, const py::handle& inputs,
           const py::handle& attrs, const py::handle& num_outputs) {
          return tensorflow::TFE_Py_ExecuteCancelable_wrapper(
              context, device_name, op_name, inputs, attrs.ptr(), nullptr,
              num_outputs);
        });
  m.def(
      ""TFE_Py_ExecuteCancelable"",
      [](const py::handle& context, const char* device_name,
         const char* op_name, const py::handle& inputs, const py::handle& attrs,
         TFE_CancellationManager& cancellation_manager,
         const py::handle& num_outputs) {
        return tensorflow::TFE_Py_ExecuteCancelable_wrapper(
            context, device_name, op_name, inputs, attrs.ptr(),
            &cancellation_manager, num_outputs);
      });
  m.def(""TFE_Py_FastPathExecute"", [](const py::args args) {
    // TFE_Py_FastPathExecute requires error checking prior to returning.
    return tensorflow::PyoOrThrow(TFE_Py_FastPathExecute_C(args.ptr()));
  });
  m.def(""TFE_Py_RecordGradient"",
        [](const py::handle& op_name, const py::handle& inputs,
           const py::handle& attrs, const py::handle& results,
           const py::handle& forward_pass_name_scope) {
          return tensorflow::PyoOrThrow(TFE_Py_RecordGradient(
              op_name.ptr(), inputs.ptr(), attrs.ptr(), results.ptr(),
              forward_pass_name_scope.ptr()));
        });
  m.def(""TFE_Py_UID"", []() { return tensorflow::PyoOrThrow(TFE_Py_UID()); });

  // TFE_Py_Tape Logic
  m.def(""TFE_Py_TapeSetNew"", [](const py::handle& persistent,
                                const py::handle& watch_accessed_variables) {
    return tensorflow::PyoOrThrow(
        TFE_Py_TapeSetNew(persistent.ptr(), watch_accessed_variables.ptr()));
  });
  m.def(""TFE_Py_TapeSetAdd"",
        [](const py::handle& tape) { TFE_Py_TapeSetAdd(tape.ptr()); });
  m.def(""TFE_Py_TapeSetRemove"",
        [](const py::handle& tape) { TFE_Py_TapeSetRemove(tape.ptr()); });
  m.def(""TFE_Py_TapeSetStopOnThread"", &TFE_Py_TapeSetStopOnThread);
  m.def(""TFE_Py_TapeSetRestartOnThread"", &TFE_Py_TapeSetRestartOnThread);
  m.def(""TFE_Py_TapeSetIsStopped"",
        []() { return tensorflow::PyoOrThrow(TFE_Py_TapeSetIsStopped()); });
  m.def(""TFE_Py_TapeSetIsEmpty"",
        []() { return tensorflow::PyoOrThrow(TFE_Py_TapeSetIsEmpty()); });
  m.def(""TFE_Py_TapeSetShouldRecordBackprop"", [](const py::handle& tensors) {
    return tensorflow::PyoOrThrow(
        TFE_Py_TapeSetShouldRecordBackprop(tensors.ptr()));
  });
  m.def(""TFE_Py_TapeSetPossibleGradientTypes"", [](const py::handle& tensors) {
    return tensorflow::PyoOrThrow(
        TFE_Py_TapeSetPossibleGradientTypes(tensors.ptr()));
  });
  m.def(""TFE_Py_TapeSetDeleteTrace"", &TFE_Py_TapeSetDeleteTrace);
  m.def(""TFE_Py_TapeSetRecordOperation"",
        [](const py::handle& op_type, const py::handle& output_tensors,
           const py::handle& input_tensors, const py::handle& backward_function,
           const py::handle& forward_function) {
          return tensorflow::PyoOrThrow(TFE_Py_TapeSetRecordOperation(
              op_type.ptr(), output_tensors.ptr(), input_tensors.ptr(),
              backward_function.ptr(), forward_function.ptr()));
        });
  m.def(
      ""TFE_Py_TapeSetRecordOperationBackprop"",
      [](const py::handle& op_type, const py::handle& output_tensors,
         const py::handle& input_tensors, const py::handle& backward_function) {
        return tensorflow::PyoOrThrow(TFE_Py_TapeSetRecordOperationBackprop(
            op_type.ptr(), output_tensors.ptr(), input_tensors.ptr(),
            backward_function.ptr()));
      });
  m.def(
      ""TFE_Py_TapeSetRecordOperationForwardprop"",
      [](const py::handle& op_type, const py::handle& output_tensors,
         const py::handle& input_tensors, const py::handle& backward_function,
         const py::handle& forwardprop_output_indices) {
        return tensorflow::PyoOrThrow(TFE_Py_TapeSetRecordOperationForwardprop(
            op_type.ptr(), output_tensors.ptr(), input_tensors.ptr(),
            backward_function.ptr(), forwardprop_output_indices.ptr()));
      });
  m.def(""TFE_Py_TapeGradient"",
        [](const py::handle& tape, const py::handle& target,
           const py::handle& sources, const py::handle& output_gradients,
           const py::handle& sources_raw,
           const py::handle& unconnected_gradients) {
          tensorflow::Safe_TF_StatusPtr status =
              tensorflow::make_safe(TF_NewStatus());
          PyObject* output = TFE_Py_TapeGradient(
              tape.ptr(), target.ptr(), sources.ptr(), output_gradients.ptr(),
              sources_raw.ptr(), unconnected_gradients.ptr(), status.get());
          tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
          return tensorflow::PyoOrThrow(output);
        });

  m.def(""TFE_Py_TapeVariableAccessed"", [](const py::handle& variable) {
    TFE_Py_TapeVariableAccessed(variable.ptr());
  });
  m.def(""TFE_Py_TapeWatch"",
        [](const py::handle& tape, const py::handle& tensor) {
          TFE_Py_TapeWatch(tape.ptr(), tensor.ptr());
        });
  m.def(""TFE_Py_TapeWatchVariable"",
        [](const py::handle& tape, const py::handle& variable) {
          TFE_Py_TapeWatchVariable(tape.ptr(), variable.ptr());
        });
  m.def(""TFE_Py_TapeWatchedVariables"", [](const py::handle& tape) {
    return tensorflow::PyoOrThrow(TFE_Py_TapeWatchedVariables(tape.ptr()));
  });

  // TFE_Py_VariableWatcher logic.
  m.def(""TFE_Py_VariableWatcherNew"",
        []() { return tensorflow::PyoOrThrow(TFE_Py_VariableWatcherNew()); });
  m.def(""TFE_Py_VariableWatcherRemove"", [](const py::handle& variable_watcher) {
    TFE_Py_VariableWatcherRemove(variable_watcher.ptr());
  });
  m.def(""TFE_Py_VariableWatcherVariableAccessed"",
        [](const py::handle& variable) {
          TFE_Py_VariableWatcherVariableAccessed(variable.ptr());
        });
  m.def(""TFE_Py_VariableWatcherWatchedVariables"",
        [](const py::handle& variable_watcher) {
          return tensorflow::PyoOrThrow(
              TFE_Py_VariableWatcherWatchedVariables(variable_watcher.ptr()));
        });

  // TFE_Py_ForwardAccumulator logic.
  m.def(""TFE_Py_ForwardAccumulatorNew"", [](bool use_batch) {
    return tensorflow::PyoOrThrow(TFE_Py_ForwardAccumulatorNew(use_batch));
  });

  m.def(""TFE_Py_ForwardAccumulatorSetAdd"", [](const py::handle& accumulator) {
    return tensorflow::PyoOrThrow(
        TFE_Py_ForwardAccumulatorSetAdd(accumulator.ptr()));
  });
  m.def(""TFE_Py_ForwardAccumulatorSetRemove"",
        [](const py::handle& accumulator) {
          TFE_Py_ForwardAccumulatorSetRemove(accumulator.ptr());
        });

  m.def(""TFE_Py_ForwardAccumulatorWatch"",
        [](const py::handle& accumulator, const py::handle& tensor,
           const py::handle& tangent) {
          TFE_Py_ForwardAccumulatorWatch(accumulator.ptr(), tensor.ptr(),
                                         tangent.ptr());
        });
  m.def(""TFE_Py_ForwardAccumulatorJVP"",
        [](const py::handle& accumulator, const py::handle& tensor) {
          return tensorflow::PyoOrThrow(
              TFE_Py_ForwardAccumulatorJVP(accumulator.ptr(), tensor.ptr()));
        });
  m.def(""TFE_Py_ForwardAccumulatorPushState"", []() {
    return tensorflow::PyoOrThrow(TFE_Py_ForwardAccumulatorPushState());
  });
  m.def(""TFE_Py_ForwardAccumulatorPopState"", []() {
    return tensorflow::PyoOrThrow(TFE_Py_ForwardAccumulatorPopState());
  });
  m.def(""TFE_Py_PackJVPs"", [](const py::handle& tensors) {
    return tensorflow::PyoOrThrow(TFE_Py_PackJVPs(tensors.ptr()));
  });

  // TFE_ContextOptions Logic
  m.def(""TFE_NewContextOptions"", &TFE_NewContextOptions,
        py::return_value_policy::reference);
  m.def(""TFE_ContextOptionsSetConfig"", [](TFE_ContextOptions* options,
                                          py::bytes proto) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    tensorflow::Safe_TF_BufferPtr buf =
        tensorflow::make_safe(tensorflow::ProtoStringToTFBuffer(proto.ptr()));
    TFE_ContextOptionsSetConfig(options, buf.get()->data, buf.get()->length,
                                status.get());
    tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
  });
  m.def(""TFE_ContextOptionsSetDevicePlacementPolicy"",
        &TFE_ContextOptionsSetDevicePlacementPolicy);
  m.def(""TFE_ContextOptionsSetLazyRemoteInputsCopy"",
        &TFE_ContextOptionsSetLazyRemoteInputsCopy);
  m.def(""TFE_ContextOptionsSetTfrt"", &TFE_ContextOptionsSetTfrt);
  m.def(""TFE_ContextOptionsSetAsync"", &TFE_ContextOptionsSetAsync);
  m.def(""TFE_DeleteContextOptions"", &TFE_DeleteContextOptions,
        py::return_value_policy::reference);

  // TFE_Py_TensorShape Logic
  m.def(""TFE_Py_TensorShapeSlice"",
        [](const py::handle& tensors, int slice_dim) {
          return tensorflow::PyoOrThrow(
              TFE_Py_TensorShapeSlice(tensors.ptr(), slice_dim));
        });
  m.def(""TFE_Py_TensorShapeOnDevice"", [](const py::handle& tensors,
                                         int slice_dim) {
    return tensorflow::PyoOrThrow(TFE_Py_TensorShapeOnDevice(tensors.ptr()));
  });
  m.def(""TFE_Py_EnableInteractivePythonLogging"",
        &TFE_Py_EnableInteractivePythonLogging);

  // Additional Context Logic
  m.def(""TFE_Py_SetEagerContext"", [](const py::handle& o) {
    return tensorflow::PyoOrThrow(TFE_Py_SetEagerContext(o.ptr()));
  });
  m.def(""TFE_ContextStartStep"", [](py::handle& o) {
    TFE_ContextStartStep(tensorflow::InputTFE_Context(o.ptr()));
  });
  m.def(""TFE_ContextEndStep"", [](py::handle& o) {
    TFE_ContextEndStep(tensorflow::InputTFE_Context(o.ptr()));
  });
  m.def(""TFE_Py_RegisterVSpace"", [](const py::handle& o) {
    return tensorflow::PyoOrThrow(TFE_Py_RegisterVSpace(o.ptr()));
  });
  m.def(""TFE_Py_EncodeArg"",
        [](const py::handle& o, bool include_tensor_ranks_only) {
          return tensorflow::PyoOrThrow(
              TFE_Py_EncodeArg(o.ptr(), include_tensor_ranks_only));
        });
  m.def(""TFE_EnableCollectiveOps"", [](const py::handle& ctx, py::bytes proto) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    tensorflow::Safe_TF_BufferPtr buf =
        tensorflow::make_safe(tensorflow::ProtoStringToTFBuffer(proto.ptr()));
    TFE_EnableCollectiveOps(tensorflow::InputTFE_Context(ctx), buf.get()->data,
                            buf.get()->length, status.get());
    tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
  });
  m.def(""TFE_AbortCollectiveOps"", [](const py::handle& ctx, int code,
                                     const char* message) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    TF_SetStatus(status.get(), static_cast<TF_Code>(code), message);
    TFE_AbortCollectiveOps(tensorflow::InputTFE_Context(ctx), status.get());
  });
  m.def(""TFE_CollectiveOpsCheckPeerHealth"",
        [](const py::handle& ctx, const char* task) {
          tensorflow::Safe_TF_StatusPtr status =
              tensorflow::make_safe(TF_NewStatus());
          TFE_CollectiveOpsCheckPeerHealth(tensorflow::InputTFE_Context(ctx),
                                           task, status.get());
          tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        });
  m.def(""TF_ListPhysicalDevices"", &tensorflow::TF_ListPhysicalDevices);
  m.def(""TF_GetDeviceDetails"", &tensorflow::TF_GetDeviceDetails);
  m.def(""TF_DeleteDeviceList"", &TF_DeleteDeviceList,
        py::return_value_policy::reference);
  m.def(""TF_DeviceListCount"", &TF_DeviceListCount);
  m.def(""TF_DeviceListName"", [](const TF_DeviceList* list, int index) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    auto output = TF_DeviceListName(list, index, status.get());
    tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
    return output;
  });
  m.def(""TF_DeviceListType"", [](const TF_DeviceList* list, int index) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    auto output = TF_DeviceListType(list, index, status.get());
    tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
    return output;
  });

  m.def(""TF_PickUnusedPortOrDie"", &TF_PickUnusedPortOrDie);

  // TFE_MonitoringCounter Logic
  m.def(""TFE_MonitoringCounterCellIncrementBy"",
        &TFE_MonitoringCounterCellIncrementBy);
  m.def(""TFE_MonitoringCounterCellValue"", &TFE_MonitoringCounterCellValue);
  m.def(
      ""TFE_MonitoringNewCounter0"",
      [](const char* name, const char* description) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        auto output =
            TFE_MonitoringNewCounter0(name, status.get(), description);
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return output;
      },
      py::return_value_policy::reference);
  m.def(""TFE_MonitoringDeleteCounter0"", &TFE_MonitoringDeleteCounter0,
        py::return_value_policy::reference);
  m.def(""TFE_MonitoringGetCellCounter0"", &TFE_MonitoringGetCellCounter0,
        py::return_value_policy::reference);
  m.def(
      ""TFE_MonitoringNewCounter1"",
      [](const char* name, const char* description, const char* label1) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        auto output =
            TFE_MonitoringNewCounter1(name, status.get(), description, label1);
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return output;
      },
      py::return_value_policy::reference);
  m.def(""TFE_MonitoringDeleteCounter1"", &TFE_MonitoringDeleteCounter1,
        py::return_value_policy::reference);
  m.def(""TFE_MonitoringGetCellCounter1"", &TFE_MonitoringGetCellCounter1,
        py::return_value_policy::reference);
  m.def(
      ""TFE_MonitoringNewCounter2"",
      [](const char* name, const char* description, const char* label1,
         const char* label2) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        auto output = TFE_MonitoringNewCounter2(name, status.get(), description,
                                                label1, label2);
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return output;
      },
      py::return_value_policy::reference);
  m.def(""TFE_MonitoringDeleteCounter2"", &TFE_MonitoringDeleteCounter2,
        py::return_value_policy::reference);
  m.def(""TFE_MonitoringGetCellCounter2"", &TFE_MonitoringGetCellCounter2,
        py::return_value_policy::reference);

  // TFE_MonitoringIntGauge Logic
  m.def(""TFE_MonitoringIntGaugeCellSet"", &TFE_MonitoringIntGaugeCellSet);
  m.def(""TFE_MonitoringIntGaugeCellValue"", &TFE_MonitoringIntGaugeCellValue);
  m.def(
      ""TFE_MonitoringNewIntGauge0"",
      [](const char* name, const char* description) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        auto output =
            TFE_MonitoringNewIntGauge0(name, status.get(), description);
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return output;
      },
      py::return_value_policy::reference);
  m.def(""TFE_MonitoringDeleteIntGauge0"", &TFE_MonitoringDeleteIntGauge0,
        py::return_value_policy::reference);
  m.def(""TFE_MonitoringGetCellIntGauge0"", &TFE_MonitoringGetCellIntGauge0,
        py::return_value_policy::reference);
  m.def(
      ""TFE_MonitoringNewIntGauge1"",
      [](const char* name, const char* description, const char* label1) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        auto output =
            TFE_MonitoringNewIntGauge1(name, status.get(), description, label1);
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return output;
      },
      py::return_value_policy::reference);
  m.def(""TFE_MonitoringDeleteIntGauge1"", &TFE_MonitoringDeleteIntGauge1,
        py::return_value_policy::reference);
  m.def(""TFE_MonitoringGetCellIntGauge1"", &TFE_MonitoringGetCellIntGauge1,
        py::return_value_policy::reference);
  m.def(
      ""TFE_MonitoringNewIntGauge2"",
      [](const char* name, const char* description, const char* label1,
         const char* label2) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        auto output = TFE_MonitoringNewIntGauge2(name, status.get(),
                                                 description, label1, label2);
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return output;
      },
      py::return_value_policy::reference);
  m.def(""TFE_MonitoringDeleteIntGauge2"", &TFE_MonitoringDeleteIntGauge2,
        py::return_value_policy::reference);
  m.def(""TFE_MonitoringGetCellIntGauge2"", &TFE_MonitoringGetCellIntGauge2,
        py::return_value_policy::reference);
  m.def(""TFE_MonitoringStringGaugeCellSet"", &TFE_MonitoringStringGaugeCellSet);
  m.def(""TFE_MonitoringStringGaugeCellValue"",
        &TFE_MonitoringStringGaugeCellValue);
  m.def(
      ""TFE_MonitoringNewStringGauge0"",
      [](const char* name, const char* description) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        auto output =
            TFE_MonitoringNewStringGauge0(name, status.get(), description);
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return output;
      },
      py::return_value_policy::reference);

  // TFE_MonitoringStringGauge Logic
  m.def(""TFE_MonitoringDeleteStringGauge0"", &TFE_MonitoringDeleteStringGauge0);
  m.def(""TFE_MonitoringGetCellStringGauge0"", &TFE_MonitoringGetCellStringGauge0,
        py::return_value_policy::reference);
  m.def(
      ""TFE_MonitoringNewStringGauge1"",
      [](const char* name, const char* description, const char* label1) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        auto output = TFE_MonitoringNewStringGauge1(name, status.get(),
                                                    description, label1);
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return output;
      },
      py::return_value_policy::reference);
  m.def(""TFE_MonitoringDeleteStringGauge1"", &TFE_MonitoringDeleteStringGauge1);
  m.def(""TFE_MonitoringGetCellStringGauge1"", &TFE_MonitoringGetCellStringGauge1,
        py::return_value_policy::reference);
  m.def(
      ""TFE_MonitoringNewStringGauge2"",
      [](const char* name, const char* description, const char* label1,
         const char* label2) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        auto output = TFE_MonitoringNewStringGauge2(
            name, status.get(), description, label1, label2);
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return output;
      },
      py::return_value_policy::reference);
  m.def(""TFE_MonitoringDeleteStringGauge2"", &TFE_MonitoringDeleteStringGauge2);
  m.def(""TFE_MonitoringGetCellStringGauge2"", &TFE_MonitoringGetCellStringGauge2,
        py::return_value_policy::reference);

  // TFE_MonitoringBoolGauge Logic
  m.def(""TFE_MonitoringBoolGaugeCellSet"", &TFE_MonitoringBoolGaugeCellSet);
  m.def(""TFE_MonitoringBoolGaugeCellValue"", &TFE_MonitoringBoolGaugeCellValue);
  m.def(
      ""TFE_MonitoringNewBoolGauge0"",
      [](const char* name, const char* description) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        auto output =
            TFE_MonitoringNewBoolGauge0(name, status.get(), description);
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return output;
      },
      py::return_value_policy::reference);
  m.def(""TFE_MonitoringDeleteBoolGauge0"", &TFE_MonitoringDeleteBoolGauge0,
        py::return_value_policy::reference);
  m.def(""TFE_MonitoringGetCellBoolGauge0"", &TFE_MonitoringGetCellBoolGauge0,
        py::return_value_policy::reference);
  m.def(
      ""TFE_MonitoringNewBoolGauge1"",
      [](const char* name, const char* description, const char* label1) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        auto output = TFE_MonitoringNewBoolGauge1(name, status.get(),
                                                  description, label1);
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return output;
      },
      py::return_value_policy::reference);
  m.def(""TFE_MonitoringDeleteBoolGauge1"", &TFE_MonitoringDeleteBoolGauge1,
        py::return_value_policy::reference);
  m.def(""TFE_MonitoringGetCellBoolGauge1"", &TFE_MonitoringGetCellBoolGauge1,
        py::return_value_policy::reference);
  m.def(
      ""TFE_MonitoringNewBoolGauge2"",
      [](const char* name, const char* description, const char* label1,
         const char* label2) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        auto output = TFE_MonitoringNewBoolGauge2(name, status.get(),
                                                  description, label1, label2);
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return output;
      },
      py::return_value_policy::reference);
  m.def(""TFE_MonitoringDeleteBoolGauge2"", &TFE_MonitoringDeleteBoolGauge2,
        py::return_value_policy::reference);
  m.def(""TFE_MonitoringGetCellBoolGauge2"", &TFE_MonitoringGetCellBoolGauge2,
        py::return_value_policy::reference);

  // TFE_MonitoringSampler Logic
  m.def(""TFE_MonitoringSamplerCellAdd"", &TFE_MonitoringSamplerCellAdd);
  m.def(""TFE_MonitoringSamplerCellValue"", &TFE_MonitoringSamplerCellValue);
  m.def(""TFE_MonitoringNewExponentialBuckets"",
        &TFE_MonitoringNewExponentialBuckets,
        py::return_value_policy::reference);
  m.def(""TFE_MonitoringDeleteBuckets"", &TFE_MonitoringDeleteBuckets,
        py::return_value_policy::reference);
  m.def(
      ""TFE_MonitoringNewSampler0"",
      [](const char* name, TFE_MonitoringBuckets* buckets,
         const char* description) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        auto output =
            TFE_MonitoringNewSampler0(name, buckets, status.get(), description);
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return output;
      },
      py::return_value_policy::reference);
  m.def(""TFE_MonitoringDeleteSampler0"", &TFE_MonitoringDeleteSampler0,
        py::return_value_policy::reference);
  m.def(""TFE_MonitoringGetCellSampler0"", &TFE_MonitoringGetCellSampler0,
        py::return_value_policy::reference);
  m.def(
      ""TFE_MonitoringNewSampler1"",
      [](const char* name, TFE_MonitoringBuckets* buckets,
         const char* description, const char* label1) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        auto output = TFE_MonitoringNewSampler1(name, buckets, status.get(),
                                                description, label1);
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return output;
      },
      py::return_value_policy::reference);
  m.def(""TFE_MonitoringDeleteSampler1"", &TFE_MonitoringDeleteSampler1,
        py::return_value_policy::reference);
  m.def(""TFE_MonitoringGetCellSampler1"", &TFE_MonitoringGetCellSampler1,
        py::return_value_policy::reference);
  m.def(
      ""TFE_MonitoringNewSampler2"",
      [](const char* name, TFE_MonitoringBuckets* buckets,
         const char* description, const char* label1, const char* label2) {
        tensorflow::Safe_TF_StatusPtr status =
            tensorflow::make_safe(TF_NewStatus());
        auto output = TFE_MonitoringNewSampler2(name, buckets, status.get(),
                                                description, label1, label2);
        tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
        return output;
      },
      py::return_value_policy::reference);
  m.def(""TFE_MonitoringDeleteSampler2"", &TFE_MonitoringDeleteSampler2,
        py::return_value_policy::reference);
  m.def(""TFE_MonitoringGetCellSampler2"", &TFE_MonitoringGetCellSampler2,
        py::return_value_policy::reference);

  // TFE_CancellationManager Logic
  m.def(""TFE_NewCancellationManager"", &TFE_NewCancellationManager,
        py::return_value_policy::reference);
  m.def(""TFE_CancellationManagerIsCancelled"",
        &TFE_CancellationManagerIsCancelled);
  m.def(""TFE_CancellationManagerStartCancel"",
        &TFE_CancellationManagerStartCancel);
  m.def(""TFE_DeleteCancellationManager"", &TFE_DeleteCancellationManager,
        py::return_value_policy::reference);

  m.def(""TFE_ClearScalarCache"", &tensorflow::TFE_ClearScalarCache);

  // Util buffer helper functions
  m.def(""TF_NewBufferFromString"", &TF_NewBufferFromString,
        py::return_value_policy::reference);

  // DLPack functions
  m.def(""TFE_ToDlpackCapsule"", [](py::handle& o) {
    PyObject* eager_tensor_pyobject_ptr = o.ptr();
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());

    if (!EagerTensor_CheckExact(eager_tensor_pyobject_ptr)) {
      status->status = tensorflow::errors::InvalidArgument(
          ""The argument to `to_dlpack` must be a TF tensor, not Python object"");
      tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
    }

    TFE_TensorHandle* thandle = EagerTensor_Handle(eager_tensor_pyobject_ptr);
    void* dlm_ptr = tensorflow::TFE_HandleToDLPack(thandle, status.get());
    tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());

    py::capsule capsule(
        dlm_ptr, tensorflow::kDlTensorCapsuleName, [](PyObject* capsule) {
          if (PyCapsule_IsValid(capsule, tensorflow::kDlTensorCapsuleName)) {
            void* dlm_rptr =
                PyCapsule_GetPointer(capsule, tensorflow::kDlTensorCapsuleName);
            if (dlm_rptr) {
              tensorflow::TFE_CallDLManagedTensorDeleter(dlm_rptr);
              PyCapsule_SetDestructor(capsule, nullptr);
            }
          }
        });
    return capsule;
  });

  m.def(""TFE_FromDlpackCapsule"", [](const py::capsule& pycapsule,
                                    const py::handle& context) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    if (absl::string_view(pycapsule.name()) !=
        tensorflow::kDlTensorCapsuleName) {
      status->status = tensorflow::errors::InvalidArgument(
          ""DLPack tensor must be a capsule with name \\""dltensor\\"", got \\""%s\\"". ""
          ""Note that a DLPack tensor may be consumed at most once."",
          absl::string_view(pycapsule.name()));
      tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
    }

    TFE_TensorHandle* thandle = tensorflow::TFE_HandleFromDLPack(
        pycapsule, status.get(), tensorflow::InputTFE_Context(context));

    tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());

    PyCapsule_SetName(pycapsule.ptr(), ""used_dltensor"");
    PyCapsule_SetDestructor(pycapsule.ptr(), nullptr);

    PyObject* pyhandle = EagerTensorFromHandle(thandle);
    return tensorflow::PyoOrThrow(pyhandle);
  });

  m.def(""TFE_Py_RegisterCustomDevice"", [](const py::handle& context,
                                          const py::capsule& device,
                                          const char* device_name,
                                          const py::capsule& device_info) {
    tensorflow::Safe_TF_StatusPtr status =
        tensorflow::make_safe(TF_NewStatus());
    if (absl::string_view(device.name()) != ""TFE_CustomDevice"") {
      status->status = tensorflow::errors::InvalidArgument(
          ""Expected a capsule named 'TFE_CustomDevice' for the `device` ""
          ""argument, got "",
          absl::string_view(device.name()));
      tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
    }
    if (absl::string_view(device_info.name()) !=
        ""TFE_CustomDevice_DeviceInfo"") {
      status->status = tensorflow::errors::InvalidArgument(
          ""Expected a capsule named 'TFE_CustomDevice_DeviceInfo' for ""
          ""the `device_info` argument, got "",
          absl::string_view(device_info.name()));
      tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
    }
    // TFE_RegisterCustomDevice takes ownership
    PyCapsule_SetDestructor(device_info.ptr(), nullptr);
    TFE_RegisterCustomDevice(
        tensorflow::InputTFE_Context(context),
        *reinterpret_cast<TFE_CustomDevice*>(
            PyCapsule_GetPointer(device.ptr(), ""TFE_CustomDevice"")),
        device_name,
        PyCapsule_GetPointer(device_info.ptr(), ""TFE_CustomDevice_DeviceInfo""),
        status.get());
    tensorflow::MaybeRaiseRegisteredFromTFStatus(status.get());
  });

  py::class_<EagerContextThreadLocalDataWrapper>(m,
                                                 ""EagerContextThreadLocalData"")
      .def(py::init<py::handle, py::handle, py::handle>(),
           py::arg(""py_eager_context""), py::arg(""is_eager""),
           py::arg(""device_spec""))
      .def_property(""is_eager"",
                    &EagerContextThreadLocalDataWrapper::get_is_eager,
                    &EagerContextThreadLocalDataWrapper::set_is_eager)
      .def_property(
          ""invoking_op_callbacks"",
          &EagerContextThreadLocalDataWrapper::get_invoking_op_callbacks,
          &EagerContextThreadLocalDataWrapper::set_invoking_op_callbacks)
      .def_property(""device_name"",
                    &EagerContextThreadLocalDataWrapper::get_device_name,
                    &EagerContextThreadLocalDataWrapper::set_device_name)
      .def_property(""scope_name"",
                    &EagerContextThreadLocalDataWrapper::get_scope_name,
                    &EagerContextThreadLocalDataWrapper::set_scope_name)
      .def_property(""device_spec"",
                    &EagerContextThreadLocalDataWrapper::get_device_spec,
                    &EagerContextThreadLocalDataWrapper::set_device_spec)
      .def_property(
          ""function_call_options"",
          &EagerContextThreadLocalDataWrapper::get_function_call_options,
          &EagerContextThreadLocalDataWrapper::set_function_call_options)
      .def_property(""executor"",
                    &EagerContextThreadLocalDataWrapper::get_executor,
                    &EagerContextThreadLocalDataWrapper::set_executor)
      .def_property(""op_callbacks"",
                    &EagerContextThreadLocalDataWrapper::get_op_callbacks,
                    &EagerContextThreadLocalDataWrapper::set_op_callbacks);

  // C API Enum

  py::enum_<TFE_ContextDevicePlacementPolicy>(
      m, ""TFE_ContextDevicePlacementPolicy"")
      .value(""TFE_DEVICE_PLACEMENT_EXPLICIT"", TFE_DEVICE_PLACEMENT_EXPLICIT)
      .value(""TFE_DEVICE_PLACEMENT_WARN"", TFE_DEVICE_PLACEMENT_WARN)
      .value(""TFE_DEVICE_PLACEMENT_SILENT"", TFE_DEVICE_PLACEMENT_SILENT)
      .value(""TFE_DEVICE_PLACEMENT_SILENT_FOR_INT32"",
             TFE_DEVICE_PLACEMENT_SILENT_FOR_INT32)
      .export_values();

  py::enum_<TF_AttrType>(m, ""TF_AttrType"")
      .value(""TF_ATTR_STRING"", TF_ATTR_STRING)
      .value(""TF_ATTR_INT"", TF_ATTR_INT)
      .value(""TF_ATTR_FLOAT"", TF_ATTR_FLOAT)
      .value(""TF_ATTR_BOOL"", TF_ATTR_BOOL)
      .value(""TF_ATTR_TYPE"", TF_ATTR_TYPE)
      .value(""TF_ATTR_SHAPE"", TF_ATTR_SHAPE)
      .value(""TF_ATTR_TENSOR"", TF_ATTR_TENSOR)
      .value(""TF_ATTR_PLACEHOLDER"", TF_ATTR_PLACEHOLDER)
      .value(""TF_ATTR_FUNC"", TF_ATTR_FUNC)
      .export_values();
};
",16371,True,3533.489428854389,median
"// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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.

#include ""kudu/client/client.h""

#include <algorithm>
#include <cstdint>
#include <cstdlib>
#include <functional>
#include <map>
#include <mutex>
#include <ostream>
#include <set>
#include <string>
#include <vector>

#include <boost/optional/optional.hpp>
#include <glog/logging.h>
#include <google/protobuf/stubs/common.h>

#include ""kudu/client/callbacks.h""
#include ""kudu/client/client-internal.h""
#include ""kudu/client/client.pb.h""
#include ""kudu/client/client_builder-internal.h""
#include ""kudu/client/columnar_scan_batch.h""
#include ""kudu/client/error-internal.h""
#include ""kudu/client/error_collector.h""
#include ""kudu/client/master_proxy_rpc.h""
#include ""kudu/client/meta_cache.h""
#include ""kudu/client/partitioner-internal.h""
#include ""kudu/client/replica-internal.h""
#include ""kudu/client/row_result.h""
#include ""kudu/client/scan_batch.h""
#include ""kudu/client/scan_configuration.h""
#include ""kudu/client/scan_predicate-internal.h""
#include ""kudu/client/scan_token-internal.h""
#include ""kudu/client/scanner-internal.h""
#include ""kudu/client/session-internal.h""
#include ""kudu/client/table-internal.h""
#include ""kudu/client/table_alterer-internal.h""
#include ""kudu/client/table_creator-internal.h""
#include ""kudu/client/table_statistics-internal.h""
#include ""kudu/client/tablet-internal.h""
#include ""kudu/client/tablet_server-internal.h""
#include ""kudu/client/value.h""
#include ""kudu/client/write_op.h""
#include ""kudu/common/common.pb.h""
#include ""kudu/common/partial_row.h""
#include ""kudu/common/partition.h""
#include ""kudu/common/partition_pruner.h""
#include ""kudu/common/row_operations.h""
#include ""kudu/common/scan_spec.h""
#include ""kudu/common/schema.h""
#include ""kudu/common/wire_protocol.h""
#include ""kudu/common/wire_protocol.pb.h""
#include ""kudu/consensus/metadata.pb.h""
#include ""kudu/gutil/casts.h""
#include ""kudu/gutil/ref_counted.h""
#include ""kudu/gutil/stl_util.h""
#include ""kudu/gutil/strings/numbers.h""
#include ""kudu/gutil/strings/substitute.h""
#include ""kudu/master/master.pb.h""
#include ""kudu/master/master.proxy.h""
#include ""kudu/rpc/messenger.h""
#include ""kudu/rpc/request_tracker.h""
#include ""kudu/rpc/response_callback.h""
#include ""kudu/rpc/rpc.h""
#include ""kudu/rpc/rpc_controller.h""
#include ""kudu/rpc/sasl_common.h""
#include ""kudu/rpc/user_credentials.h""
#include ""kudu/security/cert.h""
#include ""kudu/security/openssl_util.h""
#include ""kudu/security/tls_context.h""
#include ""kudu/security/token.pb.h""
#include ""kudu/tserver/tserver.pb.h""
#include ""kudu/tserver/tserver_service.proxy.h""
#include ""kudu/util/async_util.h""
#include ""kudu/util/debug-util.h""
#include ""kudu/util/init.h""
#include ""kudu/util/logging.h""
#include ""kudu/util/logging_callback.h""
#include ""kudu/util/monotime.h""
#include ""kudu/util/net/net_util.h""
#include ""kudu/util/oid_generator.h""
#include ""kudu/util/scoped_cleanup.h""
#include ""kudu/util/version_info.h""

namespace kudu {
class BlockBloomFilter;
}  // namespace kudu

using kudu::consensus::RaftPeerPB;
using kudu::master::AlterTableRequestPB;
using kudu::master::AlterTableResponsePB;
using kudu::master::CreateTableRequestPB;
using kudu::master::CreateTableResponsePB;
using kudu::master::DeleteTableRequestPB;
using kudu::master::DeleteTableResponsePB;
using kudu::master::GetTableSchemaRequestPB;
using kudu::master::GetTableSchemaResponsePB;
using kudu::master::GetTableStatisticsRequestPB;
using kudu::master::GetTableStatisticsResponsePB;
using kudu::master::GetTabletLocationsRequestPB;
using kudu::master::GetTabletLocationsResponsePB;
using kudu::master::ListTablesRequestPB;
using kudu::master::ListTablesResponsePB;
using kudu::master::ListTabletServersRequestPB;
using kudu::master::ListTabletServersResponsePB;
using kudu::master::ListTabletServersResponsePB_Entry;
using kudu::master::MasterServiceProxy;
using kudu::master::TSInfoPB;
using kudu::master::TableIdentifierPB;
using kudu::master::TabletLocationsPB;
using kudu::rpc::BackoffType;
using kudu::rpc::Messenger;
using kudu::rpc::MessengerBuilder;
using kudu::rpc::RpcController;
using kudu::rpc::UserCredentials;
using kudu::tserver::ScanResponsePB;
using std::map;
using std::set;
using std::string;
using std::unique_ptr;
using std::vector;
using strings::Substitute;

MAKE_ENUM_LIMITS(kudu::client::KuduSession::FlushMode,
                 kudu::client::KuduSession::AUTO_FLUSH_SYNC,
                 kudu::client::KuduSession::MANUAL_FLUSH);

MAKE_ENUM_LIMITS(kudu::client::KuduSession::ExternalConsistencyMode,
                 kudu::client::KuduSession::CLIENT_PROPAGATED,
                 kudu::client::KuduSession::COMMIT_WAIT);

MAKE_ENUM_LIMITS(kudu::client::KuduScanner::ReadMode,
                 kudu::client::KuduScanner::READ_LATEST,
                 kudu::client::KuduScanner::READ_YOUR_WRITES);

MAKE_ENUM_LIMITS(kudu::client::KuduScanner::OrderMode,
                 kudu::client::KuduScanner::UNORDERED,
                 kudu::client::KuduScanner::ORDERED);

struct tm;

namespace kudu {

class simple_spinlock;

namespace client {

class ResourceMetrics;

using internal::AsyncLeaderMasterRpc;
using internal::MetaCache;
using sp::shared_ptr;

const char* kVerboseEnvVar = ""KUDU_CLIENT_VERBOSE"";

#if defined(kudu_client_exported_EXPORTS)
static const char* kProgName = ""kudu_client"";

// We need to reroute all logging to stderr when the client library is
// loaded. GoogleOnceInit() can do that, but there are multiple entry
// points into the client code, and it'd need to be called in each one.
// So instead, let's use a constructor function.
//
// This is restricted to the exported client builds only. In case of linking
// with non-exported kudu client library, logging must be initialized
// from the main() function of the corresponding binary: usually, that's done
// by calling InitGoogleLoggingSafe(argv[0]).
__attribute__((constructor))
static void InitializeBasicLogging() {
  InitGoogleLoggingSafeBasic(kProgName);

  SetVerboseLevelFromEnvVar();
}
#endif

// Set Client logging verbose level from environment variable.
void SetVerboseLevelFromEnvVar() {
  int32_t level = 0; // this is the default logging level;
  const char* env_verbose_level = std::getenv(kVerboseEnvVar);
  if (env_verbose_level != nullptr) {
     if (safe_strto32(env_verbose_level, &level) && (level >= 0)) {
       SetVerboseLogLevel(level);
     } else {
       LOG(WARNING) << ""Invalid verbose level from environment variable "" << kVerboseEnvVar;
     }
  }
}

// Adapts between the internal LogSeverity and the client's KuduLogSeverity.
static void LoggingAdapterCB(KuduLoggingCallback* user_cb,
                             LogSeverity severity,
                             const char* filename,
                             int line_number,
                             const struct ::tm* time,
                             const char* message,
                             size_t message_len) {
  KuduLogSeverity client_severity;
  switch (severity) {
    case kudu::SEVERITY_INFO:
      client_severity = SEVERITY_INFO;
      break;
    case kudu::SEVERITY_WARNING:
      client_severity = SEVERITY_WARNING;
      break;
    case kudu::SEVERITY_ERROR:
      client_severity = SEVERITY_ERROR;
      break;
    case kudu::SEVERITY_FATAL:
      client_severity = SEVERITY_FATAL;
      break;
    default:
      LOG(FATAL) << ""Unknown Kudu log severity: "" << severity;
  }
  user_cb->Run(client_severity, filename, line_number, time,
               message, message_len);
}

void InstallLoggingCallback(KuduLoggingCallback* cb) {
  RegisterLoggingCallback(
      [=](LogSeverity severity, const char* filename, int line_number,
          const struct ::tm* time, const char* message, size_t message_len) {
        LoggingAdapterCB(cb, severity, filename, line_number, time, message, message_len);
      });
}

void UninstallLoggingCallback() {
  UnregisterLoggingCallback();
}

void SetVerboseLogLevel(int level) {
  FLAGS_v = level;
}

Status SetInternalSignalNumber(int signum) {
  return SetStackTraceSignal(signum);
}

Status DisableSaslInitialization() {
  return kudu::rpc::DisableSaslInitialization();
}

Status DisableOpenSSLInitialization() {
  return kudu::security::DisableOpenSSLInitialization();
}

string GetShortVersionString() {
  return VersionInfo::GetVersionInfo();
}

string GetAllVersionInfo() {
  return VersionInfo::GetAllVersionInfo();
}

KuduClientBuilder::KuduClientBuilder()
  : data_(new KuduClientBuilder::Data()) {
}

KuduClientBuilder::~KuduClientBuilder() {
  delete data_;
}

KuduClientBuilder& KuduClientBuilder::clear_master_server_addrs() {
  data_->master_server_addrs_.clear();
  return *this;
}

KuduClientBuilder& KuduClientBuilder::master_server_addrs(const vector<string>& addrs) {
  for (const string& addr : addrs) {
    data_->master_server_addrs_.push_back(addr);
  }
  return *this;
}

KuduClientBuilder& KuduClientBuilder::add_master_server_addr(const string& addr) {
  data_->master_server_addrs_.push_back(addr);
  return *this;
}

KuduClientBuilder& KuduClientBuilder::default_admin_operation_timeout(const MonoDelta& timeout) {
  data_->default_admin_operation_timeout_ = timeout;
  return *this;
}

KuduClientBuilder& KuduClientBuilder::default_rpc_timeout(const MonoDelta& timeout) {
  data_->default_rpc_timeout_ = timeout;
  return *this;
}

KuduClientBuilder& KuduClientBuilder::import_authentication_credentials(string authn_creds) {
  data_->authn_creds_ = std::move(authn_creds);
  return *this;
}

KuduClientBuilder& KuduClientBuilder::num_reactors(int num_reactors) {
  data_->num_reactors_ = num_reactors;
  return *this;
}

namespace {
Status ImportAuthnCreds(const string& authn_creds,
                        Messenger* messenger,
                        UserCredentials* user_credentials) {
  AuthenticationCredentialsPB pb;
  if (!pb.ParseFromString(authn_creds)) {
    return Status::InvalidArgument(""invalid authentication data"");
  }
  if (pb.has_authn_token()) {
    const auto& tok = pb.authn_token();
    if (!tok.has_token_data() ||
        !tok.has_signature() ||
        !tok.has_signing_key_seq_num()) {
      return Status::InvalidArgument(""invalid authentication token"");
    }
    messenger->set_authn_token(tok);
  }
  if (pb.has_real_user()) {
    user_credentials->set_real_user(pb.real_user());
  }
  for (const string& cert_der : pb.ca_cert_ders()) {
    security::Cert cert;
    RETURN_NOT_OK_PREPEND(cert.FromString(cert_der, security::DataFormat::DER),
                          ""could not import CA cert"");
    RETURN_NOT_OK_PREPEND(messenger->mutable_tls_context()->AddTrustedCertificate(cert),
                          ""could not trust CA cert"");
  }
  return Status::OK();
}
} // anonymous namespace

Status KuduClientBuilder::Build(shared_ptr<KuduClient>* client) {
  RETURN_NOT_OK(CheckCPUFlags());

  // Init messenger.
  MessengerBuilder builder(""client"");
  if (data_->num_reactors_) {
    builder.set_num_reactors(data_->num_reactors_.get());
  }
  std::shared_ptr<Messenger> messenger;
  RETURN_NOT_OK(builder.Build(&messenger));
  UserCredentials user_credentials;

  // Parse and import the provided authn data, if any.
  if (!data_->authn_creds_.empty()) {
    RETURN_NOT_OK(ImportAuthnCreds(data_->authn_creds_, messenger.get(), &user_credentials));
  }
  if (!user_credentials.has_real_user()) {
    // If there are no authentication credentials, then set the real user to the
    // currently logged-in user.
    RETURN_NOT_OK(user_credentials.SetLoggedInRealUser());
  }

  shared_ptr<KuduClient> c(new KuduClient);
  c->data_->messenger_ = std::move(messenger);
  c->data_->user_credentials_ = std::move(user_credentials);
  c->data_->master_server_addrs_ = data_->master_server_addrs_;
  c->data_->default_admin_operation_timeout_ = data_->default_admin_operation_timeout_;
  c->data_->default_rpc_timeout_ = data_->default_rpc_timeout_;

  // Let's allow for plenty of time for discovering the master the first
  // time around.
  MonoTime deadline = MonoTime::Now() + c->default_admin_operation_timeout();
  RETURN_NOT_OK_PREPEND(c->data_->ConnectToCluster(c.get(), deadline),
                        ""Could not connect to the cluster"");

  c->data_->meta_cache_.reset(new MetaCache(c.get(), data_->replica_visibility_));

  // Init local host names used for locality decisions.
  RETURN_NOT_OK_PREPEND(c->data_->InitLocalHostNames(),
                        ""Could not determine local host names"");

  c->data_->request_tracker_ = new rpc::RequestTracker(c->data_->client_id_);

  client->swap(c);
  return Status::OK();
}

KuduClient::KuduClient()
  : data_(new KuduClient::Data()) {
  static ObjectIdGenerator oid_generator;
  data_->client_id_ = oid_generator.Next();
}

KuduClient::~KuduClient() {
  delete data_;
}

KuduTableCreator* KuduClient::NewTableCreator() {
  return new KuduTableCreator(this);
}

Status KuduClient::IsCreateTableInProgress(const string& table_name,
                                           bool* create_in_progress) {
  MonoTime deadline = MonoTime::Now() + default_admin_operation_timeout();
  TableIdentifierPB table;
  table.set_table_name(table_name);
  return data_->IsCreateTableInProgress(this, std::move(table), deadline,
                                        create_in_progress);
}

Status KuduClient::DeleteTable(const string& table_name) {
  return DeleteTableInCatalogs(table_name, true);
}

Status KuduClient::DeleteTableInCatalogs(const string& table_name,
                                         bool modify_external_catalogs) {
  MonoTime deadline = MonoTime::Now() + default_admin_operation_timeout();
  return data_->DeleteTable(this, table_name, deadline, modify_external_catalogs);
}

KuduTableAlterer* KuduClient::NewTableAlterer(const string& table_name) {
  return new KuduTableAlterer(this, table_name);
}

Status KuduClient::IsAlterTableInProgress(const string& table_name,
                                          bool* alter_in_progress) {
  MonoTime deadline = MonoTime::Now() + default_admin_operation_timeout();
  TableIdentifierPB table;
  table.set_table_name(table_name);
  return data_->IsAlterTableInProgress(this, std::move(table), deadline,
                                       alter_in_progress);
}

Status KuduClient::GetTableSchema(const string& table_name,
                                  KuduSchema* schema) {
  MonoTime deadline = MonoTime::Now() + default_admin_operation_timeout();
  TableIdentifierPB table;
  table.set_table_name(table_name);
  return data_->GetTableSchema(this,
                               deadline,
                               table,
                               schema,
                               nullptr, // partition schema
                               nullptr, // table id
                               nullptr, // table name
                               nullptr, // number of replicas
                               nullptr); // extra configs
}

Status KuduClient::ListTabletServers(vector<KuduTabletServer*>* tablet_servers) {
  ListTabletServersRequestPB req;
  ListTabletServersResponsePB resp;
  MonoTime deadline = MonoTime::Now() + default_admin_operation_timeout();
  RETURN_NOT_OK(data_->ListTabletServers(this, deadline, req, &resp));
  for (int i = 0; i < resp.servers_size(); i++) {
    const ListTabletServersResponsePB_Entry& e = resp.servers(i);
    HostPort hp = HostPortFromPB(e.registration().rpc_addresses(0));
    unique_ptr<KuduTabletServer> ts(new KuduTabletServer);
    ts->data_ = new KuduTabletServer::Data(e.instance_id().permanent_uuid(), hp, e.location());
    tablet_servers->push_back(ts.release());
  }
  return Status::OK();
}

Status KuduClient::ListTables(vector<string>* tables,
                              const string& filter) {
  ListTablesRequestPB req;
  ListTablesResponsePB resp;

  if (!filter.empty()) {
    req.set_name_filter(filter);
  }
  MonoTime deadline = MonoTime::Now() + default_admin_operation_timeout();
  Synchronizer sync;
  AsyncLeaderMasterRpc<ListTablesRequestPB, ListTablesResponsePB> rpc(
      deadline, this, BackoffType::EXPONENTIAL, req, &resp,
      &MasterServiceProxy::ListTablesAsync, ""ListTables"",
      sync.AsStatusCallback(), {});
  rpc.SendRpc();
  RETURN_NOT_OK(sync.Wait());
  if (resp.has_error()) {
    return StatusFromPB(resp.error().status());
  }
  for (int i = 0; i < resp.tables_size(); i++) {
    tables->push_back(resp.tables(i).name());
  }
  return Status::OK();
}

Status KuduClient::TableExists(const string& table_name, bool* exists) {
  auto s = GetTableSchema(table_name, nullptr);
  if (s.ok()) {
    *exists = true;
  } else if (s.IsNotFound()) {
    *exists = false;
    s = Status::OK();
  }
  return s;
}

Status KuduClient::OpenTable(const string& table_name,
                             shared_ptr<KuduTable>* table) {
  TableIdentifierPB table_identifier;
  table_identifier.set_table_name(table_name);
  return data_->OpenTable(this,
                          table_identifier,
                          table);
}

shared_ptr<KuduSession> KuduClient::NewSession() {
  shared_ptr<KuduSession> ret(new KuduSession(shared_from_this()));
  ret->data_->Init(ret);
  return ret;
}

Status KuduClient::GetTablet(const string& tablet_id, KuduTablet** tablet) {
  GetTabletLocationsRequestPB req;
  GetTabletLocationsResponsePB resp;

  req.add_tablet_ids(tablet_id);
  req.set_intern_ts_infos_in_response(true);
  MonoTime deadline = MonoTime::Now() + default_admin_operation_timeout();
  Synchronizer sync;
  AsyncLeaderMasterRpc<GetTabletLocationsRequestPB, GetTabletLocationsResponsePB> rpc(
      deadline, this, BackoffType::EXPONENTIAL, req, &resp,
      &MasterServiceProxy::GetTabletLocationsAsync, ""GetTabletLocations"",
      sync.AsStatusCallback(), {});
  rpc.SendRpc();
  RETURN_NOT_OK(sync.Wait());
  if (resp.has_error()) {
    return StatusFromPB(resp.error().status());
  }
  if (resp.tablet_locations_size() == 0) {
    return Status::NotFound(Substitute(""$0: tablet not found"", tablet_id));
  }
  if (resp.tablet_locations_size() != 1) {
    return Status::IllegalState(Substitute(
        ""Expected only one tablet, but received $0"",
        resp.tablet_locations_size()));
  }
  const TabletLocationsPB& t = resp.tablet_locations(0);

  vector<const KuduReplica*> replicas;
  ElementDeleter deleter(&replicas);

  auto add_replica_func = [](const TSInfoPB& ts_info,
                             const RaftPeerPB::Role role,
                             vector<const KuduReplica*>* replicas) {
    if (ts_info.rpc_addresses_size() == 0) {
      return Status::IllegalState(Substitute(
          ""No RPC addresses found for tserver $0"",
          ts_info.permanent_uuid()));
    }
    HostPort hp = HostPortFromPB(ts_info.rpc_addresses(0));
    unique_ptr<KuduTabletServer> ts(new KuduTabletServer);
    ts->data_ = new KuduTabletServer::Data(ts_info.permanent_uuid(), hp, ts_info.location());

    // TODO(aserbin): try to use member_type instead of role for metacache.
    bool is_leader = role == RaftPeerPB::LEADER;
    bool is_voter = is_leader || role == RaftPeerPB::FOLLOWER;
    unique_ptr<KuduReplica> replica(new KuduReplica);
    replica->data_ = new KuduReplica::Data(is_leader, is_voter, std::move(ts));

    replicas->push_back(replica.release());
    return Status::OK();
  };

  // Handle ""old-style"" non-interned replicas. It's used for backward compatibility.
  for (const auto& r : t.deprecated_replicas()) {
    RETURN_NOT_OK(add_replica_func(r.ts_info(), r.role(), &replicas));
  }
  // Handle interned replicas.
  for (const auto& r : t.interned_replicas()) {
    RETURN_NOT_OK(add_replica_func(resp.ts_infos(r.ts_info_idx()), r.role(), &replicas));
  }

  unique_ptr<KuduTablet> client_tablet(new KuduTablet);
  client_tablet->data_ = new KuduTablet::Data(tablet_id, std::move(replicas));
  replicas.clear();

  *tablet = client_tablet.release();
  return Status::OK();
}

Status KuduClient::GetTableStatistics(const string& table_name,
                                      KuduTableStatistics** statistics) {
  GetTableStatisticsRequestPB req;
  GetTableStatisticsResponsePB resp;
  TableIdentifierPB* table = req.mutable_table();
  table->set_table_name(table_name);
  MonoTime deadline = MonoTime::Now() + default_admin_operation_timeout();
  Synchronizer sync;
  AsyncLeaderMasterRpc<GetTableStatisticsRequestPB, GetTableStatisticsResponsePB> rpc(
      deadline, this, BackoffType::EXPONENTIAL, req, &resp,
      &MasterServiceProxy::GetTableStatisticsAsync, ""GetTableStatistics"",
      sync.AsStatusCallback(), {});
  rpc.SendRpc();
  RETURN_NOT_OK(sync.Wait());
  if (resp.has_error()) {
    return StatusFromPB(resp.error().status());
  }
  unique_ptr<KuduTableStatistics> table_statistics(new KuduTableStatistics);
  table_statistics->data_ = new KuduTableStatistics::Data(
      resp.has_on_disk_size() ? boost::optional<int64_t>(resp.on_disk_size()) : boost::none,
      resp.has_live_row_count() ? boost::optional<int64_t>(resp.live_row_count()) : boost::none);

  *statistics = table_statistics.release();
  return Status::OK();
}

string KuduClient::GetMasterAddresses() const {
  return HostPort::ToCommaSeparatedString(data_->master_hostports());
}

bool KuduClient::IsMultiMaster() const {
  return data_->master_server_addrs_.size() > 1;
}

const MonoDelta& KuduClient::default_admin_operation_timeout() const {
  return data_->default_admin_operation_timeout_;
}

const MonoDelta& KuduClient::default_rpc_timeout() const {
  return data_->default_rpc_timeout_;
}

const uint64_t KuduClient::kNoTimestamp = 0;

uint64_t KuduClient::GetLatestObservedTimestamp() const {
  return data_->GetLatestObservedTimestamp();
}

void KuduClient::SetLatestObservedTimestamp(uint64_t ht_timestamp) {
  data_->UpdateLatestObservedTimestamp(ht_timestamp);
}

Status KuduClient::ExportAuthenticationCredentials(string* authn_creds) const {
  AuthenticationCredentialsPB pb;

  boost::optional<security::SignedTokenPB> tok = data_->messenger_->authn_token();
  if (tok) {
    pb.mutable_authn_token()->CopyFrom(*tok);
  }
  pb.set_real_user(data_->user_credentials_.real_user());

  vector<string> cert_ders;
  RETURN_NOT_OK_PREPEND(data_->messenger_->tls_context().DumpTrustedCerts(&cert_ders),
                        ""could not export trusted certs"");
  for (auto& der : cert_ders) {
    pb.add_ca_cert_ders()->assign(std::move(der));
  }

  if (!pb.SerializeToString(authn_creds)) {
    return Status::RuntimeError(""could not serialize authentication data"");
  }

  return Status::OK();
}

string KuduClient::GetHiveMetastoreUris() const {
  std::lock_guard<simple_spinlock> l(data_->leader_master_lock_);
  return data_->hive_metastore_uris_;
}

bool KuduClient::GetHiveMetastoreSaslEnabled() const {
  std::lock_guard<simple_spinlock> l(data_->leader_master_lock_);
  return data_->hive_metastore_sasl_enabled_;
}

string KuduClient::GetHiveMetastoreUuid() const {
  std::lock_guard<simple_spinlock> l(data_->leader_master_lock_);
  return data_->hive_metastore_uuid_;
}

string KuduClient::location() const {
  return data_->location();
}

////////////////////////////////////////////////////////////
// KuduTableCreator
////////////////////////////////////////////////////////////

KuduTableCreator::KuduTableCreator(KuduClient* client)
  : data_(new KuduTableCreator::Data(client)) {
}

KuduTableCreator::~KuduTableCreator() {
  delete data_;
}

KuduTableCreator& KuduTableCreator::table_name(const string& name) {
  data_->table_name_ = name;
  return *this;
}

KuduTableCreator& KuduTableCreator::schema(const KuduSchema* schema) {
  data_->schema_ = schema;
  return *this;
}

KuduTableCreator& KuduTableCreator::add_hash_partitions(const vector<string>& columns,
                                                        int32_t num_buckets) {
  return add_hash_partitions(columns, num_buckets, 0);
}

KuduTableCreator& KuduTableCreator::add_hash_partitions(const vector<string>& columns,
                                                        int32_t num_buckets, int32_t seed) {
  PartitionSchemaPB::HashBucketSchemaPB* bucket_schema =
    data_->partition_schema_.add_hash_bucket_schemas();
  for (const string& col_name : columns) {
    bucket_schema->add_columns()->set_name(col_name);
  }
  bucket_schema->set_num_buckets(num_buckets);
  bucket_schema->set_seed(seed);
  return *this;
}

KuduTableCreator& KuduTableCreator::set_range_partition_columns(const vector<string>& columns) {
  PartitionSchemaPB::RangeSchemaPB* range_schema =
    data_->partition_schema_.mutable_range_schema();
  range_schema->Clear();
  for (const string& col_name : columns) {
    range_schema->add_columns()->set_name(col_name);
  }

  return *this;
}

KuduTableCreator& KuduTableCreator::add_range_partition_split(KuduPartialRow* split_row) {
  data_->range_partition_splits_.emplace_back(split_row);
  return *this;
}

KuduTableCreator& KuduTableCreator::split_rows(const vector<const KuduPartialRow*>& rows) {
  for (const KuduPartialRow* row : rows) {
    data_->range_partition_splits_.emplace_back(const_cast<KuduPartialRow*>(row));
  }
  return *this;
}

KuduTableCreator& KuduTableCreator::add_range_partition(KuduPartialRow* lower_bound,
                                                        KuduPartialRow* upper_bound,
                                                        RangePartitionBound lower_bound_type,
                                                        RangePartitionBound upper_bound_type) {
  data_->range_partition_bounds_.push_back({
      unique_ptr<KuduPartialRow>(lower_bound),
      unique_ptr<KuduPartialRow>(upper_bound),
      lower_bound_type,
      upper_bound_type,
  });
  return *this;
}

KuduTableCreator& KuduTableCreator::num_replicas(int num_replicas) {
  data_->num_replicas_ = num_replicas;
  return *this;
}

KuduTableCreator& KuduTableCreator::dimension_label(const std::string& dimension_label) {
  data_->dimension_label_ = dimension_label;
  return *this;
}

KuduTableCreator& KuduTableCreator::extra_configs(const map<string, string>& extra_configs) {
  data_->extra_configs_ = extra_configs;
  return *this;
}

KuduTableCreator& KuduTableCreator::timeout(const MonoDelta& timeout) {
  data_->timeout_ = timeout;
  return *this;
}

KuduTableCreator& KuduTableCreator::wait(bool wait) {
  data_->wait_ = wait;
  return *this;
}

Status KuduTableCreator::Create() {
  if (!data_->table_name_.length()) {
    return Status::InvalidArgument(""Missing table name"");
  }
  if (!data_->schema_) {
    return Status::InvalidArgument(""Missing schema"");
  }
  if (!data_->partition_schema_.has_range_schema() &&
      data_->partition_schema_.hash_bucket_schemas().empty()) {
    return Status::InvalidArgument(
        ""Table partitioning must be specified using ""
        ""add_hash_partitions or set_range_partition_columns"");
  }

  // Build request.
  CreateTableRequestPB req;
  CreateTableResponsePB resp;
  req.set_name(data_->table_name_);
  if (data_->num_replicas_ != boost::none) {
    req.set_num_replicas(data_->num_replicas_.get());
  }
  if (data_->dimension_label_) {
    req.set_dimension_label(data_->dimension_label_.get());
  }
  if (data_->extra_configs_) {
    req.mutable_extra_configs()->insert(data_->extra_configs_->begin(),
                                        data_->extra_configs_->end());
  }
  RETURN_NOT_OK_PREPEND(SchemaToPB(*data_->schema_->schema_, req.mutable_schema(),
                                   SCHEMA_PB_WITHOUT_WRITE_DEFAULT),
                        ""Invalid schema"");

  RowOperationsPBEncoder encoder(req.mutable_split_rows_range_bounds());

  for (const auto& row : data_->range_partition_splits_) {
    if (!row) {
      return Status::InvalidArgument(""range split row must not be null"");
    }
    encoder.Add(RowOperationsPB::SPLIT_ROW, *row);
  }

  for (const auto& bound : data_->range_partition_bounds_) {
    if (!bound.lower_bound || !bound.upper_bound) {
      return Status::InvalidArgument(""range bounds must not be null"");
    }

    RowOperationsPB_Type lower_bound_type =
      bound.lower_bound_type == KuduTableCreator::INCLUSIVE_BOUND ?
      RowOperationsPB::RANGE_LOWER_BOUND :
      RowOperationsPB::EXCLUSIVE_RANGE_LOWER_BOUND;

    RowOperationsPB_Type upper_bound_type =
      bound.upper_bound_type == KuduTableCreator::EXCLUSIVE_BOUND ?
      RowOperationsPB::RANGE_UPPER_BOUND :
      RowOperationsPB::INCLUSIVE_RANGE_UPPER_BOUND;

    encoder.Add(lower_bound_type, *bound.lower_bound);
    encoder.Add(upper_bound_type, *bound.upper_bound);
  }

  req.mutable_partition_schema()->CopyFrom(data_->partition_schema_);

  MonoTime deadline = MonoTime::Now();
  if (data_->timeout_.Initialized()) {
    deadline += data_->timeout_;
  } else {
    deadline += data_->client_->default_admin_operation_timeout();
  }
  RETURN_NOT_OK_PREPEND(data_->client_->data_->CreateTable(data_->client_,
                                                           req,
                                                           &resp,
                                                           deadline,
                                                           !data_->range_partition_bounds_.empty()),
                        Substitute(""Error creating table $0 on the master"",
                                   data_->table_name_));

  // Spin until the table is fully created, if requested.
  if (data_->wait_) {
    TableIdentifierPB table;
    table.set_table_id(resp.table_id());
    RETURN_NOT_OK(data_->client_->data_->WaitForCreateTableToFinish(data_->client_,
                                                                    table,
                                                                    deadline));
  }

  return Status::OK();
}

////////////////////////////////////////////////////////////
// KuduTableStatistics
////////////////////////////////////////////////////////////

KuduTableStatistics::KuduTableStatistics() : data_(nullptr) {
}

KuduTableStatistics::~KuduTableStatistics() {
  delete data_;
}

int64_t KuduTableStatistics::on_disk_size() const {
  return data_->on_disk_size_ ? *data_->on_disk_size_ : -1;
}

int64_t KuduTableStatistics::live_row_count() const {
  return data_->live_row_count_ ? *data_->live_row_count_ : -1;
}

std::string KuduTableStatistics::ToString() const {
  return data_->ToString();
}

////////////////////////////////////////////////////////////
// KuduTable
////////////////////////////////////////////////////////////

KuduTable::KuduTable(const shared_ptr<KuduClient>& client,
                     const string& name,
                     const string& id,
                     int num_replicas,
                     const KuduSchema& schema,
                     const PartitionSchema& partition_schema,
                     const map<string, string>& extra_configs)
  : data_(new KuduTable::Data(client, name, id, num_replicas,
                              schema, partition_schema, extra_configs)) {
}

KuduTable::~KuduTable() {
  delete data_;
}

const string& KuduTable::name() const {
  return data_->name_;
}

const string& KuduTable::id() const {
  return data_->id_;
}

const KuduSchema& KuduTable::schema() const {
  return data_->schema_;
}

int KuduTable::num_replicas() const {
  return data_->num_replicas_;
}

KuduInsert* KuduTable::NewInsert() {
  return new KuduInsert(shared_from_this());
}

KuduInsertIgnore* KuduTable::NewInsertIgnore() {
  return new KuduInsertIgnore(shared_from_this());
}

KuduUpsert* KuduTable::NewUpsert() {
  return new KuduUpsert(shared_from_this());
}

KuduUpdate* KuduTable::NewUpdate() {
  return new KuduUpdate(shared_from_this());
}

KuduDelete* KuduTable::NewDelete() {
  return new KuduDelete(shared_from_this());
}

KuduClient* KuduTable::client() const {
  return data_->client_.get();
}

const PartitionSchema& KuduTable::partition_schema() const {
  return data_->partition_schema_;
}

const map<string, string>& KuduTable::extra_configs() const {
  return data_->extra_configs_;
}

KuduPredicate* KuduTable::NewComparisonPredicate(const Slice& col_name,
                                                 KuduPredicate::ComparisonOp op,
                                                 KuduValue* value) {
  // We always take ownership of value; this ensures cleanup if the predicate is invalid.
  auto cleanup = MakeScopedCleanup([&]() {
    delete value;
  });
  return data_->MakePredicate(col_name, [&](const ColumnSchema& col_schema) {
    // Ownership of value is passed to the valid returned predicate.
    cleanup.cancel();
    return new KuduPredicate(new ComparisonPredicateData(col_schema, op, value));
  });
}

KuduPredicate* KuduTable::NewInBloomFilterPredicate(const Slice& col_name,
                                                    vector<KuduBloomFilter*>* bloom_filters) {
  // We always take ownership of values; this ensures cleanup if the predicate is invalid.
  auto cleanup = MakeScopedCleanup([&]() {
    STLDeleteElements(bloom_filters);
  });

  // Empty vector of bloom filters will select all rows. Hence disallowed.
  if (bloom_filters->empty()) {
    return new KuduPredicate(
        new ErrorPredicateData(Status::InvalidArgument(""No Bloom filters supplied"")));
  }

  // Transfer the Bloom filter raw ptrs over to vector of unique ptrs.
  // There is a possibility of emplace_back() throwing exception, so in such a case the
  // transferred Bloom filters in unique_ptrs will be cleaned-up on exiting scope
  // automatically and the non-nullptr Bloom filters in input ""bloom_filters"" vector
  // will be cleaned up by the explicit scoped ""cleanup"".
  vector<unique_ptr<KuduBloomFilter>> bloom_filters_owned;
  bloom_filters_owned.reserve(bloom_filters->size());
  for (auto& bf : *bloom_filters) {
    bloom_filters_owned.emplace_back(bf);
    bf = nullptr;
  }

  return data_->MakePredicate(col_name, [&](const ColumnSchema& col_schema) {
    // At this point we could cancel the scoped ""cleanup"". But the scoped cleanup
    // not only deletes pointers contained in the vector but also clears the vector
    // and we want the vector be cleared as expected by the caller.
    return new KuduPredicate(
        new InBloomFilterPredicateData(col_schema, std::move(bloom_filters_owned)));
  });
}

KuduPredicate* KuduTable::NewInBloomFilterPredicate(const Slice& col_name,
                                                    const vector<Slice>& bloom_filters) {
  // Empty vector of bloom filters will select all rows. Hence disallowed.
  if (bloom_filters.empty()) {
    return new KuduPredicate(
        new ErrorPredicateData(Status::InvalidArgument(""No Bloom filters supplied"")));
  }

  // Extract the Block Bloom filters.
  vector<DirectBlockBloomFilterUniqPtr> bbf_vec;
  for (const auto& bf_slice : bloom_filters) {
    auto* bbf =
        reinterpret_cast<BlockBloomFilter*>(const_cast<uint8_t*>(bf_slice.data()));
    // In this case, the Block Bloom filters are supplied as opaque pointers
    // and the predicate will convert them to well-defined pointer types
    // but will NOT take ownership of those pointers. Hence a custom deleter,
    // DirectBloomFilterDataDeleter, is used that gives control over ownership.
    DirectBlockBloomFilterUniqPtr bf_uniq_ptr(
        bbf, DirectBloomFilterDataDeleter<BlockBloomFilter>(false /*owned*/));
    bbf_vec.emplace_back(std::move(bf_uniq_ptr));
  }

  return data_->MakePredicate(col_name, [&](const ColumnSchema& col_schema) {
    return new KuduPredicate(
        new InDirectBloomFilterPredicateData(col_schema, std::move(bbf_vec)));
  });
}

KuduPredicate* KuduTable::NewInListPredicate(const Slice& col_name,
                                             vector<KuduValue*>* values) {
  // We always take ownership of values; this ensures cleanup if the predicate is invalid.
  auto cleanup = MakeScopedCleanup([&]() {
    STLDeleteElements(values);
  });
  return data_->MakePredicate(col_name, [&](const ColumnSchema& col_schema) {
    // Ownership of values is passed to the valid returned predicate.
    cleanup.cancel();
    return new KuduPredicate(new InListPredicateData(col_schema, values));
  });
}

KuduPredicate* KuduTable::NewIsNotNullPredicate(const Slice& col_name) {
  return data_->MakePredicate(col_name, [&](const ColumnSchema& col_schema) {
    return new KuduPredicate(new IsNotNullPredicateData(col_schema));
  });
}

KuduPredicate* KuduTable::NewIsNullPredicate(const Slice& col_name) {
  return data_->MakePredicate(col_name, [&](const ColumnSchema& col_schema) {
    return new KuduPredicate(new IsNullPredicateData(col_schema));
  });
}

// The strategy for retrieving the partitions from the metacache is adapted
// from KuduScanTokenBuilder::Data::Build.
Status KuduTable::ListPartitions(vector<Partition>* partitions) {
  DCHECK(partitions);
  partitions->clear();
  auto& client = data_->client_;
  const auto deadline = MonoTime::Now() + client->default_admin_operation_timeout();
  PartitionPruner pruner;
  pruner.Init(*data_->schema_.schema_, data_->partition_schema_, ScanSpec());
  while (pruner.HasMorePartitionKeyRanges()) {
    scoped_refptr<client::internal::RemoteTablet> tablet;
    Synchronizer sync;
    const string& partition_key = pruner.NextPartitionKey();
    client->data_->meta_cache_->LookupTabletByKey(
        this,
        partition_key,
        deadline,
        client::internal::MetaCache::LookupType::kLowerBound,
        &tablet,
        sync.AsStatusCallback());
    Status s = sync.Wait();
    if (s.IsNotFound()) {
      // No more tablets.
      break;
    }
    RETURN_NOT_OK(s);

    partitions->emplace_back(tablet->partition());
    pruner.RemovePartitionKeyRange(tablet->partition().partition_key_end());
  }
  return Status::OK();
}

////////////////////////////////////////////////////////////
// Error
////////////////////////////////////////////////////////////

const Status& KuduError::status() const {
  return data_->status_;
}

const KuduWriteOperation& KuduError::failed_op() const {
  return *data_->failed_op_;
}

KuduWriteOperation* KuduError::release_failed_op() {
  CHECK_NOTNULL(data_->failed_op_.get());
  return data_->failed_op_.release();
}

bool KuduError::was_possibly_successful() const {
  // TODO: implement me - right now be conservative.
  return true;
}

KuduError::KuduError(KuduWriteOperation* failed_op,
                     const Status& status)
  : data_(new KuduError::Data(unique_ptr<KuduWriteOperation>(failed_op),
                              status)) {
}

KuduError::~KuduError() {
  delete data_;
}

////////////////////////////////////////////////////////////
// KuduSession
////////////////////////////////////////////////////////////

KuduSession::KuduSession(const shared_ptr<KuduClient>& client)
  : data_(new KuduSession::Data(client, client->data_->messenger_)) {
}

KuduSession::~KuduSession() {
  WARN_NOT_OK(data_->Close(true), ""Closed Session with pending operations."");
  delete data_;
}

Status KuduSession::Close() {
  return data_->Close(false);
}

Status KuduSession::SetFlushMode(FlushMode m) {
  if (!tight_enum_test<FlushMode>(m)) {
    // Be paranoid in client code.
    return Status::InvalidArgument(""Bad flush mode"");
  }
  return data_->SetFlushMode(m);
}

Status KuduSession::SetExternalConsistencyMode(ExternalConsistencyMode m) {
  if (!tight_enum_test<ExternalConsistencyMode>(m)) {
    // Be paranoid in client code.
    return Status::InvalidArgument(""Bad external consistency mode"");
  }
  return data_->SetExternalConsistencyMode(m);
}

Status KuduSession::SetMutationBufferSpace(size_t size) {
  return data_->SetBufferBytesLimit(size);
}

Status KuduSession::SetMutationBufferFlushWatermark(double watermark_pct) {
  return data_->SetBufferFlushWatermark(
      static_cast<int32_t>(100.0 * watermark_pct));
}

Status KuduSession::SetMutationBufferFlushInterval(unsigned int millis) {
  return data_->SetBufferFlushInterval(millis);
}

Status KuduSession::SetMutationBufferMaxNum(unsigned int max_num) {
  return data_->SetMaxBatchersNum(max_num);
}

void KuduSession::SetTimeoutMillis(int timeout_ms) {
  data_->SetTimeoutMillis(timeout_ms);
}

Status KuduSession::Flush() {
  return data_->Flush();
}

void KuduSession::FlushAsync(KuduStatusCallback* user_callback) {
  data_->FlushAsync(user_callback);
}

bool KuduSession::HasPendingOperations() const {
  return data_->HasPendingOperations();
}

Status KuduSession::Apply(KuduWriteOperation* write_op) {
  RETURN_NOT_OK(data_->ApplyWriteOp(write_op));
  // Thread-safety note: this method should not be called concurrently
  // with other methods which modify the KuduSession::Data members, so it
  // should be safe to read KuduSession::Data members without protection.
  if (data_->flush_mode_ == AUTO_FLUSH_SYNC) {
    RETURN_NOT_OK(data_->Flush());
  }
  return Status::OK();
}

int KuduSession::CountBufferedOperations() const {
  return data_->CountBufferedOperations();
}

Status KuduSession::SetErrorBufferSpace(size_t size_bytes) {
  return data_->error_collector_->SetMaxMemSize(size_bytes);
}

int KuduSession::CountPendingErrors() const {
  return data_->error_collector_->CountErrors();
}

void KuduSession::GetPendingErrors(vector<KuduError*>* errors, bool* overflowed) {
  data_->error_collector_->GetErrors(errors, overflowed);
}

KuduClient* KuduSession::client() const {
  return data_->client_.get();
}

////////////////////////////////////////////////////////////
// KuduTableAlterer
////////////////////////////////////////////////////////////
KuduTableAlterer::KuduTableAlterer(KuduClient* client, const string& name)
  : data_(new Data(client, name)) {
}

KuduTableAlterer::~KuduTableAlterer() {
  delete data_;
}

KuduTableAlterer* KuduTableAlterer::RenameTo(const string& new_name) {
  data_->rename_to_ = new_name;
  return this;
}

KuduColumnSpec* KuduTableAlterer::AddColumn(const string& name) {
  Data::Step s = { AlterTableRequestPB::ADD_COLUMN,
                   new KuduColumnSpec(name), nullptr, nullptr };
  auto* spec = s.spec;
  data_->steps_.emplace_back(std::move(s));
  return spec;
}

KuduColumnSpec* KuduTableAlterer::AlterColumn(const string& name) {
  Data::Step s = { AlterTableRequestPB::ALTER_COLUMN,
                   new KuduColumnSpec(name), nullptr, nullptr };
  auto* spec = s.spec;
  data_->steps_.emplace_back(std::move(s));
  return spec;
}

KuduTableAlterer* KuduTableAlterer::DropColumn(const string& name) {
  Data::Step s = { AlterTableRequestPB::DROP_COLUMN,
                   new KuduColumnSpec(name), nullptr, nullptr };
  data_->steps_.emplace_back(std::move(s));
  return this;
}

KuduTableAlterer* KuduTableAlterer::AddRangePartition(
    KuduPartialRow* lower_bound,
    KuduPartialRow* upper_bound,
    KuduTableCreator::RangePartitionBound lower_bound_type,
    KuduTableCreator::RangePartitionBound upper_bound_type) {
  return AddRangePartitionWithDimension(
      lower_bound, upper_bound, """", lower_bound_type, upper_bound_type);
}

KuduTableAlterer* KuduTableAlterer::AddRangePartitionWithDimension(
    KuduPartialRow* lower_bound,
    KuduPartialRow* upper_bound,
    const std::string& dimension_label,
    KuduTableCreator::RangePartitionBound lower_bound_type,
    KuduTableCreator::RangePartitionBound upper_bound_type) {

  if (lower_bound == nullptr || upper_bound == nullptr) {
    data_->status_ = Status::InvalidArgument(""range partition bounds may not be null"");
    return this;
  }
  if (!lower_bound->schema()->Equals(*upper_bound->schema())) {
    data_->status_ = Status::InvalidArgument(""range partition bounds must have matching schemas"");
    return this;
  }
  if (data_->schema_ == nullptr) {
    data_->schema_ = lower_bound->schema();
  } else if (!lower_bound->schema()->Equals(*data_->schema_)) {
    data_->status_ = Status::InvalidArgument(""range partition bounds must have matching schemas"");
    return this;
  }

  Data::Step s { AlterTableRequestPB::ADD_RANGE_PARTITION,
                 nullptr,
                 unique_ptr<KuduPartialRow>(lower_bound),
                 unique_ptr<KuduPartialRow>(upper_bound),
                 lower_bound_type,
                 upper_bound_type,
                 dimension_label.empty() ? boost::none : boost::make_optional(dimension_label) };
  data_->steps_.emplace_back(std::move(s));
  data_->has_alter_partitioning_steps = true;
  return this;
}

KuduTableAlterer* KuduTableAlterer::DropRangePartition(
    KuduPartialRow* lower_bound,
    KuduPartialRow* upper_bound,
    KuduTableCreator::RangePartitionBound lower_bound_type,
    KuduTableCreator::RangePartitionBound upper_bound_type) {
  if (lower_bound == nullptr || upper_bound == nullptr) {
    data_->status_ = Status::InvalidArgument(""range partition bounds may not be null"");
    return this;
  }
  if (!lower_bound->schema()->Equals(*upper_bound->schema())) {
    data_->status_ = Status::InvalidArgument(""range partition bounds must have matching schemas"");
    return this;
  }
  if (data_->schema_ == nullptr) {
    data_->schema_ = lower_bound->schema();
  } else if (!lower_bound->schema()->Equals(*data_->schema_)) {
    data_->status_ = Status::InvalidArgument(""range partition bounds must have matching schemas"");
    return this;
  }

  Data::Step s { AlterTableRequestPB::DROP_RANGE_PARTITION,
                 nullptr,
                 unique_ptr<KuduPartialRow>(lower_bound),
                 unique_ptr<KuduPartialRow>(upper_bound),
                 lower_bound_type,
                 upper_bound_type };
  data_->steps_.emplace_back(std::move(s));
  data_->has_alter_partitioning_steps = true;
  return this;
}

KuduTableAlterer* KuduTableAlterer::AlterExtraConfig(const map<string, string>& extra_configs) {
  data_->new_extra_configs_ = extra_configs;
  return this;
}

KuduTableAlterer* KuduTableAlterer::timeout(const MonoDelta& timeout) {
  data_->timeout_ = timeout;
  return this;
}

KuduTableAlterer* KuduTableAlterer::wait(bool wait) {
  data_->wait_ = wait;
  return this;
}

KuduTableAlterer* KuduTableAlterer::modify_external_catalogs(
    bool modify_external_catalogs) {
  data_->modify_external_catalogs_ = modify_external_catalogs;
  return this;
}

Status KuduTableAlterer::Alter() {
  AlterTableRequestPB req;
  AlterTableResponsePB resp;
  RETURN_NOT_OK(data_->ToRequest(&req));

  MonoDelta timeout = data_->timeout_.Initialized() ?
    data_->timeout_ :
    data_->client_->default_admin_operation_timeout();
  MonoTime deadline = MonoTime::Now() + timeout;
  RETURN_NOT_OK(data_->client_->data_->AlterTable(data_->client_, req, &resp, deadline,
                                                  data_->has_alter_partitioning_steps));

  if (data_->has_alter_partitioning_steps) {
    // If the table partitions change, clear the local meta cache so that the
    // new tablets can immediately be written to and scanned, and the old
    // tablets won't be seen again. This also prevents rows being batched for
    // the wrong tablet when a partition is dropped and added in the same alter
    // table transaction. We could clear the meta cache for just the table being
    // altered or just the partition key ranges being changed, but that would
    // require opening the table in order to get the ID, schema, and partition
    // schema.
    //
    // It is not necessary to wait for the alteration to be completed before
    // clearing the cache (i.e. the tablets to be created), because the master
    // has its soft state updated as part of handling the alter table RPC. When
    // the meta cache looks up the new tablet locations during a subsequent
    // write or scan, the master will return a ServiceUnavailable response if
    // the new tablets are not yet running. The meta cache will automatically
    // retry after a delay when it encounters this error.
    data_->client_->data_->meta_cache_->ClearCache();
  }

  if (data_->wait_) {
    if (!resp.has_table_id()) {
      return Status::NotSupported(""Alter Table succeeded but the server's ""
          ""response did not include a table ID. This server is too old to wait ""
          ""for alter table to finish"");
    }
    TableIdentifierPB table;
    table.set_table_id(resp.table_id());
    RETURN_NOT_OK(data_->client_->data_->WaitForAlterTableToFinish(
        data_->client_, table, deadline));
  }

  return Status::OK();
}

////////////////////////////////////////////////////////////
// KuduScanner
////////////////////////////////////////////////////////////

KuduScanner::KuduScanner(KuduTable* table)
  : data_(new KuduScanner::Data(table)) {
}

KuduScanner::~KuduScanner() {
  Close();
  delete data_;
}

Status KuduScanner::SetProjectedColumns(const vector<string>& col_names) {
  return SetProjectedColumnNames(col_names);
}

Status KuduScanner::SetProjectedColumnNames(const vector<string>& col_names) {
  if (data_->open_) {
    return Status::IllegalState(""Projection must be set before Open()"");
  }
  return data_->mutable_configuration()->SetProjectedColumnNames(col_names);
}

Status KuduScanner::SetProjectedColumnIndexes(const vector<int>& col_indexes) {
  if (data_->open_) {
    return Status::IllegalState(""Projection must be set before Open()"");
  }
  return data_->mutable_configuration()->SetProjectedColumnIndexes(col_indexes);
}

Status KuduScanner::SetBatchSizeBytes(uint32_t batch_size) {
  return data_->mutable_configuration()->SetBatchSizeBytes(batch_size);
}

Status KuduScanner::SetReadMode(ReadMode read_mode) {
  if (data_->open_) {
    return Status::IllegalState(""Read mode must be set before Open()"");
  }
  if (!tight_enum_test<ReadMode>(read_mode)) {
    return Status::InvalidArgument(""Bad read mode"");
  }
  return data_->mutable_configuration()->SetReadMode(read_mode);
}

Status KuduScanner::SetOrderMode(OrderMode order_mode) {
  if (data_->open_) {
    return Status::IllegalState(""Order mode must be set before Open()"");
  }
  if (!tight_enum_test<OrderMode>(order_mode)) {
    return Status::InvalidArgument(""Bad order mode"");
  }
  return data_->mutable_configuration()->SetFaultTolerant(order_mode == ORDERED);
}

Status KuduScanner::SetFaultTolerant() {
  if (data_->open_) {
    return Status::IllegalState(""Fault-tolerance must be set before Open()"");
  }
  return data_->mutable_configuration()->SetFaultTolerant(true);
}

Status KuduScanner::SetSnapshotMicros(uint64_t snapshot_timestamp_micros) {
  if (data_->open_) {
    return Status::IllegalState(""Snapshot timestamp must be set before Open()"");
  }
  data_->mutable_configuration()->SetSnapshotMicros(snapshot_timestamp_micros);
  return Status::OK();
}

Status KuduScanner::SetSnapshotRaw(uint64_t snapshot_timestamp) {
  if (data_->open_) {
    return Status::IllegalState(""Snapshot timestamp must be set before Open()"");
  }
  if (snapshot_timestamp == 0) {
    return Status::IllegalState(""Snapshot timestamp must be set bigger than 0"");
  }
  data_->mutable_configuration()->SetSnapshotRaw(snapshot_timestamp);
  return Status::OK();
}

Status KuduScanner::SetDiffScan(uint64_t start_timestamp, uint64_t end_timestamp) {
  if (data_->open_) {
    return Status::IllegalState(""Diff scan must be set before Open()"");
  }
  return data_->mutable_configuration()->SetDiffScan(start_timestamp, end_timestamp);
}

Status KuduScanner::SetSelection(KuduClient::ReplicaSelection selection) {
  if (data_->open_) {
    return Status::IllegalState(""Replica selection must be set before Open()"");
  }
  return data_->mutable_configuration()->SetSelection(selection);
}

Status KuduScanner::SetTimeoutMillis(int millis) {
  if (data_->open_) {
    return Status::IllegalState(""Timeout must be set before Open()"");
  }
  data_->mutable_configuration()->SetTimeoutMillis(millis);
  return Status::OK();
}

Status KuduScanner::AddConjunctPredicate(KuduPredicate* pred) {
  if (data_->open_) {
    // Take ownership even if we return a bad status.
    delete pred;
    return Status::IllegalState(""Predicate must be set before Open()"");
  }
  return data_->mutable_configuration()->AddConjunctPredicate(pred);
}

Status KuduScanner::AddLowerBound(const KuduPartialRow& key) {
  return data_->mutable_configuration()->AddLowerBound(key);
}

Status KuduScanner::AddLowerBoundRaw(const Slice& key) {
  return data_->mutable_configuration()->AddLowerBoundRaw(key);
}

Status KuduScanner::AddExclusiveUpperBound(const KuduPartialRow& key) {
  return data_->mutable_configuration()->AddUpperBound(key);
}

Status KuduScanner::AddExclusiveUpperBoundRaw(const Slice& key) {
  return data_->mutable_configuration()->AddUpperBoundRaw(key);
}

Status KuduScanner::AddLowerBoundPartitionKeyRaw(const Slice& partition_key) {
  return data_->mutable_configuration()->AddLowerBoundPartitionKeyRaw(partition_key);
}

Status KuduScanner::AddExclusiveUpperBoundPartitionKeyRaw(const Slice& partition_key) {
  return data_->mutable_configuration()->AddUpperBoundPartitionKeyRaw(partition_key);
}

Status KuduScanner::SetCacheBlocks(bool cache_blocks) {
  if (data_->open_) {
    return Status::IllegalState(""Block caching must be set before Open()"");
  }
  return data_->mutable_configuration()->SetCacheBlocks(cache_blocks);
}

KuduSchema KuduScanner::GetProjectionSchema() const {
  return KuduSchema::FromSchema(*data_->configuration().projection());
}

Status KuduScanner::SetRowFormatFlags(uint64_t flags) {
  switch (flags) {
    case NO_FLAGS:
    case PAD_UNIXTIME_MICROS_TO_16_BYTES:
    case COLUMNAR_LAYOUT:
      break;
    default:
      return Status::InvalidArgument(Substitute(""Invalid row format flags: $0"", flags));
  }
  if (data_->open_) {
    return Status::IllegalState(""Row format flags must be set before Open()"");
  }

  return data_->mutable_configuration()->SetRowFormatFlags(flags);
}

Status KuduScanner::SetLimit(int64_t limit) {
  if (data_->open_) {
    return Status::IllegalState(""Limit must be set before Open()"");
  }
  return data_->mutable_configuration()->SetLimit(limit);
}

const ResourceMetrics& KuduScanner::GetResourceMetrics() const {
  return data_->resource_metrics_;
}

namespace {
// Callback for the RPC sent by Close().
// We can't use the KuduScanner response and RPC controller members for this
// call, because the scanner object may be destructed while the call is still
// being processed.
struct CloseCallback {
  RpcController controller;
  ScanResponsePB response;
  string scanner_id;
  void Callback() {
    if (!controller.status().ok()) {
      LOG(WARNING) << ""Couldn't close scanner "" << scanner_id << "": ""
                   << controller.status().ToString();
    }
    delete this;
  }
};
} // anonymous namespace

string KuduScanner::ToString() const {
  return KUDU_DISABLE_REDACTION(Substitute(
      ""$0: $1"",
      data_->table_->name(),
      data_->configuration().spec().ToString(*data_->table_->schema().schema_)));
}

Status KuduScanner::Open() {
  CHECK(!data_->open_) << ""Scanner already open"";

  if (data_->configuration().has_start_timestamp()) {
    RETURN_NOT_OK(data_->mutable_configuration()->AddIsDeletedColumn());
  }
  data_->mutable_configuration()->OptimizeScanSpec();
  data_->partition_pruner_.Init(*data_->table_->schema().schema_,
                                data_->table_->partition_schema(),
                                data_->configuration().spec());

  if (data_->configuration().spec().CanShortCircuit() ||
      !data_->partition_pruner_.HasMorePartitionKeyRanges()) {
    VLOG(2) << ""Short circuiting scan "" << data_->DebugString();
    data_->open_ = true;
    data_->short_circuit_ = true;
    return Status::OK();
  }

  // For READ_YOUR_WRITES scan mode, get the latest observed timestamp and store it
  // to scan config. Always use this one as propagation timestamp for the duration
  // of the scan to avoid unnecessarily wait.
  if (data_->configuration().read_mode() == READ_YOUR_WRITES) {
    const uint64_t lo_ts = data_->table_->client()->data_->GetLatestObservedTimestamp();
    data_->mutable_configuration()->SetScanLowerBoundTimestampRaw(lo_ts);
  }

  if (data_->configuration().read_mode() != READ_AT_SNAPSHOT &&
      data_->configuration().has_snapshot_timestamp()) {
    return Status::InvalidArgument(""Snapshot timestamp should only be configured ""
                                   ""for READ_AT_SNAPSHOT scan mode."");
  }

  VLOG(2) << ""Beginning "" << data_->DebugString();

  MonoTime deadline = MonoTime::Now() + data_->configuration().timeout();
  set<string> blacklist;

  RETURN_NOT_OK(data_->OpenNextTablet(deadline, &blacklist));

  data_->open_ = true;
  return Status::OK();
}

Status KuduScanner::KeepAlive() {
  return data_->KeepAlive();
}

void KuduScanner::Close() {
  if (!data_->open_) return;

  VLOG(2) << ""Ending "" << data_->DebugString();

  // Close the scanner on the server-side, if necessary.
  //
  // If the scan did not match any rows, the tserver will not assign a scanner ID.
  // This is reflected in the Open() response. In this case, there is no server-side state
  // to clean up.
  if (!data_->next_req_.scanner_id().empty()) {
    CHECK(data_->proxy_);
    unique_ptr<CloseCallback> closer(new CloseCallback);
    closer->scanner_id = data_->next_req_.scanner_id();
    data_->PrepareRequest(KuduScanner::Data::CLOSE);
    data_->next_req_.set_close_scanner(true);
    closer->controller.set_timeout(data_->configuration().timeout());
    // CloseCallback::Callback() deletes the closer.
    CloseCallback* closer_raw = closer.release();
    data_->proxy_->ScanAsync(data_->next_req_, &closer_raw->response, &closer_raw->controller,
                             [closer_raw]() { closer_raw->Callback(); });
  }
  data_->proxy_.reset();
  data_->open_ = false;
  return;
}

bool KuduScanner::HasMoreRows() const {
  CHECK(data_->open_);
  return !data_->short_circuit_ &&                 // The scan is not short circuited
      (data_->data_in_open_ ||                     // more data in hand
       data_->last_response_.has_more_results() || // more data in this tablet
       data_->MoreTablets());                      // more tablets to scan, possibly with more data
}

Status KuduScanner::NextBatch(vector<KuduRowResult>* rows) {
  if (PREDICT_FALSE(data_->configuration().row_format_flags() != KuduScanner::NO_FLAGS)) {
    return Status::IllegalState(
        Substitute(""Cannot extract rows. Row format modifier flags were selected: $0"",
                   data_->configuration().row_format_flags()));
  }
  RETURN_NOT_OK(NextBatch(&data_->batch_for_old_api_));
  data_->batch_for_old_api_.data_->ExtractRows(rows);
  return Status::OK();
}

Status KuduScanner::NextBatch(KuduScanBatch* batch) {
  return NextBatch(batch->data_);
}

Status KuduScanner::NextBatch(KuduColumnarScanBatch* batch) {
  return NextBatch(batch->data_);
}

Status KuduScanner::NextBatch(internal::ScanBatchDataInterface* batch_data) {

  // TODO: do some double-buffering here -- when we return this batch
  // we should already have fired off the RPC for the next batch, but
  // need to do some swapping of the response objects around to avoid
  // stomping on the memory the user is looking at.
  CHECK(data_->open_);
  CHECK(data_->proxy_);

  batch_data->Clear();

  if (data_->short_circuit_) {
    return Status::OK();
  }

  if (data_->data_in_open_) {
    // We have data from a previous scan.
    VLOG(2) << ""Extracting data from "" << data_->DebugString();
    data_->data_in_open_ = false;
    return batch_data->Reset(&data_->controller_,
                             data_->configuration().projection(),
                             data_->configuration().client_projection(),
                             data_->configuration().row_format_flags(),
                             &data_->last_response_);
  }

  if (data_->last_response_.has_more_results()) {
    // More data is available in this tablet.
    VLOG(2) << ""Continuing "" << data_->DebugString();

    MonoTime batch_deadline = MonoTime::Now() + data_->configuration().timeout();
    data_->PrepareRequest(KuduScanner::Data::CONTINUE);

    while (true) {
      bool allow_time_for_failover = data_->configuration().is_fault_tolerant();
      ScanRpcStatus result = data_->SendScanRpc(batch_deadline, allow_time_for_failover);

      // Success case.
      if (result.result == ScanRpcStatus::OK) {
        if (data_->last_response_.has_last_primary_key()) {
          data_->last_primary_key_ = data_->last_response_.last_primary_key();
        }
        data_->scan_attempts_ = 0;
        return batch_data->Reset(&data_->controller_,
                                 data_->configuration().projection(),
                                 data_->configuration().client_projection(),
                                 data_->configuration().row_format_flags(),
                                 &data_->last_response_);
      }

      data_->scan_attempts_++;

      // Error handling.
      set<string> blacklist;
      bool needs_reopen = false;
      Status s = data_->HandleError(result, batch_deadline, &blacklist, &needs_reopen);
      if (!s.ok()) {
        LOG(WARNING) << ""Scan on tablet server "" << data_->ts_->ToString() << "" with ""
                     << data_->DebugString() << "" failed: "" << result.status.ToString();
        return s;
      }

      if (data_->configuration().is_fault_tolerant()) {
        LOG(WARNING) << ""Attempting to retry "" << data_->DebugString()
                     << "" elsewhere."";
        return data_->ReopenCurrentTablet(batch_deadline, &blacklist);
      }

      if (blacklist.empty() && !needs_reopen) {
        // If we didn't blacklist the current server, we can just retry again.
        continue;
      }
      // If we blacklisted the current server, and it's not fault-tolerant, we can't
      // retry anywhere, so just propagate the error.
      return result.status;
    }
  } else if (data_->MoreTablets()) {
    // More data may be available in other tablets.
    // No need to close the current tablet; we scanned all the data so the
    // server closed it for us.
    VLOG(2) << ""Scanning next tablet "" << data_->DebugString();
    data_->last_primary_key_.clear();
    MonoTime deadline = MonoTime::Now() + data_->configuration().timeout();
    set<string> blacklist;

    RETURN_NOT_OK(data_->OpenNextTablet(deadline, &blacklist));
    if (data_->data_in_open_) {
      // Avoid returning an empty batch in between tablets if we have data
      // we can return from this call.
      return NextBatch(batch_data);
    }
    return Status::OK();
  } else {
    // No more data anywhere.
    return Status::OK();
  }
}

Status KuduScanner::GetCurrentServer(KuduTabletServer** server) {
  CHECK(data_->open_);
  internal::RemoteTabletServer* rts = data_->ts_;
  CHECK(rts);
  vector<HostPort> host_ports;
  rts->GetHostPorts(&host_ports);
  if (host_ports.empty()) {
    return Status::IllegalState(Substitute(""No HostPort found for RemoteTabletServer $0"",
                                           rts->ToString()));
  }
  unique_ptr<KuduTabletServer> client_server(new KuduTabletServer);
  client_server->data_ = new KuduTabletServer::Data(rts->permanent_uuid(),
                                                    host_ports[0],
                                                    rts->location());
  *server = client_server.release();
  return Status::OK();
}

////////////////////////////////////////////////////////////
// KuduScanToken
////////////////////////////////////////////////////////////

KuduScanToken::KuduScanToken()
    : data_(nullptr) {
}

KuduScanToken::~KuduScanToken() {
  delete data_;
}

Status KuduScanToken::IntoKuduScanner(KuduScanner** scanner) const {
  return data_->IntoKuduScanner(scanner);
}

const KuduTablet& KuduScanToken::tablet() const {
  return data_->tablet();
}

Status KuduScanToken::Serialize(string* buf) const {
  return data_->Serialize(buf);
}

Status KuduScanToken::DeserializeIntoScanner(KuduClient* client,
                                             const string& serialized_token,
                                             KuduScanner** scanner) {
  return KuduScanToken::Data::DeserializeIntoScanner(
      client, serialized_token, scanner);
}

////////////////////////////////////////////////////////////
// KuduScanTokenBuilder
////////////////////////////////////////////////////////////

KuduScanTokenBuilder::KuduScanTokenBuilder(KuduTable* table)
    : data_(new KuduScanTokenBuilder::Data(table)) {
}

KuduScanTokenBuilder::~KuduScanTokenBuilder() {
  delete data_;
}

Status KuduScanTokenBuilder::SetProjectedColumnNames(const vector<string>& col_names) {
  return data_->mutable_configuration()->SetProjectedColumnNames(col_names);
}

Status KuduScanTokenBuilder::SetProjectedColumnIndexes(const vector<int>& col_indexes) {
  return data_->mutable_configuration()->SetProjectedColumnIndexes(col_indexes);
}

Status KuduScanTokenBuilder::SetBatchSizeBytes(uint32_t batch_size) {
  return data_->mutable_configuration()->SetBatchSizeBytes(batch_size);
}

Status KuduScanTokenBuilder::SetReadMode(KuduScanner::ReadMode read_mode) {
  if (!tight_enum_test<KuduScanner::ReadMode>(read_mode)) {
    return Status::InvalidArgument(""Bad read mode"");
  }
  return data_->mutable_configuration()->SetReadMode(read_mode);
}

Status KuduScanTokenBuilder::SetFaultTolerant() {
  return data_->mutable_configuration()->SetFaultTolerant(true);
}

Status KuduScanTokenBuilder::SetSnapshotMicros(uint64_t snapshot_timestamp_micros) {
  data_->mutable_configuration()->SetSnapshotMicros(snapshot_timestamp_micros);
  return Status::OK();
}

Status KuduScanTokenBuilder::SetDiffScan(uint64_t start_timestamp, uint64_t end_timestamp) {
  return data_->mutable_configuration()->SetDiffScan(start_timestamp, end_timestamp);
}

Status KuduScanTokenBuilder::SetSnapshotRaw(uint64_t snapshot_timestamp) {
  data_->mutable_configuration()->SetSnapshotRaw(snapshot_timestamp);
  return Status::OK();
}

Status KuduScanTokenBuilder::SetSelection(KuduClient::ReplicaSelection selection) {
  return data_->mutable_configuration()->SetSelection(selection);
}

Status KuduScanTokenBuilder::SetTimeoutMillis(int millis) {
  data_->mutable_configuration()->SetTimeoutMillis(millis);
  return Status::OK();
}

Status KuduScanTokenBuilder::IncludeTableMetadata(bool include_metadata) {
  data_->IncludeTableMetadata(include_metadata);
  return Status::OK();
}

Status KuduScanTokenBuilder::IncludeTabletMetadata(bool include_metadata) {
  data_->IncludeTabletMetadata(include_metadata);
  return Status::OK();
}

Status KuduScanTokenBuilder::AddConjunctPredicate(KuduPredicate* pred) {
  return data_->mutable_configuration()->AddConjunctPredicate(pred);
}

Status KuduScanTokenBuilder::AddLowerBound(const KuduPartialRow& key) {
  return data_->mutable_configuration()->AddLowerBound(key);
}

Status KuduScanTokenBuilder::AddUpperBound(const KuduPartialRow& key) {
  return data_->mutable_configuration()->AddUpperBound(key);
}

Status KuduScanTokenBuilder::SetCacheBlocks(bool cache_blocks) {
  return data_->mutable_configuration()->SetCacheBlocks(cache_blocks);
}

Status KuduScanTokenBuilder::Build(vector<KuduScanToken*>* tokens) {
  return data_->Build(tokens);
}

////////////////////////////////////////////////////////////
// KuduReplica
////////////////////////////////////////////////////////////

KuduReplica::KuduReplica()
  : data_(nullptr) {
}

KuduReplica::~KuduReplica() {
  delete data_;
}

bool KuduReplica::is_leader() const {
  return data_->is_leader_;
}

const KuduTabletServer& KuduReplica::ts() const {
  return *data_->ts_;
}

////////////////////////////////////////////////////////////
// KuduTablet
////////////////////////////////////////////////////////////

KuduTablet::KuduTablet()
  : data_(nullptr) {
}

KuduTablet::~KuduTablet() {
  delete data_;
}

const string& KuduTablet::id() const {
  return data_->id_;
}

const vector<const KuduReplica*>& KuduTablet::replicas() const {
  return data_->replicas_;
}

////////////////////////////////////////////////////////////
// KuduTabletServer
////////////////////////////////////////////////////////////

KuduTabletServer::KuduTabletServer()
  : data_(nullptr) {
}

KuduTabletServer::~KuduTabletServer() {
  delete data_;
}

const string& KuduTabletServer::uuid() const {
  return data_->uuid_;
}

const string& KuduTabletServer::hostname() const {
  return data_->hp_.host();
}

uint16_t KuduTabletServer::port() const {
  return data_->hp_.port();
}

const string& KuduTabletServer::location() const {
  return data_->location_;
}

////////////////////////////////////////////////////////////
// KuduPartitionerBuilder
////////////////////////////////////////////////////////////
KuduPartitionerBuilder::KuduPartitionerBuilder(sp::shared_ptr<KuduTable> table)
    : data_(new Data(std::move(table))) {
}

KuduPartitionerBuilder::~KuduPartitionerBuilder() {
  delete data_;
}

KuduPartitionerBuilder* KuduPartitionerBuilder::SetBuildTimeout(MonoDelta timeout) {
  data_->SetBuildTimeout(timeout);
  return this;
}

Status KuduPartitionerBuilder::Build(KuduPartitioner** partitioner) {
  return data_->Build(partitioner);
}

////////////////////////////////////////////////////////////
// KuduPartitioner
////////////////////////////////////////////////////////////
KuduPartitioner::KuduPartitioner(Data* data)
    : data_(CHECK_NOTNULL(data)) {
}

KuduPartitioner::~KuduPartitioner() {
  delete data_;
}

int KuduPartitioner::NumPartitions() const {
  return data_->num_partitions_;
}

Status KuduPartitioner::PartitionRow(const KuduPartialRow& row, int* partition) {
  return data_->PartitionRow(row, partition);
}

} // namespace client
} // namespace kudu
",16181,True,2631.7208527382872,median
"= `just`
:toc: macro
:toc-title:

image:https://img.shields.io/crates/v/just.svg[crates.io version,link=https://crates.io/crates/just]
image:https://github.com/casey/just/workflows/Build/badge.svg[build status,link=https://github.com/casey/just/actions]
image:https://img.shields.io/github/downloads/casey/just/total.svg[downloads,link=https://github.com/casey/just/releases]
image:https://img.shields.io/discord/695580069837406228?logo=discord[chat on discord,link=https://discord.gg/ezYScXR]
image:https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg[say thanks,link=mailto:casey@rodarmor.com?subject=Thanks for Just!]

`just` is a handy way to save and run project-specific commands.

(非官方中文文档,link:https://github.com/chinanf-boy/just-zh[这里],快看过来!)

Commands, called recipes, are stored in a file called `justfile` with syntax inspired by `make`:

image:screenshot.png[screenshot]

You can then run them with `just RECIPE`:

```sh
$ just test-all
cc *.c -o main
./test --all
Yay, all your tests passed!
```

`just` has a ton of useful features, and many improvements over `make`:

- `just` is a command runner, not a build system, so it avoids much of
  link:https://github.com/casey/just#what-are-the-idiosyncrasies-of-make-that-just-avoids[`make`'s
  complexity and idiosyncrasies]. No need for `.PHONY` recipes!

- Linux, MacOS, and Windows are supported with no additional dependencies. (Although if your system doesn't have an `sh`, you'll need to link:https://github.com/casey/just#shell[choose a different shell].)

- Errors are specific and informative, and syntax errors are reported along with their source context.

- Recipes can accept
  link:https://github.com/casey/just#recipe-parameters[command line arguments].

- Wherever possible, errors are resolved statically. Unknown recipes and
  circular dependencies are reported before anything runs.

- `just` link:https://github.com/casey/just#dotenv-integration[loads `.env`
  files], making it easy to populate environment variables.

- Recipes can be
  link:https://github.com/casey/just#listing-available-recipes[listed from the
  command line].

- Command line completion scripts are
  link:https://github.com/casey/just#shell-completion-scripts[available for
  most popular shells].

- Recipes can be written in
  link:https://github.com/casey/just#writing-recipes-in-other-languages[arbitrary
  languages], like Python or NodeJS.

- `just` can be invoked from any subdirectory, not just the directory that contains the `justfile`.

- And link:https://github.com/casey/just#manual[much more]!

If you need help with `just` please feel free to open an issue or ping me on link:https://discord.gg/ezYScXR[Discord]. Feature requests and bug reports are always welcome!

[discrete]
== Manual

toc::[]

== Installation

=== Prerequisites

`just` should run on any system with a reasonable `sh`, including Linux, MacOS, and the BSDs.

On Windows, `just` works with the `sh` provided by https://git-scm.com[Git for Windows], https://desktop.github.com[GitHub Desktop], or http://www.cygwin.com[Cygwin].

If you'd rather not install `sh`, you can use the `shell` setting to use the shell of your choice.

Like PowerShell:

```make

# use PowerShell instead of sh:
set shell := [""powershell.exe"", ""-c""]

hello:
  Write-Host ""Hello, world!""
```

…or `cmd.exe`:

```make

# use cmd.exe instead of sh:
set shell := [""cmd.exe"", ""/c""]

list:
  dir
```

(PowerShell is installed by default on Windows 7 SP1 and Windows Server 2008 R2 S1 and later, and `cmd.exe` is quite fiddly, so PowerShell is recommended for most Windows users.)

=== Packages

[cols=""1,1,1,1"", options=""header""]
|===
| Operating System
| Package Manager
| Package
| Command

| https://forge.rust-lang.org/release/platform-support.html[Various]
| https://www.rust-lang.org[Cargo]
| https://crates.io/crates/just[just]
| `cargo install just`

| https://en.wikipedia.org/wiki/Microsoft_Windows[Microsoft Windows]
| https://scoop.sh[Scoop]
| https://github.com/ScoopInstaller/Main/blob/master/bucket/just.json[just]
| `scoop install just`

| https://en.wikipedia.org/wiki/MacOS[macOS]
| https://brew.sh[Homebrew]
| https://formulae.brew.sh/formula/just[just]
| `brew install just`

| https://en.wikipedia.org/wiki/MacOS[macOS]
| https://www.macports.org[MacPorts]
| https://ports.macports.org/port/just/summary[just]
| `port install just`

| https://www.archlinux.org[Arch Linux]
| https://wiki.archlinux.org/title/Pacman[pacman]
| https://archlinux.org/packages/community/x86_64/just/[just]
| `pacman -S just`

| https://nixos.org/nixos/[NixOS],
  https://nixos.org/nix/manual/#ch-supported-platforms[Linux],
  https://nixos.org/nix/manual/#ch-supported-platforms[macOS]
| https://nixos.org/nix/[Nix]
| https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/tools/just/default.nix[just]
| `nix-env -iA nixos.just`

| https://getsol.us/[Solus]
| https://getsol.us/articles/package-management/basics/en[eopkg]
| https://dev.getsol.us/source/just/[just]
| `eopkg install just`

| https://voidlinux.org[Void Linux]
| https://wiki.voidlinux.org/XBPS[XBPS]
| https://github.com/void-linux/void-packages/blob/master/srcpkgs/just/template[just]
| `xbps-install -S just`

| https://www.freebsd.org/[FreeBSD]
| https://www.freebsd.org/doc/handbook/pkgng-intro.html[pkg]
| https://www.freshports.org/deskutils/just/[just]
| `pkg install just`

| https://alpinelinux.org/[Alpine Linux]
| https://wiki.alpinelinux.org/wiki/Alpine_Linux_package_management[apk-tools]
| https://pkgs.alpinelinux.org/package/edge/community/x86_64/just[just]
| `apk add just`

| https://getfedora.org/[Fedora Linux]
| https://dnf.readthedocs.io/en/latest/[DNF]
| https://src.fedoraproject.org/rpms/rust-just[just]
| `dnf install just`

| https://www.gentoo.org/[Gentoo Linux]
| https://wiki.gentoo.org/wiki/Portage[Portage]
| https://github.com/gentoo-mirror/dm9pZCAq/tree/master/sys-devel/just[dm9pZCAq overlay: sys-devel/just]
| `eselect repository enable dm9pZCAq && emerge --sync dm9pZCAq && emerge sys-devel/just`

| https://docs.conda.io/en/latest/miniconda.html#system-requirements[Various]
| https://docs.conda.io/projects/conda/en/latest/index.html[Conda]
| https://anaconda.org/conda-forge/just[just]
| `conda install -c conda-forge just`
|===

=== Pre-Built Binaries

Pre-built binaries for Linux, MacOS, and Windows can be found on https://github.com/casey/just/releases[the releases page].

You can use the following command on Linux, MacOS, or Windows to download the latest release, just replace `DEST` with the directory where you'd like to put `just`:

```sh
curl --proto '=https' --tlsv1.2 -sSf https://just.systems/install.sh | bash -s -- --to DEST
```

For example, to install `just` to `~/bin`:

```
# create `~/bin`
mkdir -p ~/bin

# download and extract `just` to `~/bin/just`
curl --proto '=https' --tlsv1.2 -sSf https://just.systems/install.sh | bash -s -- --to ~/bin

# add `~/bin` to the paths that your shell searches for executables
# this line should be added to your shells initialization file,
# e.g. `~/.bashrc` or `~/.zshrc`
export PATH=""$PATH:$HOME/bin""

# just should now be executable
just --help
```

=== GitHub Actions

link:https://github.com/extractions/setup-just[extractions/setup-just] can be used to install `just` in a GitHub Actions workflow.

Example usage:

```yaml
- uses: extractions/setup-just@v1
  with:
    just-version: 0.8  # optional semver specification, otherwise latest
```

=== Release RSS Feed

An https://en.wikipedia.org/wiki/RSS[RSS feed] of `just` releases is available https://github.com/casey/just/releases.atom[here].

== Editor Support

`justfile` syntax is close enough to `make` that you may want to tell your editor to use `make` syntax highlighting for `just`.

=== Vim and Neovim

==== `vim-just`

The https://github.com/NoahTheDuke/vim-just[vim-just] plugin provides syntax highlighting for justfiles.

Install it with your favorite package manager, like https://github.com/junegunn/vim-plug[Plug]:

```vim
call plug#begin()

Plug 'NoahTheDuke/vim-just'

call plug#end()
```

Or with Vim's built-in package support:

```
mkdir -p ~/.vim/pack/vendor/start
cd ~/.vim/pack/vendor/start
git clone https://github.com/NoahTheDuke/vim-just.git
```

`vim-just` is also available from https://github.com/sheerun/vim-polyglot[vim-polyglot], a multi-language Vim plugin.

==== `tree-sitter-just`

https://github.com/IndianBoy42/tree-sitter-just[tree-sitter-just] is an https://github.com/nvim-treesitter/nvim-treesitter[Nvim Treesitter] plugin for Neovim.

==== Makefile Syntax Highlighting

Vim's built-in makefile syntax highlighting isn't perfect for justfiles, but it's better than nothing. You can put the following in `~/.vim/filetype.vim`:

```vimscript
if exists(""did_load_filetypes"")
  finish
endif

augroup filetypedetect
  au BufNewFile,BufRead justfile setf make
augroup END
```

Or add the following to an individual justfile to enable `make` mode on a per-file basis:

```
# vim: set ft=make :
```

=== Emacs

https://github.com/leon-barrett/just-mode.el[just-mode] provides syntax highlighting and automatic indentation of justfiles. It is available on https://melpa.org/[MELPA] as https://melpa.org/#/just-mode[just-mode]

https://github.com/psibi/justl.el[justl] provides commands for executing and listing recipes.

You can add the following to an individual justfile to enable `make` mode on a per-file basis:

```
# Local Variables:
# mode: makefile
# End:
```

=== Visual Studio Code

An extension for VS Code by https://github.com/skellock[skellock] is https://marketplace.visualstudio.com/items?itemName=skellock.just[available here]. (https://github.com/skellock/vscode-just[repository])

You can install it from the command line by running:

```
code --install-extension skellock.just
```

=== Kakoune

Kakoune supports `justfile` syntax highlighting out of the box, thanks to TeddyDD.

=== Sublime Text

A syntax file for Sublime Text written by TonioGela is available in link:extras/just.sublime-syntax[extras/just.sublime-syntax].

=== Other Editors

Feel free to send me the commands necessary to get syntax highlighting working in your editor of choice so that I may include them here.

== Quick Start

See xref:Installation[] for how to install `just` on your computer. Try running `just --version` to make sure that it's installed correctly.

Once `just` is installed and working, create a file named `justfile` in the root of your project with the following contents:

```make
recipe-name:
    echo 'This is a recipe!'

# this is a comment
another-recipe:
    @echo 'This is another recipe.'
```

When you invoke `just` it looks for file `justfile` in the current directory and upwards, so you can invoke it from any subdirectory of your project.

The search for a `justfile` is case insensitive, so any case, like `Justfile`, `JUSTFILE`, or `JuStFiLe`, will work. `just` will also look for files with the name `.justfile`, in case you'd like to hide a `justfile`.

Running `just` with no arguments runs the first recipe in the `justfile`:

```sh
$ just
echo 'This is a recipe!'
This is a recipe!
```

One or more arguments specify the recipe(s) to run:

```sh
$ just another-recipe
This is another recipe.
```

`just` prints each command to standard error before running it, which is why `echo 'This is a recipe!'` was printed. This is suppressed for lines starting with `@`, which is why `echo 'Another recipe.'` was not printed.

Recipes stop running if a command fails. Here `cargo publish` will only run if `cargo test` succeeds:

```make
publish:
    cargo test
    # tests passed, time to publish!
    cargo publish
```

Recipes can depend on other recipes. Here the `test` recipe depends on the `build` recipe, so `build` will run before `test`:

```make
build:
    cc main.c foo.c bar.c -o main

test: build
    ./test

sloc:
    @echo ""`wc -l *.c` lines of code""
```

```sh
$ just test
cc main.c foo.c bar.c -o main
./test
testing... all tests passed!
```

Recipes without dependencies will run in the order they're given on the command line:

```sh
$ just build sloc
cc main.c foo.c bar.c -o main
1337 lines of code
```

Dependencies will always run first, even if they are passed after a recipe that depends on them:

```sh
$ just test build
cc main.c foo.c bar.c -o main
./test
testing... all tests passed!
```

== Examples

A variety of example justfiles can be found in the link:examples[examples directory].

This https://toniogela.dev/just/[blog post] discusses using `just` to improve management of shared machines, and includes a number of example justfiles.

== Features

=== Listing Available Recipes

Recipes can be listed in alphabetical order with `just --list`:

```sh
$ just --list
Available recipes:
    build
    test
    deploy
    lint
```

`just --summary` is more concise:

```sh
$ just --summary
build test deploy lint
```

Pass `--unsorted` to print recipes in the order they appear in the justfile:

```make
test:
  echo 'Testing!'

build:
  echo 'Building!'
```

```sh
$ just --list --unsorted
Available recipes:
    test
    build
```

```sh
$ just --summary --unsorted
test build
```

If you'd like `just` to default to listing the recipes in the justfile, you can
use this as your default recipe:

```make
default:
  @just --list
```

The heading text can be customized with `--list-heading`:

```
$ just --list --list-heading $'Cool stuff…\\n'
Cool stuff…
    test
    build
```

And the indentation can be customized with `--list-prefix`:

```
$ just --list --list-prefix ····
Available recipes:
····test
····build
```

The argument to `--list-heading` replaces both the heading and the newline
following it, so it should contain a newline if non-empty. It works this way so
you can suppress the heading line entirely by passing the empty string:

```
$ just --list --list-heading ''
    test
    build
```

=== Aliases

Aliases allow recipes to be invoked with alternative names:

```make
alias b := build

build:
  echo 'Building!'
```

```sh
$ just b
build
echo 'Building!'
Building!
```

=== Settings

Settings control interpretation and execution. Each setting may be specified at most once, anywhere in the justfile.

For example:

```make

set shell := [""zsh"", ""-cu""]

foo:
  # this line will be run as `zsh -cu 'ls **/*.txt'`
  ls **/*.txt
```

==== Table of Settings

[options=""header""]
|=================
| Name | Value | Description
| `dotenv-load` | boolean | Load a `.env` file, if present.
| `export` | boolean | Export all variables as environment variables.
| `positional-arguments` | boolean | Pass positional arguments.
| `shell` | `[COMMAND, ARGS...]` | Set the command used to invoke recipes and evaluate backticks.
|=================

Boolean settings can be written as:

```
set NAME
```

Which is equivalent to:

```
set NAME := true
```

==== Dotenv Load

If `dotenv-load` is `true`, a `.env` file will be loaded if present. Defaults to `true`.

==== Export

The `export` setting causes all `just` variables to be exported as environment variables. Defaults to `false`.

```make
set export

a := ""hello""

@foo b:
  echo $a
  echo $b
```

```
$ just foo goodbye
hello
goodbye
```

==== Positional Arguments

If `positional-arguments` is `true`, recipe arguments will be passed as positional arguments to commands. For linewise recipes, argument `$0` will be the name of the recipe.

For example, running this recipe:

```make
set positional-arguments

@foo bar:
  echo $0
  echo $1
```

Will produce the following output:

```
$ just foo hello
foo
hello
```

==== Shell

The `shell` setting controls the command used to invoke recipe lines and backticks. Shebang recipes are unaffected.

```make
# use python3 to execute recipe lines and backticks
set shell := [""python3"", ""-c""]

# use print to capture result of evaluation
foos := `print(""foo"" * 4)`

foo:
  print(""Snake snake snake snake."")
  print(""{{foos}}"")
```

`just` passes the command to be executed as an argument. Many shells will need an additional flag, often `-c`, to make them evaluate the first argument.

===== Python 3

```make
set shell := [""python3"", ""-c""]
```

===== Bash

```make
set shell := [""bash"", ""-uc""]
```

===== Z Shell

```make
set shell := [""zsh"", ""-uc""]
```

===== Fish

```make
set shell := [""fish"", ""-c""]
```

=== Documentation Comments

Comments immediately preceding a recipe will appear in `just --list`:

```make
# build stuff
build:
  ./bin/build

# test stuff
test:
  ./bin/test
```

```sh
$ just --list
Available recipes:
    build # build stuff
    test # test stuff
```

=== Variables and Substitution

Variables, strings, concatenation, and substitution using `{{...}}` are supported:

```make
version := ""0.2.7""
tardir  := ""awesomesauce-"" + version
tarball := tardir + "".tar.gz""

publish:
    rm -f {{tarball}}
    mkdir {{tardir}}
    cp README.md *.c {{tardir}}
    tar zcvf {{tarball}} {{tardir}}
    scp {{tarball}} me@server.com:release/
    rm -rf {{tarball}} {{tardir}}
```

==== Escaping `{{`

To write a recipe containing `{{`, use `{{{{`:

```make
braces:
    echo 'I {{{{LOVE}} curly braces!'
```

(An unmatched `}}` is ignored, so it doesn't need to be escaped.)

Another option is to put all the text you'd like to escape inside of an interpolation:

```make
braces:
    echo '{{'I {{LOVE}} curly braces!'}}'
```

Yet another option is to use `{{ ""{{"" }}`:

```make
braces:
    echo 'I {{ ""{{"" }}LOVE}} curly braces!'
```

=== Strings

Double-quoted strings support escape sequences:

```make
string-with-tab             := ""\\t""
string-with-newline         := ""\\n""
string-with-carriage-return := ""\\r""
string-with-double-quote    := ""\\""""
string-with-slash           := ""\\\\""
string-with-no-newline      := ""\\
""
```

```sh
$ just --evaluate
""tring-with-carriage-return := ""
string-with-double-quote    := """"""
string-with-newline         := ""
""
string-with-no-newline      := """"
string-with-slash           := ""\\""
string-with-tab             := ""     ""
```

Strings may contain line breaks:

```make
single := '
hello
'

double := ""
goodbye
""
```

Single-quoted strings do not recognize escape sequences:

```make
escapes := '\\t\\n\\r\\""\\\\'
```

```sh
$ just --evaluate
escapes := ""\\t\\n\\r\\""\\\\""
```

Indented versions of both single- and double-quoted strings, delimited by triple single- or triple double-quotes, are supported. Indented string lines are stripped of leading whitespace common to all non-blank lines:

```make
# this string will evaluate to `foo\\nbar\\n`
x := '''
  foo
  bar
'''

# this string will evaluate to `abc\\n  wuv\\nbar\\n`
y := """"""
  abc
    wuv
  xyz
""""""
```

Similar to unindented strings, indented double-quoted strings process escape sequences, and indented single-quoted strings ignore escape sequences. Escape sequence processing takes place after unindentation. The unindention algorithm does not take escape-sequence produced whitespace or newlines into account.

=== Ignoring Errors

Normally, if a command returns a non-zero exit status, execution will stop. To
continue execution after a command, even if it fails, prefix the command with
`-`:

```make
foo:
    -cat foo
    echo 'Done!'
```

```sh
$ just foo
cat foo
cat: foo: No such file or directory
echo 'Done!'
Done!
```

=== Functions

`just` provides a few built-in functions that might be useful when writing recipes.

==== System Information

- `arch()` – Instruction set architecture. Possible values are: `""aarch64""`, `""arm""`, `""asmjs""`, `""hexagon""`, `""mips""`, `""msp430""`, `""powerpc""`, `""powerpc64""`, `""s390x""`, `""sparc""`, `""wasm32""`, `""x86""`, `""x86_64""`, and `""xcore""`.

- `os()` – Operating system. Possible values are: `""android""`, `""bitrig""`, `""dragonfly""`, `""emscripten""`, `""freebsd""`, `""haiku""`, `""ios""`, `""linux""`, `""macos""`, `""netbsd""`, `""openbsd""`, `""solaris""`, and `""windows""`.

- `os_family()` – Operating system family; possible values are: `""unix""` and `""windows""`.

For example:

```make
system-info:
    @echo ""This is an {{arch()}} machine"".
```

```
$ just system-info
This is an x86_64 machine
```

==== Environment Variables

- `env_var(key)` – Retrieves the environment variable with name `key`, aborting if it is not present.

- `env_var_or_default(key, default)` – Retrieves the environment variable with name `key`, returning `default` if it is not present.

==== Invocation Directory

- `invocation_directory()` - Retrieves the path of the current working directory, before `just` changed it (chdir'd) prior to executing commands.

For example, to call `rustfmt` on files just under the ""current directory"" (from the user/invoker's perspective), use the following rule:

```
rustfmt:
    find {{invocation_directory()}} -name \\*.rs -exec rustfmt {} \\;
```

Alternatively, if your command needs to be run from the current directory, you could use (e.g.):

```
build:
    cd {{invocation_directory()}}; ./some_script_that_needs_to_be_run_from_here
```

==== Justfile and Justfile Directory

- `justfile()` - Retrieves the path of the current justfile.

- `justfile_directory()` - Retrieves the path of the parent directory of the current justfile.

For example, to run a command relative to the location of the current justfile:

```
script:
  ./{{justfile_directory()}}/scripts/some_script
```

==== Just Executable

- `just_executable()` - Absolute path to the `just` executable.

For example:

```make
executable:
    @echo The executable is at: {{just_executable()}}
```

```
$ just
The executable is at: /bin/just
```

==== String Manipulation

- `uppercase(s)` - Convert `s` to uppercase.
- `lowercase(s)` - Convert `s` to lowercase.
- `trim(s)` - Remove leading and trailing whitespace from `s`.
- `replace(s, from, to)` - Replace all occurrences of `from` in `s` to `to`.

==== Dotenv Integration

`just` will load environment variables from a file named `.env`. This file can be located in the same directory as your justfile or in a parent directory. These variables are environment variables, not `just` variables, and so must be accessed using `$VARIABLE_NAME` in recipes and backticks.

For example, if your `.env` file contains:

```
# a comment, will be ignored
DATABASE_ADDRESS=localhost:6379
SERVER_PORT=1337
```

And your justfile contains:

```make
serve:
  @echo ""Starting server with database $DATABASE_ADDRESS on port $SERVER_PORT...""
  ./server --database $DATABASE_ADDRESS --port $SERVER_PORT
```

`just serve` will output:

```sh
$ just serve
Starting server with database localhost:6379 on port 1337...
./server --database $DATABASE_ADDRESS --port $SERVER_PORT
```

==== Path Manipulation

===== Fallible

- `extension(path)` - Extension of `path`. `extension(""/foo/bar.txt"")` is `txt`.
- `file_name(path)` - File name of `path` with any leading directory components removed. `file_name(""/foo/bar.txt"")` is `bar.txt`.
- `file_stem(path)` - File name of `path` without extension. `file_stem(""/foo/bar.txt"")` is `bar`.
- `parent_directory(path)` - Parent directory of `path`. `parent_directory(""/foo/bar.txt"")` is `/foo`.
- `without_extension(path)` - `path` without extension. `without_extension(""/foo/bar.txt"")` is `/foo/bar`.

These functions can fail, for example if a path does not have an extension, which will halt execution.

===== Infallible

- `join(a, b)` - Join path `a` with path `b`. `join(""foo/bar"", ""baz"")` is `foo/bar/baz`.
- `clean(path)` - Simplify `path` by removing extra path separators, intermediate `.` components, and `..` where possible. `clean(""foo//bar"")` is `foo/bar`, `clean(""foo/.."")` is `.`, `clean(""foo/./bar"")` is `foo/bar`.

=== Command Evaluation Using Backticks

Backticks can be used to store the result of commands:

```make
localhost := `dumpinterfaces | cut -d: -f2 | sed 's/\\/.*//' | sed 's/ //g'`

serve:
    ./serve {{localhost}} 8080
```

Indented backticks, delimited by three backticks, are de-indented in the same manner as indented strings:

```make
# This backtick evaluates the command `echo foo\\necho bar\\n`, which produces the value `foo\\nbar\\n`.
stuff := ```
    echo foo
    echo bar
  ```
```

See the <<Strings>> section for details on unindenting.

Backticks may not start with `#!`. This syntax is reserved for a future upgrade.

=== Conditional Expressions

`if`/`else` expressions evaluate different branches depending on if two expressions evaluate to the same value:

```make
foo := if ""2"" == ""2"" { ""Good!"" } else { ""1984"" }

bar:
  @echo ""{{foo}}""
```

```sh
$ just bar
Good!
```

It is also possible to test for inequality:

```make
foo := if ""hello"" != ""goodbye"" { ""xyz"" } else { ""abc"" }

bar:
  @echo {{foo}}
```

```sh
$ just bar
xyz
```

And match against regular expressions:

```make
foo := if ""hello"" =~ 'hel+o' { ""match"" } else { ""mismatch"" }

bar:
  @echo {{foo}}
```

```sh
$ just bar
match
```

Regular expressions are provided by the https://github.com/rust-lang/regex[regex crate], whose syntax is documented on https://docs.rs/regex/1.5.4/regex/#syntax[docs.rs]. Since regular expressions commonly use backslash escape sequences, consider using single-quoted string literals, which will pass slashes to the regex parser unmolested.

Conditional expressions short-circuit, which means they only evaluate one of
their branches. This can be used to make sure that backtick expressions don't
run when they shouldn't.

```make
foo := if env_var(""RELEASE"") == ""true"" { `get-something-from-release-database` } else { ""dummy-value"" }
```

Conditionals can be used inside of recipes:

```make
bar foo:
  echo {{ if foo == ""bar"" { ""hello"" } else { ""goodbye"" } }}
```

Note the space after the final `}`! Without the space, the interpolation will
be prematurely closed.

Multiple conditionals can be chained:

```make
foo := if ""hello"" == ""goodbye"" {
  ""xyz""
} else if ""a"" == ""a"" {
  ""abc""
} else {
  ""123""
}

bar:
  @echo {{foo}}
```

```sh
$ just bar
abc
```

=== Setting Variables from the Command Line

Variables can be overridden from the command line.

```make
os := ""linux""

test: build
    ./test --test {{os}}

build:
    ./build {{os}}
```

```sh
$ just
./build linux
./test --test linux
```

Any number of arguments of the form `NAME=VALUE` can be passed before recipes:

```sh
$ just os=plan9
./build plan9
./test --test plan9
```

Or you can use the `--set` flag:

```sh
$ just --set os bsd
./build bsd
./test --test bsd
```

=== Environment Variables

Assignments prefixed with the `export` keyword will be exported to recipes as environment variables:

```make
export RUST_BACKTRACE := ""1""

test:
    # will print a stack trace if it crashes
    cargo test
```

Parameters prefixed with a `$` will be exported as environment variables:

```make
test $RUST_BACKTRACE=""1"":
    # will print a stack trace if it crashes
    cargo test
```

Exported variables and parameters are not exported to backticks in the same scope.

```make
export WORLD := ""world""
# This backtick will fail with ""WORLD: unbound variable""
BAR := `echo hello $WORLD`
```

```make
# Running `just a foo` will fail with ""A: unbound variable""
a $A $B=`echo $A`:
  echo $A $B
```

=== Recipe Parameters

Recipes may have parameters. Here recipe `build` has a parameter called `target`:

```make
build target:
    @echo 'Building {{target}}...'
    cd {{target}} && make
```

To pass arguments on the command line, put them after the recipe name:

```sh
$ just build my-awesome-project
Building my-awesome-project...
cd my-awesome-project && make
```

To pass arguments to a dependency, put the dependency in parentheses along with the arguments:

```make
default: (build ""main"")

build target:
  @echo 'Building {{target}}...'
  cd {{target}} && make
```

Parameters may have default values:

```make
default := 'all'

test target tests=default:
    @echo 'Testing {{target}}:{{tests}}...'
    ./test --tests {{tests}} {{target}}
```

Parameters with default values may be omitted:

```sh
$ just test server
Testing server:all...
./test --tests all server
```

Or supplied:

```sh
$ just test server unit
Testing server:unit...
./test --tests unit server
```

Default values may be arbitrary expressions, but concatenations must be parenthesized:

```make
arch := ""wasm""

test triple=(arch + ""-unknown-unknown""):
  ./test {{triple}}
```

The last parameter of a recipe may be variadic, indicated with either a `+` or a `*` before the argument name:

```make
backup +FILES:
  scp {{FILES}} me@server.com:
```

Variadic parameters prefixed with `+` accept _one or more_ arguments and expand to a string containing those arguments separated by spaces:

```sh
$ just backup FAQ.md GRAMMAR.md
scp FAQ.md GRAMMAR.md me@server.com:
FAQ.md                  100% 1831     1.8KB/s   00:00
GRAMMAR.md              100% 1666     1.6KB/s   00:00
```

Variadic parameters prefixed with `*` accept _zero or more_ arguments and expand to a string containing those arguments separated by spaces, or an empty string if no arguments are present:

```make
commit MESSAGE *FLAGS:
  git commit {{FLAGS}} -m ""{{MESSAGE}}""
```

Variadic parameters can be assigned default values. These are overridden by arguments passed on the command line:

```make
test +FLAGS='-q':
  cargo test {{FLAGS}}
```

`{{...}}` substitutions may need to be quoted if they contain spaces. For example, if you have the following recipe:

```make
search QUERY:
    lynx https://www.google.com/?q={{QUERY}}
```

And you type:

```sh
$ just search ""cat toupee""
```

`just` will run the command `lynx https://www.google.com/?q=cat toupee`, which will get parsed by `sh` as `lynx`, `https://www.google.com/?q=cat`, and `toupee`, and not the intended `lynx` and `https://www.google.com/?q=cat toupee`.

You can fix this by adding quotes:

```make
search QUERY:
    lynx 'https://www.google.com/?q={{QUERY}}'
```

Parameters prefixed with a `$` will be exported as environment variables:

```make
foo $bar:
  echo $bar
```

=== Running Recipes at the End of a Recipe

Normal dependencies of a recipes always run before a recipe starts. That is to say, the dependee always runs before the depender. These dependencies are called ""prior dependencies"".

A recipe can also have subsequent dependencies, which run after the recipe and are introduced with an `&&`:


```make
a:
  echo 'A!'

b: a && c d
  echo 'B!'

c:
  echo 'C!'

d:
  echo 'D!'
```

…running 'b' prints:

```sh
$ just b
echo 'A!'
A!
echo 'B!'
B!
echo 'C!'
C!
echo 'D!'
D!
```

=== Running Recipes in the Middle of a Recipe

`just` doesn't support running recipes in the middle of another recipe, but you can call `just` recursively in the middle of a recipe. Given the following justfile:

```make
a:
  echo 'A!'

b: a
  echo 'B start!'
  just c
  echo 'B end!'

c:
  echo 'C!'
```

…running 'b' prints:

```sh
$ just b
echo 'A!'
A!
echo 'B start!'
B start!
echo 'C!'
C!
echo 'B end!'
B end!
```

This has limitations, since recipe `c` is run with an entirely new invocation of `just`: Assignments will be recalculated, dependencies might run twice, and command line arguments will not be propagated to the child `just` process.

=== Writing Recipes in Other Languages

Recipes that start with a `#!` are executed as scripts, so you can write recipes in other languages:

```make
polyglot: python js perl sh ruby

python:
    #!/usr/bin/env python3
    print('Hello from python!')

js:
    #!/usr/bin/env node
    console.log('Greetings from JavaScript!')

perl:
    #!/usr/bin/env perl
    print ""Larry Wall says Hi!\\n"";

sh:
    #!/usr/bin/env sh
    hello='Yo'
    echo ""$hello from a shell script!""

ruby:
    #!/usr/bin/env ruby
    puts ""Hello from ruby!""
```

```sh
$ just polyglot
Hello from python!
Greetings from JavaScript!
Larry Wall says Hi!
Yo from a shell script!
Hello from ruby!
```

=== Safer Bash Shebang Recipes

If you're writing a `bash` shebang recipe, consider adding `set -euxo pipefail`:

```make
foo:
    #!/usr/bin/env bash
    set -euxo pipefail
    hello='Yo'
    echo ""$hello from Bash!""
```

It isn't strictly necessary, but `set -euxo pipefail` turns on a few useful
features that make `bash` shebang recipes behave more like normal, linewise `just`
recipe:

- `set -e` makes `bash` exit if a command fails.
- `set -u` makes `bash` exit if a variable is undefined.
- `set -x` makes `bash` print each script line before it's run.
- `set -o pipefail` makes `bash` exit if a command in a pipeline fails.

Together, these avoid a lot of shell scripting gotchas.

==== Shebang Recipe Execution on Windows

On Windows, shebang interpreter paths containing a `/` are translated from Unix-style
paths to Windows-style paths using `cygpath`, a utility that ships with http://www.cygwin.com[Cygwin].

For example, to execute this recipe on Windows:

```make
echo:
  #!/bin/sh

  echo ""Hello!""
```

The interpreter path `/bin/sh` will be translated to a Windows-style path using
`cygpath` before being executed.

If the interpreter path does not contain a `/` it will be executed without being translated. This is useful if `cygpath` is not available, or you wish to pass a Windows-style path to the interpreter.

=== Setting Variables in a Recipe

Recipe lines are interpreted by the shell, not `just`, so it's not possible to set
`just` variables in the middle of a recipe:

```
foo:
  x := ""hello"" # This doesn't work!
  echo {{x}}
```

It is possible to use shell variables, but there's another problem. Every
recipe line is run by a new shell instance, so variables set in one line won't
be set in the next:

```make
foo:
  x=hello && echo $x # This works!
  y=bye
  echo $y            # This doesn't, `y` is undefined here!
```

The best way to work around this is to use a shebang recipe. Shebang recipe
bodies are extracted and run as scripts, so a single shell instance will run
the whole thing:

```make
foo:
  #!/usr/bin/env bash
  set -euxo pipefail
  x=hello
  echo $x
```

=== Changing the Working Directory in a Recipe

Each recipe line is executed by a new shell, so if you change the working
directory on one line, it won't have an effect on later lines:

```make
foo:
  pwd    # This `pwd` will print the same directory…
  cd bar
  pwd    # …as this `pwd`!
```

There are a couple ways around this. One is to call `cd` on the same line as
the command you want to run:

```make
foo:
  cd bar && pwd
```

The other is to use a shebang recipe. Shebang recipe bodies are extracted and
run as scripts, so a single shell instance will run the whole thing, and thus a
`pwd` on one line will affect later lines, just like a shell script:

```make
foo:
  #!/usr/bin/env bash
  set -euxo pipefail
  cd bar
  pwd
```

=== Multi-Line Constructs

Recipes without an initial shebang are evaluated and run line-by-line, which means that multi-line constructs probably won't do what you want.

For example, with the following justfile:

```
conditional:
    if true; then
        echo 'True!'
    fi
```

The extra leading whitespace before the second line of the `conditional` recipe will produce a parse error:

```
$ just conditional
error: Recipe line has extra leading whitespace
  |
3 |         echo 'True!'
  |     ^^^^^^^^^^^^^^^^
```

To work around this, you can write conditionals on one line, escape newlines with slashes, or add a shebang to your recipe. Some examples of multi-line constructs are provided for reference.

==== `if` statements

```make
conditional:
    if true; then echo 'True!'; fi
```

```make
conditional:
    if true; then \\
        echo 'True!'; \\
    fi
```

```make
conditional:
    #!/usr/bin/env sh
    if true; then
        echo 'True!'
    fi
```

==== `for` loops

```make
for:
    for file in `ls .`; do echo $file; done
```

```make
for:
    for file in `ls .`; do \\
        echo $file; \\
    done
```

```make
for:
    #!/usr/bin/env sh
    for file in `ls .`; do
        echo $file
    done
```

==== `while` loops

```make
while:
    while `server-is-dead`; do ping -c 1 server; done
```

```make
while:
    while `server-is-dead`; do \\
        ping -c 1 server; \\
    done
```

```make
while:
    #!/usr/bin/env sh
    while `server-is-dead`; do
        do ping -c 1 server
    done
```


=== Command Line Options

`just` supports a number of useful command line options for listing, dumping, and debugging recipes and variable:

```sh
$ just --list
Available recipes:
  js
  perl
  polyglot
  python
  ruby
$ just --show perl
perl:
    #!/usr/bin/env perl
    print ""Larry Wall says Hi!\\n"";
$ just --show polyglot
polyglot: python js perl sh ruby
```

Run `just --help` to see all the options.

=== Private Recipes

Recipes and aliases whose name starts with a `_` are omitted from `just --list`:

```make
test: _test-helper
  ./bin/test

_test-helper:
  ./bin/super-secret-test-helper-stuff
```

```sh
$ just --list
Available recipes:
    test
```

And from `just --summary`:

```sh
$ just --summary
test
```

This is useful for helper recipes which are only meant to be used as dependencies of other recipes.

=== Quiet Recipes

A recipe name may be prefixed with '@' to invert the meaning of '@' before each line:

```make
@quiet:
  echo hello
  echo goodbye
  @# all done!
```

Now only the lines starting with '@' will be echoed:

```sh
$ j quiet
hello
goodbye
# all done!
```

Shebang recipes are quiet by default:

```make
foo:
  #!/usr/bin/env bash
  echo 'Foo!'
```

```sh
$ just foo
Foo!
```

Adding `@` to a shebang recipe name makes `just` print the recipe before executing it:


```make
@bar:
  #!/usr/bin/env bash
  echo 'Bar!'
```

```sh
$ just bar                                                                                    ~/src/just
#!/usr/bin/env bash
echo 'Bar!'
Bar!
```

=== Selecting Recipes to Run With an Interactive Chooser

The `--choose` subcommand makes `just` invoke a chooser to select which recipes
to run. Choosers should read lines containing recipe names from standard input
and print one or more of those names separated by spaces to standard output.

Because there is currently no way to run a recipe that requires arguments with
`--choose`, such recipes will not be given to the chooser. Private recipes and
aliases are also skipped.

The chooser can be overridden with the `--chooser` flag. If `--chooser` is not
given, then `just` first checks if `$JUST_CHOOSER` is set. If it isn't, then
the chooser defaults to `fzf`, a popular fuzzy finder.

Arguments can be included in the chooser, i.e. `fzf --exact`.

The chooser is invoked in the same way as recipe lines. For example, if the
chooser is `fzf`, it will be invoked with `sh -cu 'fzf'`, and if the shell, or
the shell arguments are overridden, the chooser invocation will respect those
overrides.

If you'd like `just` to default to selecting recipes with a chooser, you can
use this as your default recipe:

```make
default:
  @just --choose
```

=== Invoking Justfiles in Other Directories

If the first argument passed to `just` contains a `/`, then the following occurs:

1. The argument is split at the last `/`.
2. The part before the last `/` is treated as a directory. `just` will start its search for the justfile there, instead of in the current directory.
3. The part after the last slash is treated as a normal argument, or ignored if it is empty.

This may seem a little strange, but it's useful if you wish to run a command in a justfile that is in a subdirectory.

For example, if you are in a directory which contains a subdirectory named `foo`, which contains a justfile with the recipe `build`, which is also the default recipe, the following are all equivalent:

```sh
$ (cd foo && just build)
$ just foo/build
$ just foo/
```

=== Hiding Justfiles

`just` looks for justfiles named `justfile` and `.justfile`, which can be used to keep a `justfile` hidden.

=== Just Scripts

By adding a shebang line to the top of a justfile and making it executable, `just` can be used as an interpreter for scripts:

```sh
$ cat > script <<EOF
#!/usr/bin/env just --justfile

foo:
  echo foo
EOF
$ chmod +x script
$ ./script foo
echo foo
foo
```

When a script with a shebang is executed, the system supplies the path to the script as an argument to the command in the shebang. So, with a shebang of `#!/usr/bin/env just --justfile`, the command will be `/usr/bin/env just --justfile PATH_TO_SCRIPT`.

With the above shebang, `just` will change its working directory to the location of the script. If you'd rather leave the working directory unchanged, use `#!/usr/bin/env just --working-directory . --justfile`.

Note: Shebang line splitting is not consistent across operating systems. The previous examples have only been tested on macOS. On Linux, you may need to pass the `-S` flag to `env`:

```
#!/usr/bin/env -S just --justfile

default:
  echo foo
```

=== Changelog

A changelog for the latest release is available in link:CHANGELOG.md[]. Changelogs for previous releases are avaiable on https://github.com/casey/just/releases[the releases page]. `just --changelog` can also be used to make a `just` binary print its changelog.

== Miscellanea

=== Companion Tools

Tools that pair nicely with `just` include:

- https://github.com/mattgreen/watchexec[`watchexec`] — a simple tool that watches a path and runs a command whenever it detects modifications.

=== Shell Alias

For lightning-fast command running, put `alias j=just` in your shell's configuration file.

=== Shell Completion Scripts

Shell completion scripts for Bash, Zsh, Fish, PowerShell, and Elvish are available in the link:completions[] directory. Please refer to your shell's documentation for how to install them.

The `just` binary can also generate the same completion scripts at runtime, using the `--completions` command:

```sh
$ just --completions zsh > just.zsh
```

=== Grammar

A non-normative grammar of justfiles can be found in link:GRAMMAR.md[].

=== just.sh

Before `just` was a fancy Rust program it was a tiny shell script that called `make`. You can find the old version in link:extras/just.sh[].

=== Non-Project Specific Justfile

If you want some commands to be available everywhere, put them in `~/.global.justfile` and add the following to your shell's initialization file:

```sh
alias .j='just --justfile ~/.global.justfile --working-directory ~'
```

Or, if you'd rather they run in the current directory:

```sh
alias .j='just --justfile ~/.global.justfile --working-directory .'
```

I'm pretty sure that nobody actually uses this feature, but it's there.

¯\\\\_(ツ)_/¯

== Contributing

`just` welcomes your contributions! `just` is released under the maximally permissive https://creativecommons.org/publicdomain/zero/1.0/legalcode.txt[CC0] public domain dedication and fallback license, so your changes must also be released under this license.

=== Janus

https://github.com/casey/janus[Janus] is a tool that collects and analyzes justfiles, and can determine if a new version of `just` breaks or changes the interpretation of existing justfiles.

Before merging a particularly large or gruesome change, Janus should be run to make sure that nothing breaks. Don't worry about running Janus yourself, Casey will happily run it for you on changes that need it.

=== Minimum Supported Rust Version

The minimum supported Rust version, or MSRV, can be found in link:rust-toolchain[].

== Frequently Asked Questions

=== What are the idiosyncrasies of Make that Just avoids?

`make` has some behaviors which are confusing, complicated, or make it unsuitable for use as a general command runner.

One example is that under some circumstances, `make` won't actually run the commands in a recipe. For example, if you have a file called `test` and the following makefile:

```make
test:
  ./test
```

`make` will refuse to run your tests:

```sh
$ make test
make: `test' is up to date.
```

`make` assumes that the `test` recipe produces a file called `test`. Since this file exists and the recipe has no other dependencies, `make` thinks that it doesn't have anything to do and exits.

To be fair, this behavior is desirable when using `make` as a build system, but not when using it as a command runner. You can disable this behavior for specific targets using `make`'s built-in link:https://www.gnu.org/software/make/manual/html_node/Phony-Targets.html[`.PHONY` target name], but the syntax is verbose and can be hard to remember. The explicit list of phony targets, written separately from the recipe definitions, also introduces the risk of accidentally defining a new non-phony target. In `just`, all recipes are treated as if they were phony.

Other examples of `make`'s idiosyncrasies include the difference between `=` and `:=` in assignments, the confusing error messages that are produced if you mess up your makefile, needing `$$` to use environment variables in recipes, and incompatibilities between different flavors of `make`.

=== What's the relationship between Just and Cargo build scripts?

http://doc.crates.io/build-script.html[`cargo` build scripts] have a pretty specific use, which is to control how `cargo` builds your Rust project. This might include adding flags to `rustc` invocations, building an external dependency, or running some kind of codegen step.

`just`, on the other hand, is for all the other miscellaneous commands you might run as part of development. Things like running tests in different configurations, linting your code, pushing build artifacts to a server, removing temporary files, and the like.

Also, although `just` is written in Rust, it can be used regardless of the language or build system your project uses.

== Further Ramblings

I personally find it very useful to write a `justfile` for almost every project, big or small.

On a big project with multiple contributors, it's very useful to have a file with all the commands needed to work on the project close at hand.

There are probably different commands to test, build, lint, deploy, and the like, and having them all in one place is useful and cuts down on the time you have to spend telling people which commands to run and how to type them.

And, with an easy place to put commands, it's likely that you'll come up with other useful things which are part of the project's collective wisdom, but which aren't written down anywhere, like the arcane commands needed for some part of your revision control workflow, install all your project's dependencies, or all the random flags you might need to pass to the build system.

Some ideas for recipes:

* Deploying/publishing the project
* Building in release mode vs debug mode
* Running in debug mode or with logging enabled
* Complex git workflows
* Updating dependencies
* Running different sets of tests, for example fast tests vs slow tests, or running them with verbose output
* Any complex set of commands that you really should write down somewhere, if only to be able to remember them

Even for small, personal projects it's nice to be able to remember commands by name instead of ^Reverse searching your shell history, and it's a huge boon to be able to go into an old project written in a random language with a mysterious build system and know that all the commands you need to do whatever you need to do are in the `justfile`, and that if you type `just` something useful (or at least interesting!) will probably happen.

For ideas for recipes, check out link:justfile[this project's `justfile`], or some of the `justfile`{zwsp}s https://github.com/search?o=desc&q=filename%3Ajustfile&s=indexed&type=Code[out in the wild].

Anyways, I think that's about it for this incredibly long-winded README.

I hope you enjoy using `just` and find great success and satisfaction in all your computational endeavors!

😸
",12451,False,1938.4256326947811,median
"[[debezium-mysql-component]]
= Debezium MySQL Connector Component
//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
:page-source: components/camel-debezium-mysql/src/main/docs/debezium-mysql-component.adoc
:docTitle: Debezium MySQL Connector
:artifactId: camel-debezium-mysql
:description: Capture changes from a MySQL database.
:since: 3.0
:supportLevel: Stable
:component-header: Only consumer is supported
include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/debezium-mysql.adoc[opts=optional]

*Since Camel {since}*

*{component-header}*

The Debezium MySQL component is wrapper around https://debezium.io/[Debezium] using https://debezium.io/documentation/reference/0.9/operations/embedded.html[Debezium Embedded], which enables Change Data Capture from MySQL database using Debezium without the need for Kafka or Kafka Connect.

*Note on handling failures:* Per https://debezium.io/documentation/reference/0.9/operations/embedded.html#_handling_failures[Debezium Embedded Engine] documentation, the engines is actively recording source offsets and periodically flushes these offsets to a persistent storage, so when the application is restarted or crashed, the engine will resume from the last recorded offset.
Thus, at normal operation, your downstream routes will receive each event exactly once, however in case of an application crash (not having a graceful shutdown), the application will resume from the last recorded offset,
which may result in receiving duplicate events immediately after the restart. Therefore, your downstream routes should be tolerant enough of such case and deduplicate events if needed.

*Note:* The Debezium MySQL component is currently not supported in OSGi

Maven users will need to add the following dependency to their `pom.xml`
for this component.

[source,xml]
----
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-debezium-mysql</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
----

== URI format

[source,text]
---------------------------
debezium-mysql:name[?options]
---------------------------

*Note:* Due to licensing issues, you will need to add the dependency for `mysql-conenctor-java` if you are using MySQL connector, just add the following to your POM file:
[source,xml]
----
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.15</version>
</dependency>
----

== Options


// component options: START
The Debezium MySQL Connector component supports 79 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *additionalProperties* (common) | Additional properties for debezium components in case they can't be set directly on the camel configurations (e.g: setting Kafka Connect properties needed by Debezium engine, for example setting KafkaOffsetBackingStore), the properties have to be prefixed with additionalProperties.. E.g: additionalProperties.transactional.id=12345&additionalProperties.schema.registry.url=\\http://localhost:8811/avro |  | Map
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *configuration* (consumer) | Allow pre-configured Configurations to be set. |  | MySqlConnectorEmbeddedDebeziumConfiguration
| *internalKeyConverter* (consumer) | The Converter class that should be used to serialize and deserialize key data for offsets. The default is JSON converter. | org.apache.kafka.connect.json.JsonConverter | String
| *internalValueConverter* (consumer) | The Converter class that should be used to serialize and deserialize value data for offsets. The default is JSON converter. | org.apache.kafka.connect.json.JsonConverter | String
| *offsetCommitPolicy* (consumer) | The name of the Java class of the commit policy. It defines when offsets commit has to be triggered based on the number of events processed and the time elapsed since the last commit. This class must implement the interface 'OffsetCommitPolicy'. The default is a periodic commit policy based upon time intervals. | io.debezium.embedded.spi.OffsetCommitPolicy.PeriodicCommitOffsetPolicy | String
| *offsetCommitTimeoutMs* (consumer) | Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt. The default is 5 seconds. | 5s | long
| *offsetFlushIntervalMs* (consumer) | Interval at which to try committing offsets. The default is 1 minute. | 60s | long
| *offsetStorage* (consumer) | The name of the Java class that is responsible for persistence of connector offsets. | org.apache.kafka.connect.storage.FileOffsetBackingStore | String
| *offsetStorageFileName* (consumer) | Path to file where offsets are to be stored. Required when offset.storage is set to the FileOffsetBackingStore. |  | String
| *offsetStoragePartitions* (consumer) | The number of partitions used when creating the offset storage topic. Required when offset.storage is set to the 'KafkaOffsetBackingStore'. |  | int
| *offsetStorageReplicationFactor* (consumer) | Replication factor used when creating the offset storage topic. Required when offset.storage is set to the KafkaOffsetBackingStore |  | int
| *offsetStorageTopic* (consumer) | The name of the Kafka topic where offsets are to be stored. Required when offset.storage is set to the KafkaOffsetBackingStore. |  | String
| *basicPropertyBinding* (advanced) | *Deprecated* Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
| *bigintUnsignedHandlingMode* (mysql) | Specify how BIGINT UNSIGNED columns should be represented in change events, including:'precise' uses java.math.BigDecimal to represent values, which are encoded in the change events using a binary representation and Kafka Connect's 'org.apache.kafka.connect.data.Decimal' type; 'long' (the default) represents values using Java's 'long', which may not offer the precision but will be far easier to use in consumers. | long | String
| *binaryHandlingMode* (mysql) | Specify how binary (blob, binary, etc.) columns should be represented in change events, including:'bytes' represents binary data as byte array (default)'base64' represents binary data as base64-encoded string'hex' represents binary data as hex-encoded (base16) string | bytes | String
| *binlogBufferSize* (mysql) | The size of a look-ahead buffer used by the binlog reader to decide whether the transaction in progress is going to be committed or rolled back. Use 0 to disable look-ahead buffering. Defaults to 0 (i.e. buffering is disabled). | 0 | int
| *columnBlacklist* (mysql) | Regular expressions matching columns to exclude from change events (deprecated, use column.exclude.list instead) |  | String
| *columnExcludeList* (mysql) | Regular expressions matching columns to exclude from change events |  | String
| *columnIncludeList* (mysql) | Regular expressions matching columns to include in change events |  | String
| *connectKeepAlive* (mysql) | Whether a separate thread should be used to ensure the connection is kept alive. | true | boolean
| *connectKeepAliveIntervalMs* (mysql) | Interval in milliseconds to wait for connection checking if keep alive thread is used. | 1m | long
| *connectTimeoutMs* (mysql) | Maximum time in milliseconds to wait after trying to connect to the database before timing out. | 30s | int
| *databaseExcludeList* (mysql) | A comma-separated list of regular expressions that match database names to be excluded from monitoring |  | String
| *databaseHistory* (mysql) | The name of the DatabaseHistory class that should be used to store and recover database schema changes. The configuration properties for the history are prefixed with the 'database.history.' string. | io.debezium.relational.history.FileDatabaseHistory | String
| *databaseHistoryFileFilename* (mysql) | The path to the file that will be used to record the database history |  | String
| *databaseHistoryKafkaBootstrap{zwsp}Servers* (mysql) | A list of host/port pairs that the connector will use for establishing the initial connection to the Kafka cluster for retrieving database schema history previously stored by the connector. This should point to the same Kafka cluster used by the Kafka Connect process. |  | String
| *databaseHistoryKafkaRecovery{zwsp}Attempts* (mysql) | The number of attempts in a row that no data are returned from Kafka before recover completes. The maximum amount of time to wait after receiving no data is (recovery.attempts) x (recovery.poll.interval.ms). | 100 | int
| *databaseHistoryKafkaRecovery{zwsp}PollIntervalMs* (mysql) | The number of milliseconds to wait while polling for persisted data during recovery. | 100ms | int
| *databaseHistoryKafkaTopic* (mysql) | The name of the topic for the database schema history |  | String
| *databaseHistorySkipUnparseable{zwsp}Ddl* (mysql) | Controls the action Debezium will take when it meets a DDL statement in binlog, that it cannot parse.By default the connector will stop operating but by changing the setting it can ignore the statements which it cannot parse. If skipping is enabled then Debezium can miss metadata changes. | false | boolean
| *databaseHistoryStoreOnly{zwsp}MonitoredTablesDdl* (mysql) | Controls what DDL will Debezium store in database history.By default (false) Debezium will store all incoming DDL statements. If set to truethen only DDL that manipulates a monitored table will be stored. | false | boolean
| *databaseHostname* (mysql) | Resolvable hostname or IP address of the MySQL database server. |  | String
| *databaseIncludeList* (mysql) | The databases for which changes are to be captured |  | String
| *databaseInitialStatements* (mysql) | A semicolon separated list of SQL statements to be executed when a JDBC connection (not binlog reading connection) to the database is established. Note that the connector may establish JDBC connections at its own discretion, so this should typically be used for configuration of session parameters only,but not for executing DML statements. Use doubled semicolon (';;') to use a semicolon as a character and not as a delimiter. |  | String
| *databaseJdbcDriver* (mysql) | JDBC Driver class name used to connect to the MySQL database server. | class com.mysql.cj.jdbc.Driver | String
| *databasePassword* (mysql) | *Required* Password of the MySQL database user to be used when connecting to the database. |  | String
| *databasePort* (mysql) | Port of the MySQL database server. | 3306 | int
| *databaseServerId* (mysql) | A numeric ID of this database client, which must be unique across all currently-running database processes in the cluster. This connector joins the MySQL database cluster as another server (with this unique ID) so it can read the binlog. By default, a random number is generated between 5400 and 6400. |  | long
| *databaseServerIdOffset* (mysql) | Only relevant if parallel snapshotting is configured. During parallel snapshotting, multiple (4) connections open to the database client, and they each need their own unique connection ID. This offset is used to generate those IDs from the base configured cluster ID. | 10000 | long
| *databaseServerName* (mysql) | *Required* Unique name that identifies the database server and all recorded offsets, and that is used as a prefix for all schemas and topics. Each distinct installation should have a separate namespace and be monitored by at most one Debezium connector. |  | String
| *databaseSslKeystore* (mysql) | Location of the Java keystore file containing an application process's own certificate and private key. |  | String
| *databaseSslKeystorePassword* (mysql) | Password to access the private key from the keystore file specified by 'ssl.keystore' configuration property or the 'javax.net.ssl.keyStore' system or JVM property. This password is used to unlock the keystore file (store password), and to decrypt the private key stored in the keystore (key password). |  | String
| *databaseSslMode* (mysql) | Whether to use an encrypted connection to MySQL. Options include'disabled' (the default) to use an unencrypted connection; 'preferred' to establish a secure (encrypted) connection if the server supports secure connections, but fall back to an unencrypted connection otherwise; 'required' to use a secure (encrypted) connection, and fail if one cannot be established; 'verify_ca' like 'required' but additionally verify the server TLS certificate against the configured Certificate Authority (CA) certificates, or fail if no valid matching CA certificates are found; or'verify_identity' like 'verify_ca' but additionally verify that the server certificate matches the host to which the connection is attempted. | disabled | String
| *databaseSslTruststore* (mysql) | Location of the Java truststore file containing the collection of CA certificates trusted by this application process (trust store). |  | String
| *databaseSslTruststorePassword* (mysql) | Password to unlock the keystore file (store password) specified by 'ssl.trustore' configuration property or the 'javax.net.ssl.trustStore' system or JVM property. |  | String
| *databaseUser* (mysql) | Name of the MySQL database user to be used when connecting to the database. |  | String
| *decimalHandlingMode* (mysql) | Specify how DECIMAL and NUMERIC columns should be represented in change events, including:'precise' (the default) uses java.math.BigDecimal to represent values, which are encoded in the change events using a binary representation and Kafka Connect's 'org.apache.kafka.connect.data.Decimal' type; 'string' uses string to represent values; 'double' represents values using Java's 'double', which may not offer the precision but will be far easier to use in consumers. | precise | String
| *enableTimeAdjuster* (mysql) | MySQL allows user to insert year value as either 2-digit or 4-digit. In case of two digit the value is automatically mapped into 1970 - 2069.false - delegates the implicit conversion to the databasetrue - (the default) Debezium makes the conversion | true | boolean
| *eventDeserializationFailure{zwsp}HandlingMode* (mysql) | Specify how failures during deserialization of binlog events (i.e. when encountering a corrupted event) should be handled, including:'fail' (the default) an exception indicating the problematic event and its binlog position is raised, causing the connector to be stopped; 'warn' the problematic event and its binlog position will be logged and the event will be skipped;'ignore' the problematic event will be skipped. | fail | String
| *eventProcessingFailureHandling{zwsp}Mode* (mysql) | Specify how failures during processing of events (i.e. when encountering a corrupted event) should be handled, including:'fail' (the default) an exception indicating the problematic event and its position is raised, causing the connector to be stopped; 'warn' the problematic event and its position will be logged and the event will be skipped;'ignore' the problematic event will be skipped. | fail | String
| *gtidNewChannelPosition* (mysql) | If set to 'latest', when connector sees new GTID, it will start consuming gtid channel from the server latest executed gtid position. If 'earliest' (the default) connector starts reading channel from first available (not purged) gtid position on the server. | earliest | String
| *gtidSourceExcludes* (mysql) | The source UUIDs used to exclude GTID ranges when determine the starting position in the MySQL server's binlog. |  | String
| *gtidSourceFilterDmlEvents* (mysql) | If set to true, we will only produce DML events into Kafka for transactions that were written on mysql servers with UUIDs matching the filters defined by the gtid.source.includes or gtid.source.excludes configuration options, if they are specified. | true | boolean
| *gtidSourceIncludes* (mysql) | The source UUIDs used to include GTID ranges when determine the starting position in the MySQL server's binlog. |  | String
| *heartbeatIntervalMs* (mysql) | Length of an interval in milli-seconds in in which the connector periodically sends heartbeat messages to a heartbeat topic. Use 0 to disable heartbeat messages. Disabled by default. | 0ms | int
| *heartbeatTopicsPrefix* (mysql) | The prefix that is used to name heartbeat topics.Defaults to __debezium-heartbeat. | __debezium-heartbeat | String
| *includeQuery* (mysql) | Whether the connector should include the original SQL query that generated the change event. Note: This option requires MySQL be configured with the binlog_rows_query_log_events option set to ON. Query will not be present for events generated from snapshot. WARNING: Enabling this option may expose tables or fields explicitly blacklisted or masked by including the original SQL statement in the change event. For this reason the default value is 'false'. | false | boolean
| *includeSchemaChanges* (mysql) | Whether the connector should publish changes in the database schema to a Kafka topic with the same name as the database server ID. Each schema change will be recorded using a key that contains the database name and whose value include logical description of the new schema and optionally the DDL statement(s).The default is 'true'. This is independent of how the connector internally records database history. | true | boolean
| *inconsistentSchemaHandlingMode* (mysql) | Specify how binlog events that belong to a table missing from internal schema representation (i.e. internal representation is not consistent with database) should be handled, including:'fail' (the default) an exception indicating the problematic event and its binlog position is raised, causing the connector to be stopped; 'warn' the problematic event and its binlog position will be logged and the event will be skipped;'skip' the problematic event will be skipped. | fail | String
| *maxBatchSize* (mysql) | Maximum size of each batch of source records. Defaults to 2048. | 2048 | int
| *maxQueueSize* (mysql) | Maximum size of the queue for change events read from the database log but not yet recorded or forwarded. Defaults to 8192, and should always be larger than the maximum batch size. | 8192 | int
| *messageKeyColumns* (mysql) | A semicolon-separated list of expressions that match fully-qualified tables and column(s) to be used as message key. Each expression must match the pattern ':',where the table names could be defined as (DB_NAME.TABLE_NAME) or (SCHEMA_NAME.TABLE_NAME), depending on the specific connector,and the key columns are a comma-separated list of columns representing the custom key. For any table without an explicit key configuration the table's primary key column(s) will be used as message key.Example: dbserver1.inventory.orderlines:orderId,orderLineId;dbserver1.inventory.orders:id |  | String
| *pollIntervalMs* (mysql) | Frequency in milliseconds to wait for new change events to appear after receiving no events. Defaults to 500ms. | 500ms | long
| *skippedOperations* (mysql) | The comma-separated list of operations to skip during streaming, defined as: 'i' for inserts; 'u' for updates; 'd' for deletes. By default, no operations will be skipped. |  | String
| *snapshotDelayMs* (mysql) | The number of milliseconds to delay before a snapshot will begin. | 0ms | long
| *snapshotFetchSize* (mysql) | The maximum number of records that should be loaded into memory while performing a snapshot |  | int
| *snapshotLockingMode* (mysql) | Controls how long the connector holds onto the global read lock while it is performing a snapshot. The default is 'minimal', which means the connector holds the global read lock (and thus prevents any updates) for just the initial portion of the snapshot while the database schemas and other metadata are being read. The remaining work in a snapshot involves selecting all rows from each table, and this can be done using the snapshot process' REPEATABLE READ transaction even when the lock is no longer held and other operations are updating the database. However, in some cases it may be desirable to block all writes for the entire duration of the snapshot; in such cases set this property to 'extended'. Using a value of 'none' will prevent the connector from acquiring any table locks during the snapshot process. This mode can only be used in combination with snapshot.mode values of 'schema_only' or 'schema_only_recovery' and is only safe to use if no schema changes are happening while the snapshot is taken. | minimal | String
| *snapshotMode* (mysql) | The criteria for running a snapshot upon startup of the connector. Options include: 'when_needed' to specify that the connector run a snapshot upon startup whenever it deems it necessary; 'schema_only' to only take a snapshot of the schema (table structures) but no actual data; 'initial' (the default) to specify the connector can run a snapshot only when no offsets are available for the logical server name; 'initial_only' same as 'initial' except the connector should stop after completing the snapshot and before it would normally read the binlog; and'never' to specify the connector should never run a snapshot and that upon first startup the connector should read from the beginning of the binlog. The 'never' mode should be used with care, and only when the binlog is known to contain all history. | initial | String
| *snapshotNewTables* (mysql) | BETA FEATURE: On connector restart, the connector will check if there have been any new tables added to the configuration, and snapshot them. There is presently only two options:'off': Default behavior. Do not snapshot new tables.'parallel': The snapshot of the new tables will occur in parallel to the continued binlog reading of the old tables. When the snapshot completes, an independent binlog reader will begin reading the events for the new tables until it catches up to present time. At this point, both old and new binlog readers will be momentarily halted and new binlog reader will start that will read the binlog for all configured tables. The parallel binlog reader will have a configured server id of 10000 the primary binlog reader's server id. | off | String
| *snapshotSelectStatement{zwsp}Overrides* (mysql) | This property contains a comma-separated list of fully-qualified tables (DB_NAME.TABLE_NAME) or (SCHEMA_NAME.TABLE_NAME), depending on thespecific connectors . Select statements for the individual tables are specified in further configuration properties, one for each table, identified by the id 'snapshot.select.statement.overrides.DB_NAME.TABLE_NAME' or 'snapshot.select.statement.overrides.SCHEMA_NAME.TABLE_NAME', respectively. The value of those properties is the select statement to use when retrieving data from the specific table during snapshotting. A possible use case for large append-only tables is setting a specific point where to start (resume) snapshotting, in case a previous snapshotting was interrupted. |  | String
| *sourceStructVersion* (mysql) | A version of the format of the publicly visible source part in the message | v2 | String
| *tableBlacklist* (mysql) | A comma-separated list of regular expressions that match the fully-qualified names of tables to be excluded from monitoring (deprecated, use table.exclude.list instead) |  | String
| *tableExcludeList* (mysql) | A comma-separated list of regular expressions that match the fully-qualified names of tables to be excluded from monitoring |  | String
| *tableIgnoreBuiltin* (mysql) | Flag specifying whether built-in tables should be ignored. | true | boolean
| *tableIncludeList* (mysql) | The tables for which changes are to be captured |  | String
| *tableWhitelist* (mysql) | The tables for which changes are to be captured (deprecated, use table.include.list instead) |  | String
| *timePrecisionMode* (mysql) | Time, date and timestamps can be represented with different kinds of precisions, including:'adaptive_time_microseconds': the precision of date and timestamp values is based the database column's precision; but time fields always use microseconds precision;'connect': always represents time, date and timestamp values using Kafka Connect's built-in representations for Time, Date, and Timestamp, which uses millisecond precision regardless of the database columns' precision. | adaptive_time_microseconds | String
| *tombstonesOnDelete* (mysql) | Whether delete operations should be represented by a delete event and a subsquenttombstone event (true) or only by a delete event (false). Emitting the tombstone event (the default behavior) allows Kafka to completely delete all events pertaining to the given key once the source record got deleted. | false | boolean
|===
// component options: END


// endpoint options: START
The Debezium MySQL Connector endpoint is configured using URI syntax:

----
debezium-mysql:name
----

with the following path and query parameters:

=== Path Parameters (1 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *name* | *Required* Unique name for the connector. Attempting to register again with the same name will fail. |  | String
|===


=== Query Parameters (81 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *additionalProperties* (common) | Additional properties for debezium components in case they can't be set directly on the camel configurations (e.g: setting Kafka Connect properties needed by Debezium engine, for example setting KafkaOffsetBackingStore), the properties have to be prefixed with additionalProperties.. E.g: additionalProperties.transactional.id=12345&additionalProperties.schema.registry.url=\\http://localhost:8811/avro |  | Map
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *internalKeyConverter* (consumer) | The Converter class that should be used to serialize and deserialize key data for offsets. The default is JSON converter. | org.apache.kafka.connect.json.JsonConverter | String
| *internalValueConverter* (consumer) | The Converter class that should be used to serialize and deserialize value data for offsets. The default is JSON converter. | org.apache.kafka.connect.json.JsonConverter | String
| *offsetCommitPolicy* (consumer) | The name of the Java class of the commit policy. It defines when offsets commit has to be triggered based on the number of events processed and the time elapsed since the last commit. This class must implement the interface 'OffsetCommitPolicy'. The default is a periodic commit policy based upon time intervals. | io.debezium.embedded.spi.OffsetCommitPolicy.PeriodicCommitOffsetPolicy | String
| *offsetCommitTimeoutMs* (consumer) | Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt. The default is 5 seconds. | 5s | long
| *offsetFlushIntervalMs* (consumer) | Interval at which to try committing offsets. The default is 1 minute. | 60s | long
| *offsetStorage* (consumer) | The name of the Java class that is responsible for persistence of connector offsets. | org.apache.kafka.connect.storage.FileOffsetBackingStore | String
| *offsetStorageFileName* (consumer) | Path to file where offsets are to be stored. Required when offset.storage is set to the FileOffsetBackingStore. |  | String
| *offsetStoragePartitions* (consumer) | The number of partitions used when creating the offset storage topic. Required when offset.storage is set to the 'KafkaOffsetBackingStore'. |  | int
| *offsetStorageReplicationFactor* (consumer) | Replication factor used when creating the offset storage topic. Required when offset.storage is set to the KafkaOffsetBackingStore |  | int
| *offsetStorageTopic* (consumer) | The name of the Kafka topic where offsets are to be stored. Required when offset.storage is set to the KafkaOffsetBackingStore. |  | String
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut |  | ExchangePattern
| *basicPropertyBinding* (advanced) | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
| *bigintUnsignedHandlingMode* (mysql) | Specify how BIGINT UNSIGNED columns should be represented in change events, including:'precise' uses java.math.BigDecimal to represent values, which are encoded in the change events using a binary representation and Kafka Connect's 'org.apache.kafka.connect.data.Decimal' type; 'long' (the default) represents values using Java's 'long', which may not offer the precision but will be far easier to use in consumers. | long | String
| *binaryHandlingMode* (mysql) | Specify how binary (blob, binary, etc.) columns should be represented in change events, including:'bytes' represents binary data as byte array (default)'base64' represents binary data as base64-encoded string'hex' represents binary data as hex-encoded (base16) string | bytes | String
| *binlogBufferSize* (mysql) | The size of a look-ahead buffer used by the binlog reader to decide whether the transaction in progress is going to be committed or rolled back. Use 0 to disable look-ahead buffering. Defaults to 0 (i.e. buffering is disabled). | 0 | int
| *columnBlacklist* (mysql) | Regular expressions matching columns to exclude from change events (deprecated, use column.exclude.list instead) |  | String
| *columnExcludeList* (mysql) | Regular expressions matching columns to exclude from change events |  | String
| *columnIncludeList* (mysql) | Regular expressions matching columns to include in change events |  | String
| *connectKeepAlive* (mysql) | Whether a separate thread should be used to ensure the connection is kept alive. | true | boolean
| *connectKeepAliveIntervalMs* (mysql) | Interval in milliseconds to wait for connection checking if keep alive thread is used. | 1m | long
| *connectTimeoutMs* (mysql) | Maximum time in milliseconds to wait after trying to connect to the database before timing out. | 30s | int
| *databaseExcludeList* (mysql) | A comma-separated list of regular expressions that match database names to be excluded from monitoring |  | String
| *databaseHistory* (mysql) | The name of the DatabaseHistory class that should be used to store and recover database schema changes. The configuration properties for the history are prefixed with the 'database.history.' string. | io.debezium.relational.history.FileDatabaseHistory | String
| *databaseHistoryFileFilename* (mysql) | The path to the file that will be used to record the database history |  | String
| *databaseHistoryKafkaBootstrap{zwsp}Servers* (mysql) | A list of host/port pairs that the connector will use for establishing the initial connection to the Kafka cluster for retrieving database schema history previously stored by the connector. This should point to the same Kafka cluster used by the Kafka Connect process. |  | String
| *databaseHistoryKafkaRecovery{zwsp}Attempts* (mysql) | The number of attempts in a row that no data are returned from Kafka before recover completes. The maximum amount of time to wait after receiving no data is (recovery.attempts) x (recovery.poll.interval.ms). | 100 | int
| *databaseHistoryKafkaRecovery{zwsp}PollIntervalMs* (mysql) | The number of milliseconds to wait while polling for persisted data during recovery. | 100ms | int
| *databaseHistoryKafkaTopic* (mysql) | The name of the topic for the database schema history |  | String
| *databaseHistorySkipUnparseable{zwsp}Ddl* (mysql) | Controls the action Debezium will take when it meets a DDL statement in binlog, that it cannot parse.By default the connector will stop operating but by changing the setting it can ignore the statements which it cannot parse. If skipping is enabled then Debezium can miss metadata changes. | false | boolean
| *databaseHistoryStoreOnly{zwsp}MonitoredTablesDdl* (mysql) | Controls what DDL will Debezium store in database history.By default (false) Debezium will store all incoming DDL statements. If set to truethen only DDL that manipulates a monitored table will be stored. | false | boolean
| *databaseHostname* (mysql) | Resolvable hostname or IP address of the MySQL database server. |  | String
| *databaseIncludeList* (mysql) | The databases for which changes are to be captured |  | String
| *databaseInitialStatements* (mysql) | A semicolon separated list of SQL statements to be executed when a JDBC connection (not binlog reading connection) to the database is established. Note that the connector may establish JDBC connections at its own discretion, so this should typically be used for configuration of session parameters only,but not for executing DML statements. Use doubled semicolon (';;') to use a semicolon as a character and not as a delimiter. |  | String
| *databaseJdbcDriver* (mysql) | JDBC Driver class name used to connect to the MySQL database server. | class com.mysql.cj.jdbc.Driver | String
| *databasePassword* (mysql) | *Required* Password of the MySQL database user to be used when connecting to the database. |  | String
| *databasePort* (mysql) | Port of the MySQL database server. | 3306 | int
| *databaseServerId* (mysql) | A numeric ID of this database client, which must be unique across all currently-running database processes in the cluster. This connector joins the MySQL database cluster as another server (with this unique ID) so it can read the binlog. By default, a random number is generated between 5400 and 6400. |  | long
| *databaseServerIdOffset* (mysql) | Only relevant if parallel snapshotting is configured. During parallel snapshotting, multiple (4) connections open to the database client, and they each need their own unique connection ID. This offset is used to generate those IDs from the base configured cluster ID. | 10000 | long
| *databaseServerName* (mysql) | *Required* Unique name that identifies the database server and all recorded offsets, and that is used as a prefix for all schemas and topics. Each distinct installation should have a separate namespace and be monitored by at most one Debezium connector. |  | String
| *databaseSslKeystore* (mysql) | Location of the Java keystore file containing an application process's own certificate and private key. |  | String
| *databaseSslKeystorePassword* (mysql) | Password to access the private key from the keystore file specified by 'ssl.keystore' configuration property or the 'javax.net.ssl.keyStore' system or JVM property. This password is used to unlock the keystore file (store password), and to decrypt the private key stored in the keystore (key password). |  | String
| *databaseSslMode* (mysql) | Whether to use an encrypted connection to MySQL. Options include'disabled' (the default) to use an unencrypted connection; 'preferred' to establish a secure (encrypted) connection if the server supports secure connections, but fall back to an unencrypted connection otherwise; 'required' to use a secure (encrypted) connection, and fail if one cannot be established; 'verify_ca' like 'required' but additionally verify the server TLS certificate against the configured Certificate Authority (CA) certificates, or fail if no valid matching CA certificates are found; or'verify_identity' like 'verify_ca' but additionally verify that the server certificate matches the host to which the connection is attempted. | disabled | String
| *databaseSslTruststore* (mysql) | Location of the Java truststore file containing the collection of CA certificates trusted by this application process (trust store). |  | String
| *databaseSslTruststorePassword* (mysql) | Password to unlock the keystore file (store password) specified by 'ssl.trustore' configuration property or the 'javax.net.ssl.trustStore' system or JVM property. |  | String
| *databaseUser* (mysql) | Name of the MySQL database user to be used when connecting to the database. |  | String
| *decimalHandlingMode* (mysql) | Specify how DECIMAL and NUMERIC columns should be represented in change events, including:'precise' (the default) uses java.math.BigDecimal to represent values, which are encoded in the change events using a binary representation and Kafka Connect's 'org.apache.kafka.connect.data.Decimal' type; 'string' uses string to represent values; 'double' represents values using Java's 'double', which may not offer the precision but will be far easier to use in consumers. | precise | String
| *enableTimeAdjuster* (mysql) | MySQL allows user to insert year value as either 2-digit or 4-digit. In case of two digit the value is automatically mapped into 1970 - 2069.false - delegates the implicit conversion to the databasetrue - (the default) Debezium makes the conversion | true | boolean
| *eventDeserializationFailure{zwsp}HandlingMode* (mysql) | Specify how failures during deserialization of binlog events (i.e. when encountering a corrupted event) should be handled, including:'fail' (the default) an exception indicating the problematic event and its binlog position is raised, causing the connector to be stopped; 'warn' the problematic event and its binlog position will be logged and the event will be skipped;'ignore' the problematic event will be skipped. | fail | String
| *eventProcessingFailureHandling{zwsp}Mode* (mysql) | Specify how failures during processing of events (i.e. when encountering a corrupted event) should be handled, including:'fail' (the default) an exception indicating the problematic event and its position is raised, causing the connector to be stopped; 'warn' the problematic event and its position will be logged and the event will be skipped;'ignore' the problematic event will be skipped. | fail | String
| *gtidNewChannelPosition* (mysql) | If set to 'latest', when connector sees new GTID, it will start consuming gtid channel from the server latest executed gtid position. If 'earliest' (the default) connector starts reading channel from first available (not purged) gtid position on the server. | earliest | String
| *gtidSourceExcludes* (mysql) | The source UUIDs used to exclude GTID ranges when determine the starting position in the MySQL server's binlog. |  | String
| *gtidSourceFilterDmlEvents* (mysql) | If set to true, we will only produce DML events into Kafka for transactions that were written on mysql servers with UUIDs matching the filters defined by the gtid.source.includes or gtid.source.excludes configuration options, if they are specified. | true | boolean
| *gtidSourceIncludes* (mysql) | The source UUIDs used to include GTID ranges when determine the starting position in the MySQL server's binlog. |  | String
| *heartbeatIntervalMs* (mysql) | Length of an interval in milli-seconds in in which the connector periodically sends heartbeat messages to a heartbeat topic. Use 0 to disable heartbeat messages. Disabled by default. | 0ms | int
| *heartbeatTopicsPrefix* (mysql) | The prefix that is used to name heartbeat topics.Defaults to __debezium-heartbeat. | __debezium-heartbeat | String
| *includeQuery* (mysql) | Whether the connector should include the original SQL query that generated the change event. Note: This option requires MySQL be configured with the binlog_rows_query_log_events option set to ON. Query will not be present for events generated from snapshot. WARNING: Enabling this option may expose tables or fields explicitly blacklisted or masked by including the original SQL statement in the change event. For this reason the default value is 'false'. | false | boolean
| *includeSchemaChanges* (mysql) | Whether the connector should publish changes in the database schema to a Kafka topic with the same name as the database server ID. Each schema change will be recorded using a key that contains the database name and whose value include logical description of the new schema and optionally the DDL statement(s).The default is 'true'. This is independent of how the connector internally records database history. | true | boolean
| *inconsistentSchemaHandlingMode* (mysql) | Specify how binlog events that belong to a table missing from internal schema representation (i.e. internal representation is not consistent with database) should be handled, including:'fail' (the default) an exception indicating the problematic event and its binlog position is raised, causing the connector to be stopped; 'warn' the problematic event and its binlog position will be logged and the event will be skipped;'skip' the problematic event will be skipped. | fail | String
| *maxBatchSize* (mysql) | Maximum size of each batch of source records. Defaults to 2048. | 2048 | int
| *maxQueueSize* (mysql) | Maximum size of the queue for change events read from the database log but not yet recorded or forwarded. Defaults to 8192, and should always be larger than the maximum batch size. | 8192 | int
| *messageKeyColumns* (mysql) | A semicolon-separated list of expressions that match fully-qualified tables and column(s) to be used as message key. Each expression must match the pattern ':',where the table names could be defined as (DB_NAME.TABLE_NAME) or (SCHEMA_NAME.TABLE_NAME), depending on the specific connector,and the key columns are a comma-separated list of columns representing the custom key. For any table without an explicit key configuration the table's primary key column(s) will be used as message key.Example: dbserver1.inventory.orderlines:orderId,orderLineId;dbserver1.inventory.orders:id |  | String
| *pollIntervalMs* (mysql) | Frequency in milliseconds to wait for new change events to appear after receiving no events. Defaults to 500ms. | 500ms | long
| *skippedOperations* (mysql) | The comma-separated list of operations to skip during streaming, defined as: 'i' for inserts; 'u' for updates; 'd' for deletes. By default, no operations will be skipped. |  | String
| *snapshotDelayMs* (mysql) | The number of milliseconds to delay before a snapshot will begin. | 0ms | long
| *snapshotFetchSize* (mysql) | The maximum number of records that should be loaded into memory while performing a snapshot |  | int
| *snapshotLockingMode* (mysql) | Controls how long the connector holds onto the global read lock while it is performing a snapshot. The default is 'minimal', which means the connector holds the global read lock (and thus prevents any updates) for just the initial portion of the snapshot while the database schemas and other metadata are being read. The remaining work in a snapshot involves selecting all rows from each table, and this can be done using the snapshot process' REPEATABLE READ transaction even when the lock is no longer held and other operations are updating the database. However, in some cases it may be desirable to block all writes for the entire duration of the snapshot; in such cases set this property to 'extended'. Using a value of 'none' will prevent the connector from acquiring any table locks during the snapshot process. This mode can only be used in combination with snapshot.mode values of 'schema_only' or 'schema_only_recovery' and is only safe to use if no schema changes are happening while the snapshot is taken. | minimal | String
| *snapshotMode* (mysql) | The criteria for running a snapshot upon startup of the connector. Options include: 'when_needed' to specify that the connector run a snapshot upon startup whenever it deems it necessary; 'schema_only' to only take a snapshot of the schema (table structures) but no actual data; 'initial' (the default) to specify the connector can run a snapshot only when no offsets are available for the logical server name; 'initial_only' same as 'initial' except the connector should stop after completing the snapshot and before it would normally read the binlog; and'never' to specify the connector should never run a snapshot and that upon first startup the connector should read from the beginning of the binlog. The 'never' mode should be used with care, and only when the binlog is known to contain all history. | initial | String
| *snapshotNewTables* (mysql) | BETA FEATURE: On connector restart, the connector will check if there have been any new tables added to the configuration, and snapshot them. There is presently only two options:'off': Default behavior. Do not snapshot new tables.'parallel': The snapshot of the new tables will occur in parallel to the continued binlog reading of the old tables. When the snapshot completes, an independent binlog reader will begin reading the events for the new tables until it catches up to present time. At this point, both old and new binlog readers will be momentarily halted and new binlog reader will start that will read the binlog for all configured tables. The parallel binlog reader will have a configured server id of 10000 the primary binlog reader's server id. | off | String
| *snapshotSelectStatement{zwsp}Overrides* (mysql) | This property contains a comma-separated list of fully-qualified tables (DB_NAME.TABLE_NAME) or (SCHEMA_NAME.TABLE_NAME), depending on thespecific connectors . Select statements for the individual tables are specified in further configuration properties, one for each table, identified by the id 'snapshot.select.statement.overrides.DB_NAME.TABLE_NAME' or 'snapshot.select.statement.overrides.SCHEMA_NAME.TABLE_NAME', respectively. The value of those properties is the select statement to use when retrieving data from the specific table during snapshotting. A possible use case for large append-only tables is setting a specific point where to start (resume) snapshotting, in case a previous snapshotting was interrupted. |  | String
| *sourceStructVersion* (mysql) | A version of the format of the publicly visible source part in the message | v2 | String
| *tableBlacklist* (mysql) | A comma-separated list of regular expressions that match the fully-qualified names of tables to be excluded from monitoring (deprecated, use table.exclude.list instead) |  | String
| *tableExcludeList* (mysql) | A comma-separated list of regular expressions that match the fully-qualified names of tables to be excluded from monitoring |  | String
| *tableIgnoreBuiltin* (mysql) | Flag specifying whether built-in tables should be ignored. | true | boolean
| *tableIncludeList* (mysql) | The tables for which changes are to be captured |  | String
| *tableWhitelist* (mysql) | The tables for which changes are to be captured (deprecated, use table.include.list instead) |  | String
| *timePrecisionMode* (mysql) | Time, date and timestamps can be represented with different kinds of precisions, including:'adaptive_time_microseconds': the precision of date and timestamp values is based the database column's precision; but time fields always use microseconds precision;'connect': always represents time, date and timestamp values using Kafka Connect's built-in representations for Time, Date, and Timestamp, which uses millisecond precision regardless of the database columns' precision. | adaptive_time_microseconds | String
| *tombstonesOnDelete* (mysql) | Whether delete operations should be represented by a delete event and a subsquenttombstone event (true) or only by a delete event (false). Emitting the tombstone event (the default behavior) allows Kafka to completely delete all events pertaining to the given key once the source record got deleted. | false | boolean
|===
// endpoint options: END

For more information about configuration:
https://debezium.io/documentation/reference/0.10/operations/embedded.html#engine-properties[https://debezium.io/documentation/reference/0.10/operations/embedded.html#engine-properties]
https://debezium.io/documentation/reference/0.10/connectors/mysql.html#connector-properties[https://debezium.io/documentation/reference/0.10/connectors/mysql.html#connector-properties]

== Message headers

=== Consumer headers

The following headers are available when consuming change events from Debezium.
[width=""100%"",cols=""2m,2m,1m,5"",options=""header""]
|===
| Header constant                           | Header value                                   | Type        | Description
| DebeziumConstants.HEADER_IDENTIFIER       | ""CamelDebeziumIdentifier""                      | String      | The identifier of the connector, normally is this format ""+++{server-name}.{database-name}.{table-name}+++"".
| DebeziumConstants.HEADER_KEY              | ""CamelDebeziumKey""                             | Struct      | The key of the event, normally is the table Primary Key.
| DebeziumConstants.HEADER_SOURCE_METADATA  | ""CamelDebeziumSourceMetadata""                  | Map         | The metadata about the source event, for example `table` name, database `name`, log position, etc, please refer to the Debezium documentation for more info.
| DebeziumConstants.HEADER_OPERATION        | ""CamelDebeziumOperation""                       | String      | If presents, the type of event operation. Values for the connector are `c` for create (or insert), `u` for update, `d` for delete or `r` in case of a snapshot event.
| DebeziumConstants.HEADER_TIMESTAMP        | ""CamelDebeziumTimestamp""                       | Long        | If presents, the time (using the system clock in the JVM) at which the connector processed the event.
| DebeziumConstants.HEADER_BEFORE           | ""CamelDebeziumBefore""                          | Struct     | If presents, contains the state of the row before the event occurred.
|===

== Message body
The message body if is not `null` (in case of tombstones), it contains the state of the row after the event occurred as `Struct` format or `Map` format if you use the included Type Converter from `Struct` to `Map` (please look below for more explanation).

== Samples

=== Consuming events

Here is a very simple route that you can use in order to listen to Debezium events from MySQL connector.
[source,java]
----
from(""debezium-mysql:dbz-test-1?offsetStorageFileName=/usr/offset-file-1.dat&databaseHostName=localhost&databaseUser=debezium&databasePassword=dbz&databaseServerName=my-app-connector&databaseHistoryFileName=/usr/history-file-1.dat"")
    .log(""Event received from Debezium : ${body}"")
    .log(""    with this identifier ${headers.CamelDebeziumIdentifier}"")
    .log(""    with these source metadata ${headers.CamelDebeziumSourceMetadata}"")
    .log(""    the event occured upon this operation '${headers.CamelDebeziumSourceOperation}'"")
    .log(""    on this database '${headers.CamelDebeziumSourceMetadata[db]}' and this table '${headers.CamelDebeziumSourceMetadata[table]}'"")
    .log(""    with the key ${headers.CamelDebeziumKey}"")
    .log(""    the previous value is ${headers.CamelDebeziumBefore}"")
----

By default, the component will emit the events in the body and `CamelDebeziumBefore` header as https://kafka.apache.org/22/javadoc/org/apache/kafka/connect/data/Struct.html[`Struct`] data type, the reasoning behind this, is to perceive the schema information in case is needed.
However, the component as well contains a xref:manual::type-converter.adoc[Type Converter] that converts
from default output type of https://kafka.apache.org/22/javadoc/org/apache/kafka/connect/data/Struct.html[`Struct`] to `Map` in order to leverage Camel's rich xref:manual::data-format.adoc[Data Format] types which many of them work out of box with `Map` data type.
To use it, you can either add `Map.class` type when you access the message e.g: `exchange.getIn().getBody(Map.class)`, or you can convert the body always to `Map` from the route builder by adding `.convertBodyTo(Map.class)` to your Camel Route DSL after `from` statement.

We mentioned above about the schema, which can be used in case you need to perform advance data transformation and the schema is needed for that. If you choose not to convert your body to `Map`,
you can obtain the schema information as https://kafka.apache.org/22/javadoc/org/apache/kafka/connect/data/Schema.html[`Schema`] type from `Struct` like this:
[source,java]
----
from(""debezium-mysql:[name]?[options]])
    .process(exchange -> {
        final Struct bodyValue = exchange.getIn().getBody(Struct.class);
        final Schema schemaValue = bodyValue.schema();

        log.info(""Body value is :"" + bodyValue);
        log.info(""With Schema : "" + schemaValue);
        log.info(""And fields of :"" + schemaValue.fields());
        log.info(""Field name has `"" + schemaValue.field(""name"").schema() + ""` type"");
    });
----

*Important Note:* This component is a thin wrapper around Debezium Engine as mentioned, therefore before using this component in production, you need to understand how Debezium works and how configurations can reflect the expected behavior, especially in regards to https://debezium.io/documentation/reference/0.9/operations/embedded.html#_handling_failures[handling failures].

include::camel-spring-boot::page$debezium-mysql-starter.adoc[]
",12061,True,2998.392107945683,median
"// Copyright (c) 2018, ETH Zurich and UNC Chapel Hill.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//
//     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
//       its contributors may be used to endorse or promote products derived
//       from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS""
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// Author: Johannes L. Schoenberger (jsch-at-demuc-dot-de)

#ifndef NOMINMAX
#define NOMINMAX
#endif

#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.hpp>

#include ""base/similarity_transform.h""
#include ""controllers/automatic_reconstruction.h""
#include ""controllers/bundle_adjustment.h""
#include ""controllers/hierarchical_mapper.h""
#include ""estimators/coordinate_frame.h""
#include ""feature/extraction.h""
#include ""feature/matching.h""
#include ""feature/utils.h""
#include ""mvs/meshing.h""
#include ""mvs/patch_match.h""
#include ""retrieval/visual_index.h""
#include ""ui/main_window.h""
#include ""util/opengl_utils.h""
#include ""util/version.h""

using namespace colmap;

#ifdef CUDA_ENABLED
const bool kUseOpenGL = false;
#else
const bool kUseOpenGL = true;
#endif

int RunGraphicalUserInterface(int argc, char** argv) {
  OptionManager options;

  std::string import_path;

  if (argc > 1) {
    options.AddDefaultOption(""import_path"", &import_path);
    options.AddAllOptions();
    options.Parse(argc, argv);
  }

#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
  QApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
  QApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
#endif

  Q_INIT_RESOURCE(resources);

  QApplication app(argc, argv);

  MainWindow main_window(options);
  main_window.show();

  if (!import_path.empty()) {
    main_window.ImportReconstruction(import_path);
  }

  return app.exec();
}

int RunAutomaticReconstructor(int argc, char** argv) {
  AutomaticReconstructionController::Options reconstruction_options;
  std::string data_type = ""individual"";
  std::string quality = ""high"";
  std::string mesher = ""poisson"";

  OptionManager options;
  options.AddRequiredOption(""workspace_path"",
                            &reconstruction_options.workspace_path);
  options.AddRequiredOption(""image_path"", &reconstruction_options.image_path);
  options.AddDefaultOption(""mask_path"",
                           &reconstruction_options.mask_path);
  options.AddDefaultOption(""vocab_tree_path"",
                           &reconstruction_options.vocab_tree_path);
  options.AddDefaultOption(""data_type"", &data_type,
                           ""{individual, video, internet}"");
  options.AddDefaultOption(""quality"", &quality, ""{low, medium, high, extreme}"");
  options.AddDefaultOption(""camera_model"",
                           &reconstruction_options.camera_model);
  options.AddDefaultOption(""single_camera"",
                           &reconstruction_options.single_camera);
  options.AddDefaultOption(""sparse"", &reconstruction_options.sparse);
  options.AddDefaultOption(""dense"", &reconstruction_options.dense);
  options.AddDefaultOption(""mesher"", &mesher, ""{poisson, delaunay}"");
  options.AddDefaultOption(""num_threads"", &reconstruction_options.num_threads);
  options.AddDefaultOption(""use_gpu"", &reconstruction_options.use_gpu);
  options.AddDefaultOption(""gpu_index"", &reconstruction_options.gpu_index);
  options.Parse(argc, argv);

  StringToLower(&data_type);
  if (data_type == ""individual"") {
    reconstruction_options.data_type =
        AutomaticReconstructionController::DataType::INDIVIDUAL;
  } else if (data_type == ""video"") {
    reconstruction_options.data_type =
        AutomaticReconstructionController::DataType::VIDEO;
  } else if (data_type == ""internet"") {
    reconstruction_options.data_type =
        AutomaticReconstructionController::DataType::INTERNET;
  } else {
    LOG(FATAL) << ""Invalid data type provided"";
  }

  StringToLower(&quality);
  if (quality == ""low"") {
    reconstruction_options.quality =
        AutomaticReconstructionController::Quality::LOW;
  } else if (quality == ""medium"") {
    reconstruction_options.quality =
        AutomaticReconstructionController::Quality::MEDIUM;
  } else if (quality == ""high"") {
    reconstruction_options.quality =
        AutomaticReconstructionController::Quality::HIGH;
  } else if (quality == ""extreme"") {
    reconstruction_options.quality =
        AutomaticReconstructionController::Quality::EXTREME;
  } else {
    LOG(FATAL) << ""Invalid quality provided"";
  }

  StringToLower(&mesher);
  if (mesher == ""poisson"") {
    reconstruction_options.mesher =
        AutomaticReconstructionController::Mesher::POISSON;
  } else if (mesher == ""delaunay"") {
    reconstruction_options.mesher =
        AutomaticReconstructionController::Mesher::DELAUNAY;
  } else {
    LOG(FATAL) << ""Invalid mesher provided"";
  }

  ReconstructionManager reconstruction_manager;

  if (reconstruction_options.use_gpu && kUseOpenGL) {
    QApplication app(argc, argv);
    AutomaticReconstructionController controller(reconstruction_options,
                                                 &reconstruction_manager);
    RunThreadWithOpenGLContext(&controller);
  } else {
    AutomaticReconstructionController controller(reconstruction_options,
                                                 &reconstruction_manager);
    controller.Start();
    controller.Wait();
  }

  return EXIT_SUCCESS;
}

int RunBundleAdjuster(int argc, char** argv) {
  std::string input_path;
  std::string output_path;

  OptionManager options;
  options.AddRequiredOption(""input_path"", &input_path);
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddBundleAdjustmentOptions();
  options.Parse(argc, argv);

  Reconstruction reconstruction;
  reconstruction.Read(input_path);

  BundleAdjustmentController ba_controller(options, &reconstruction);
  ba_controller.Start();
  ba_controller.Wait();

  reconstruction.Write(output_path);

  return EXIT_SUCCESS;
}

int RunColorExtractor(int argc, char** argv) {
  std::string input_path;
  std::string output_path;

  OptionManager options;
  options.AddImageOptions();
  options.AddDefaultOption(""input_path"", &input_path);
  options.AddRequiredOption(""output_path"", &output_path);
  options.Parse(argc, argv);

  Reconstruction reconstruction;
  reconstruction.Read(input_path);
  reconstruction.ExtractColorsForAllImages(*options.image_path);
  reconstruction.Write(output_path);

  return EXIT_SUCCESS;
}

int RunDatabaseCreator(int argc, char** argv) {
  OptionManager options;
  options.AddDatabaseOptions();
  options.Parse(argc, argv);

  Database database(*options.database_path);

  return EXIT_SUCCESS;
}

int RunDatabaseMerger(int argc, char** argv) {
  std::string database_path1;
  std::string database_path2;
  std::string merged_database_path;

  OptionManager options;
  options.AddRequiredOption(""database_path1"", &database_path1);
  options.AddRequiredOption(""database_path2"", &database_path2);
  options.AddRequiredOption(""merged_database_path"", &merged_database_path);
  options.Parse(argc, argv);

  if (ExistsFile(merged_database_path)) {
    std::cout << ""ERROR: Merged database file must not exist."" << std::endl;
    return EXIT_FAILURE;
  }

  Database database1(database_path1);
  Database database2(database_path2);
  Database merged_database(merged_database_path);
  Database::Merge(database1, database2, &merged_database);

  return EXIT_SUCCESS;
}

int RunStereoFuser(int argc, char** argv) {
  std::string workspace_path;
  std::string input_type = ""geometric"";
  std::string workspace_format = ""COLMAP"";
  std::string pmvs_option_name = ""option-all"";
  std::string output_path;

  OptionManager options;
  options.AddRequiredOption(""workspace_path"", &workspace_path);
  options.AddDefaultOption(""workspace_format"", &workspace_format,
                           ""{COLMAP, PMVS}"");
  options.AddDefaultOption(""pmvs_option_name"", &pmvs_option_name);
  options.AddDefaultOption(""input_type"", &input_type,
                           ""{photometric, geometric}"");
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddStereoFusionOptions();
  options.Parse(argc, argv);

  StringToLower(&workspace_format);
  if (workspace_format != ""colmap"" && workspace_format != ""pmvs"") {
    std::cout << ""ERROR: Invalid `workspace_format` - supported values are ""
                 ""'COLMAP' or 'PMVS'.""
              << std::endl;
    return EXIT_FAILURE;
  }

  StringToLower(&input_type);
  if (input_type != ""photometric"" && input_type != ""geometric"") {
    std::cout << ""ERROR: Invalid input type - supported values are ""
                 ""'photometric' and 'geometric'.""
              << std::endl;
    return EXIT_FAILURE;
  }

  mvs::StereoFusion fuser(*options.stereo_fusion, workspace_path,
                          workspace_format, pmvs_option_name, input_type);

  fuser.Start();
  fuser.Wait();

  std::cout << ""Writing output: "" << output_path << std::endl;
  WriteBinaryPlyPoints(output_path, fuser.GetFusedPoints());
  mvs::WritePointsVisibility(output_path + "".vis"",
                             fuser.GetFusedPointsVisibility());

  return EXIT_SUCCESS;
}

int RunPoissonMesher(int argc, char** argv) {
  std::string input_path;
  std::string output_path;

  OptionManager options;
  options.AddRequiredOption(""input_path"", &input_path);
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddPoissonMeshingOptions();
  options.Parse(argc, argv);

  CHECK(mvs::PoissonMeshing(*options.poisson_meshing, input_path, output_path));

  return EXIT_SUCCESS;
}

int RunProjectGenerator(int argc, char** argv) {
  std::string output_path;
  std::string quality = ""high"";

  OptionManager options;
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddDefaultOption(""quality"", &quality, ""{low, medium, high, extreme}"");
  options.Parse(argc, argv);

  OptionManager output_options;
  output_options.AddAllOptions();

  StringToLower(&quality);
  if (quality == ""low"") {
    output_options.ModifyForLowQuality();
  } else if (quality == ""medium"") {
    output_options.ModifyForMediumQuality();
  } else if (quality == ""high"") {
    output_options.ModifyForHighQuality();
  } else if (quality == ""extreme"") {
    output_options.ModifyForExtremeQuality();
  } else {
    LOG(FATAL) << ""Invalid quality provided"";
  }

  output_options.Write(output_path);

  return EXIT_SUCCESS;
}

int RunDelaunayMesher(int argc, char** argv) {
#ifndef CGAL_ENABLED
  std::cerr << ""ERROR: Delaunay meshing requires CGAL, which is not ""
               ""available on your system.""
            << std::endl;
  return EXIT_FAILURE;
#else   // CGAL_ENABLED
  std::string input_path;
  std::string input_type = ""dense"";
  std::string output_path;

  OptionManager options;
  options.AddRequiredOption(
      ""input_path"", &input_path,
      ""Path to either the dense workspace folder or the sparse reconstruction"");
  options.AddDefaultOption(""input_type"", &input_type, ""{dense, sparse}"");
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddDelaunayMeshingOptions();
  options.Parse(argc, argv);

  StringToLower(&input_type);
  if (input_type == ""sparse"") {
    mvs::SparseDelaunayMeshing(*options.delaunay_meshing, input_path,
                               output_path);
  } else if (input_type == ""dense"") {
    mvs::DenseDelaunayMeshing(*options.delaunay_meshing, input_path,
                              output_path);
  } else {
    std::cout << ""ERROR: Invalid input type - ""
                 ""supported values are 'sparse' and 'dense'.""
              << std::endl;
    return EXIT_FAILURE;
  }

  return EXIT_SUCCESS;
#endif  // CGAL_ENABLED
}

int RunPatchMatchStereo(int argc, char** argv) {
#ifndef CUDA_ENABLED
  std::cerr << ""ERROR: Dense stereo reconstruction requires CUDA, which is not ""
               ""available on your system.""
            << std::endl;
  return EXIT_FAILURE;
#else   // CUDA_ENABLED
  std::string workspace_path;
  std::string workspace_format = ""COLMAP"";
  std::string pmvs_option_name = ""option-all"";

  OptionManager options;
  options.AddRequiredOption(
      ""workspace_path"", &workspace_path,
      ""Path to the folder containing the undistorted images"");
  options.AddDefaultOption(""workspace_format"", &workspace_format,
                           ""{COLMAP, PMVS}"");
  options.AddDefaultOption(""pmvs_option_name"", &pmvs_option_name);
  options.AddPatchMatchStereoOptions();
  options.Parse(argc, argv);

  StringToLower(&workspace_format);
  if (workspace_format != ""colmap"" && workspace_format != ""pmvs"") {
    std::cout << ""ERROR: Invalid `workspace_format` - supported values are ""
                 ""'COLMAP' or 'PMVS'.""
              << std::endl;
    return EXIT_FAILURE;
  }

  mvs::PatchMatchController controller(*options.patch_match_stereo,
                                       workspace_path, workspace_format,
                                       pmvs_option_name);

  controller.Start();
  controller.Wait();

  return EXIT_SUCCESS;
#endif  // CUDA_ENABLED
}

int RunExhaustiveMatcher(int argc, char** argv) {
  OptionManager options;
  options.AddDatabaseOptions();
  options.AddExhaustiveMatchingOptions();
  options.Parse(argc, argv);

  std::unique_ptr<QApplication> app;
  if (options.sift_matching->use_gpu && kUseOpenGL) {
    app.reset(new QApplication(argc, argv));
  }

  ExhaustiveFeatureMatcher feature_matcher(*options.exhaustive_matching,
                                           *options.sift_matching,
                                           *options.database_path);

  if (options.sift_matching->use_gpu && kUseOpenGL) {
    RunThreadWithOpenGLContext(&feature_matcher);
  } else {
    feature_matcher.Start();
    feature_matcher.Wait();
  }

  return EXIT_SUCCESS;
}

bool VerifyCameraParams(const std::string& camera_model,
                        const std::string& params) {
  if (!ExistsCameraModelWithName(camera_model)) {
    std::cerr << ""ERROR: Camera model does not exist"" << std::endl;
    return false;
  }

  const std::vector<double> camera_params = CSVToVector<double>(params);
  const int camera_model_id = CameraModelNameToId(camera_model);

  if (camera_params.size() > 0 &&
      !CameraModelVerifyParams(camera_model_id, camera_params)) {
    std::cerr << ""ERROR: Invalid camera parameters"" << std::endl;
    return false;
  }
  return true;
}

int RunFeatureExtractor(int argc, char** argv) {
  std::string image_list_path;

  OptionManager options;
  options.AddDatabaseOptions();
  options.AddImageOptions();
  options.AddDefaultOption(""image_list_path"", &image_list_path);
  options.AddExtractionOptions();
  options.Parse(argc, argv);

  ImageReaderOptions reader_options = *options.image_reader;
  reader_options.database_path = *options.database_path;
  reader_options.image_path = *options.image_path;

  if (!image_list_path.empty()) {
    reader_options.image_list = ReadTextFileLines(image_list_path);
    if (reader_options.image_list.empty()) {
      return EXIT_SUCCESS;
    }
  }

  if (!ExistsCameraModelWithName(options.image_reader->camera_model)) {
    std::cerr << ""ERROR: Camera model does not exist"" << std::endl;
  }

  if (!VerifyCameraParams(options.image_reader->camera_model,
                          options.image_reader->camera_params)) {
    return EXIT_FAILURE;
  }

  std::unique_ptr<QApplication> app;
  if (options.sift_extraction->use_gpu && kUseOpenGL) {
    app.reset(new QApplication(argc, argv));
  }

  SiftFeatureExtractor feature_extractor(reader_options,
                                         *options.sift_extraction);

  if (options.sift_extraction->use_gpu && kUseOpenGL) {
    RunThreadWithOpenGLContext(&feature_extractor);
  } else {
    feature_extractor.Start();
    feature_extractor.Wait();
  }

  return EXIT_SUCCESS;
}

int RunFeatureImporter(int argc, char** argv) {
  std::string import_path;
  std::string image_list_path;

  OptionManager options;
  options.AddDatabaseOptions();
  options.AddImageOptions();
  options.AddRequiredOption(""import_path"", &import_path);
  options.AddDefaultOption(""image_list_path"", &image_list_path);
  options.AddExtractionOptions();
  options.Parse(argc, argv);

  ImageReaderOptions reader_options = *options.image_reader;
  reader_options.database_path = *options.database_path;
  reader_options.image_path = *options.image_path;

  if (!image_list_path.empty()) {
    reader_options.image_list = ReadTextFileLines(image_list_path);
    if (reader_options.image_list.empty()) {
      return EXIT_SUCCESS;
    }
  }

  if (!VerifyCameraParams(options.image_reader->camera_model,
                          options.image_reader->camera_params)) {
    return EXIT_FAILURE;
  }

  FeatureImporter feature_importer(reader_options, import_path);
  feature_importer.Start();
  feature_importer.Wait();

  return EXIT_SUCCESS;
}

// Read stereo image pair names from a text file. The text file is expected to
// have one image pair per line, e.g.:
//
//      image_name1.jpg image_name2.jpg
//      image_name3.jpg image_name4.jpg
//      image_name5.jpg image_name6.jpg
//      ...
//
std::vector<std::pair<image_t, image_t>> ReadStereoImagePairs(
    const std::string& path, const Reconstruction& reconstruction) {
  const std::vector<std::string> stereo_pair_lines = ReadTextFileLines(path);

  std::vector<std::pair<image_t, image_t>> stereo_pairs;
  stereo_pairs.reserve(stereo_pair_lines.size());

  for (const auto& line : stereo_pair_lines) {
    const std::vector<std::string> names = StringSplit(line, "" "");
    CHECK_EQ(names.size(), 2);

    const Image* image1 = reconstruction.FindImageWithName(names[0]);
    const Image* image2 = reconstruction.FindImageWithName(names[1]);

    CHECK_NOTNULL(image1);
    CHECK_NOTNULL(image2);

    stereo_pairs.emplace_back(image1->ImageId(), image2->ImageId());
  }

  return stereo_pairs;
}

int RunImageDeleter(int argc, char** argv) {
  std::string input_path;
  std::string output_path;
  std::string image_ids_path;
  std::string image_names_path;

  OptionManager options;
  options.AddRequiredOption(""input_path"", &input_path);
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddDefaultOption(
      ""image_ids_path"", &image_ids_path,
      ""Path to text file containing one image_id to delete per line"");
  options.AddDefaultOption(
      ""image_names_path"", &image_names_path,
      ""Path to text file containing one image name to delete per line"");
  options.Parse(argc, argv);

  Reconstruction reconstruction;
  reconstruction.Read(input_path);

  if (!image_ids_path.empty()) {
    const auto image_ids = ReadTextFileLines(image_ids_path);

    for (const auto image_id_str : image_ids) {
      if (image_id_str.empty()) {
        continue;
      }

      const image_t image_id = std::stoi(image_id_str);
      if (reconstruction.ExistsImage(image_id)) {
        const auto& image = reconstruction.Image(image_id);
        std::cout
            << StringPrintf(
                   ""Deleting image_id=%d, image_name=%s from reconstruction"",
                   image.ImageId(), image.Name().c_str())
            << std::endl;
        reconstruction.DeRegisterImage(image_id);
      } else {
        std::cout << StringPrintf(
                         ""WARNING: Skipping image_id=%s, because it does not ""
                         ""exist in the reconstruction"",
                         image_id_str.c_str())
                  << std::endl;
      }
    }
  }

  if (!image_names_path.empty()) {
    const auto image_names = ReadTextFileLines(image_names_path);

    for (const auto image_name : image_names) {
      if (image_name.empty()) {
        continue;
      }

      const Image* image = reconstruction.FindImageWithName(image_name);
      if (image != nullptr) {
        std::cout
            << StringPrintf(
                   ""Deleting image_id=%d, image_name=%s from reconstruction"",
                   image->ImageId(), image->Name().c_str())
            << std::endl;
        reconstruction.DeRegisterImage(image->ImageId());
      } else {
        std::cout << StringPrintf(
                         ""WARNING: Skipping image_name=%s, because it does not ""
                         ""exist in the reconstruction"",
                         image_name.c_str())
                  << std::endl;
      }
    }
  }

  reconstruction.Write(output_path);

  return EXIT_SUCCESS;
}

int RunImageFilterer(int argc, char** argv) {
  std::string input_path;
  std::string output_path;
  double min_focal_length_ratio = 0.1;
  double max_focal_length_ratio = 10.0;
  double max_extra_param = 100.0;
  size_t min_num_observations = 10;

  OptionManager options;
  options.AddRequiredOption(""input_path"", &input_path);
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddDefaultOption(""min_focal_length_ratio"", &min_focal_length_ratio);
  options.AddDefaultOption(""max_focal_length_ratio"", &max_focal_length_ratio);
  options.AddDefaultOption(""max_extra_param"", &max_extra_param);
  options.AddDefaultOption(""min_num_observations"", &min_num_observations);
  options.Parse(argc, argv);

  Reconstruction reconstruction;
  reconstruction.Read(input_path);

  const size_t num_reg_images = reconstruction.NumRegImages();

  reconstruction.FilterImages(min_focal_length_ratio, max_focal_length_ratio,
                              max_extra_param);

  std::vector<image_t> filtered_image_ids;
  for (const auto& image : reconstruction.Images()) {
    if (image.second.IsRegistered() &&
        image.second.NumPoints3D() < min_num_observations) {
      filtered_image_ids.push_back(image.first);
    }
  }

  for (const auto image_id : filtered_image_ids) {
    reconstruction.DeRegisterImage(image_id);
  }

  const size_t num_filtered_images =
      num_reg_images - reconstruction.NumRegImages();

  std::cout << StringPrintf(""Filtered %d images from a total of %d images"",
                            num_filtered_images, num_reg_images)
            << std::endl;

  reconstruction.Write(output_path);

  return EXIT_SUCCESS;
}

int RunImageRectifier(int argc, char** argv) {
  std::string input_path;
  std::string output_path;
  std::string stereo_pairs_list;

  UndistortCameraOptions undistort_camera_options;

  OptionManager options;
  options.AddImageOptions();
  options.AddRequiredOption(""input_path"", &input_path);
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddRequiredOption(""stereo_pairs_list"", &stereo_pairs_list);
  options.AddDefaultOption(""blank_pixels"",
                           &undistort_camera_options.blank_pixels);
  options.AddDefaultOption(""min_scale"", &undistort_camera_options.min_scale);
  options.AddDefaultOption(""max_scale"", &undistort_camera_options.max_scale);
  options.AddDefaultOption(""max_image_size"",
                           &undistort_camera_options.max_image_size);
  options.Parse(argc, argv);

  Reconstruction reconstruction;
  reconstruction.Read(input_path);

  const auto stereo_pairs =
      ReadStereoImagePairs(stereo_pairs_list, reconstruction);

  StereoImageRectifier rectifier(undistort_camera_options, reconstruction,
                                 *options.image_path, output_path,
                                 stereo_pairs);
  rectifier.Start();
  rectifier.Wait();

  return EXIT_SUCCESS;
}

int RunImageRegistrator(int argc, char** argv) {
  std::string input_path;
  std::string output_path;

  OptionManager options;
  options.AddDatabaseOptions();
  options.AddRequiredOption(""input_path"", &input_path);
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddMapperOptions();
  options.Parse(argc, argv);

  if (!ExistsDir(input_path)) {
    std::cerr << ""ERROR: `input_path` is not a directory"" << std::endl;
    return EXIT_FAILURE;
  }

  if (!ExistsDir(output_path)) {
    std::cerr << ""ERROR: `output_path` is not a directory"" << std::endl;
    return EXIT_FAILURE;
  }

  PrintHeading1(""Loading database"");

  DatabaseCache database_cache;

  {
    Database database(*options.database_path);
    Timer timer;
    timer.Start();
    const size_t min_num_matches =
        static_cast<size_t>(options.mapper->min_num_matches);
    database_cache.Load(database, min_num_matches,
                        options.mapper->ignore_watermarks,
                        options.mapper->image_names);
    std::cout << std::endl;
    timer.PrintMinutes();
  }

  std::cout << std::endl;

  Reconstruction reconstruction;
  reconstruction.Read(input_path);

  IncrementalMapper mapper(&database_cache);
  mapper.BeginReconstruction(&reconstruction);

  const auto mapper_options = options.mapper->Mapper();

  for (const auto& image : reconstruction.Images()) {
    if (image.second.IsRegistered()) {
      continue;
    }

    PrintHeading1(""Registering image #"" + std::to_string(image.first) + "" ("" +
                  std::to_string(reconstruction.NumRegImages() + 1) + "")"");

    std::cout << ""  => Image sees "" << image.second.NumVisiblePoints3D()
              << "" / "" << image.second.NumObservations() << "" points""
              << std::endl;

    mapper.RegisterNextImage(mapper_options, image.first);
  }

  const bool kDiscardReconstruction = false;
  mapper.EndReconstruction(kDiscardReconstruction);

  reconstruction.Write(output_path);

  return EXIT_SUCCESS;
}

int RunImageUndistorter(int argc, char** argv) {
  std::string input_path;
  std::string output_path;
  std::string output_type = ""COLMAP"";

  UndistortCameraOptions undistort_camera_options;

  OptionManager options;
  options.AddImageOptions();
  options.AddRequiredOption(""input_path"", &input_path);
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddDefaultOption(""output_type"", &output_type,
                           ""{COLMAP, PMVS, CMP-MVS}"");
  options.AddDefaultOption(""blank_pixels"",
                           &undistort_camera_options.blank_pixels);
  options.AddDefaultOption(""min_scale"", &undistort_camera_options.min_scale);
  options.AddDefaultOption(""max_scale"", &undistort_camera_options.max_scale);
  options.AddDefaultOption(""max_image_size"",
                           &undistort_camera_options.max_image_size);
  options.AddDefaultOption(""roi_min_x"", &undistort_camera_options.roi_min_x);
  options.AddDefaultOption(""roi_min_y"", &undistort_camera_options.roi_min_y);
  options.AddDefaultOption(""roi_max_x"", &undistort_camera_options.roi_max_x);
  options.AddDefaultOption(""roi_max_y"", &undistort_camera_options.roi_max_y);
  options.Parse(argc, argv);

  CreateDirIfNotExists(output_path);

  Reconstruction reconstruction;
  reconstruction.Read(input_path);

  std::unique_ptr<Thread> undistorter;
  if (output_type == ""COLMAP"") {
    undistorter.reset(new COLMAPUndistorter(undistort_camera_options,
                                            reconstruction, *options.image_path,
                                            output_path));
  } else if (output_type == ""PMVS"") {
    undistorter.reset(new PMVSUndistorter(undistort_camera_options,
                                          reconstruction, *options.image_path,
                                          output_path));
  } else if (output_type == ""CMP-MVS"") {
    undistorter.reset(new CMPMVSUndistorter(undistort_camera_options,
                                            reconstruction, *options.image_path,
                                            output_path));
  } else {
    std::cerr << ""ERROR: Invalid `output_type` - supported values are ""
                 ""{'COLMAP', 'PMVS', 'CMP-MVS'}.""
              << std::endl;
    return EXIT_FAILURE;
  }

  undistorter->Start();
  undistorter->Wait();

  return EXIT_SUCCESS;
}

int RunMapper(int argc, char** argv) {
  std::string input_path;
  std::string output_path;
  std::string image_list_path;

  OptionManager options;
  options.AddDatabaseOptions();
  options.AddImageOptions();
  options.AddDefaultOption(""input_path"", &input_path);
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddDefaultOption(""image_list_path"", &image_list_path);
  options.AddMapperOptions();
  options.Parse(argc, argv);

  if (!ExistsDir(output_path)) {
    std::cerr << ""ERROR: `output_path` is not a directory."" << std::endl;
    return EXIT_FAILURE;
  }

  if (!image_list_path.empty()) {
    const auto image_names = ReadTextFileLines(image_list_path);
    options.mapper->image_names =
        std::unordered_set<std::string>(image_names.begin(), image_names.end());
  }

  ReconstructionManager reconstruction_manager;
  if (input_path != """") {
    if (!ExistsDir(input_path)) {
      std::cerr << ""ERROR: `input_path` is not a directory."" << std::endl;
      return EXIT_FAILURE;
    }
    reconstruction_manager.Read(input_path);
  }

  IncrementalMapperController mapper(options.mapper.get(), *options.image_path,
                                     *options.database_path,
                                     &reconstruction_manager);

  // In case a new reconstruction is started, write results of individual sub-
  // models to as their reconstruction finishes instead of writing all results
  // after all reconstructions finished.
  size_t prev_num_reconstructions = 0;
  if (input_path == """") {
    mapper.AddCallback(
        IncrementalMapperController::LAST_IMAGE_REG_CALLBACK, [&]() {
          // If the number of reconstructions has not changed, the last model
          // was discarded for some reason.
          if (reconstruction_manager.Size() > prev_num_reconstructions) {
            const std::string reconstruction_path = JoinPaths(
                output_path, std::to_string(prev_num_reconstructions));
            const auto& reconstruction =
                reconstruction_manager.Get(prev_num_reconstructions);
            CreateDirIfNotExists(reconstruction_path);
            reconstruction.Write(reconstruction_path);
            options.Write(JoinPaths(reconstruction_path, ""project.ini""));
            prev_num_reconstructions = reconstruction_manager.Size();
          }
        });
  }

  mapper.Start();
  mapper.Wait();

  // In case the reconstruction is continued from an existing reconstruction, do
  // not create sub-folders but directly write the results.
  if (input_path != """" && reconstruction_manager.Size() > 0) {
    reconstruction_manager.Get(0).Write(output_path);
  }

  return EXIT_SUCCESS;
}

int RunHierarchicalMapper(int argc, char** argv) {
  HierarchicalMapperController::Options hierarchical_options;
  SceneClustering::Options clustering_options;
  std::string output_path;

  OptionManager options;
  options.AddRequiredOption(""database_path"",
                            &hierarchical_options.database_path);
  options.AddRequiredOption(""image_path"", &hierarchical_options.image_path);
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddDefaultOption(""num_workers"", &hierarchical_options.num_workers);
  options.AddDefaultOption(""image_overlap"", &clustering_options.image_overlap);
  options.AddDefaultOption(""leaf_max_num_images"",
                           &clustering_options.leaf_max_num_images);
  options.AddMapperOptions();
  options.Parse(argc, argv);

  if (!ExistsDir(output_path)) {
    std::cerr << ""ERROR: `output_path` is not a directory."" << std::endl;
    return EXIT_FAILURE;
  }

  ReconstructionManager reconstruction_manager;

  HierarchicalMapperController hierarchical_mapper(
      hierarchical_options, clustering_options, *options.mapper,
      &reconstruction_manager);
  hierarchical_mapper.Start();
  hierarchical_mapper.Wait();

  reconstruction_manager.Write(output_path, &options);

  return EXIT_SUCCESS;
}

int RunMatchesImporter(int argc, char** argv) {
  std::string match_list_path;
  std::string match_type = ""pairs"";

  OptionManager options;
  options.AddDatabaseOptions();
  options.AddRequiredOption(""match_list_path"", &match_list_path);
  options.AddDefaultOption(""match_type"", &match_type,
                           ""{'pairs', 'raw', 'inliers'}"");
  options.AddMatchingOptions();
  options.Parse(argc, argv);

  std::unique_ptr<QApplication> app;
  if (options.sift_matching->use_gpu && kUseOpenGL) {
    app.reset(new QApplication(argc, argv));
  }

  std::unique_ptr<Thread> feature_matcher;
  if (match_type == ""pairs"") {
    ImagePairsMatchingOptions matcher_options;
    matcher_options.match_list_path = match_list_path;
    feature_matcher.reset(new ImagePairsFeatureMatcher(
        matcher_options, *options.sift_matching, *options.database_path));
  } else if (match_type == ""raw"" || match_type == ""inliers"") {
    FeaturePairsMatchingOptions matcher_options;
    matcher_options.match_list_path = match_list_path;
    matcher_options.verify_matches = match_type == ""raw"";
    feature_matcher.reset(new FeaturePairsFeatureMatcher(
        matcher_options, *options.sift_matching, *options.database_path));
  } else {
    std::cerr << ""ERROR: Invalid `match_type`"";
    return EXIT_FAILURE;
  }

  if (options.sift_matching->use_gpu && kUseOpenGL) {
    RunThreadWithOpenGLContext(feature_matcher.get());
  } else {
    feature_matcher->Start();
    feature_matcher->Wait();
  }

  return EXIT_SUCCESS;
}

int RunModelAligner(int argc, char** argv) {
  std::string input_path;
  std::string ref_images_path;
  std::string output_path;
  int min_common_images = 3;
  bool robust_alignment = true;
  RANSACOptions ransac_options;

  OptionManager options;
  options.AddRequiredOption(""input_path"", &input_path);
  options.AddRequiredOption(""ref_images_path"", &ref_images_path);
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddDefaultOption(""min_common_images"", &min_common_images);
  options.AddDefaultOption(""robust_alignment"", &robust_alignment);
  options.AddDefaultOption(""robust_alignment_max_error"",
                           &ransac_options.max_error);
  options.Parse(argc, argv);

  if (robust_alignment && ransac_options.max_error <= 0) {
    std::cout << ""ERROR: You must provide a maximum alignment error > 0""
              << std::endl;
    return EXIT_FAILURE;
  }

  std::vector<std::string> ref_image_names;
  std::vector<Eigen::Vector3d> ref_locations;
  std::vector<std::string> lines = ReadTextFileLines(ref_images_path);
  for (const auto line : lines) {
    std::stringstream line_parser(line);
    std::string image_name = """";
    Eigen::Vector3d camera_position;
    line_parser >> image_name >> camera_position[0] >> camera_position[1] >>
        camera_position[2];
    ref_image_names.push_back(image_name);
    ref_locations.push_back(camera_position);
  }

  Reconstruction reconstruction;
  reconstruction.Read(input_path);

  PrintHeading2(""Aligning reconstruction"");

  std::cout << StringPrintf("" => Using %d reference images"",
                            ref_image_names.size())
            << std::endl;

  bool alignment_success;
  if (robust_alignment) {
    alignment_success = reconstruction.AlignRobust(
        ref_image_names, ref_locations, min_common_images, ransac_options);
  } else {
    alignment_success =
        reconstruction.Align(ref_image_names, ref_locations, min_common_images);
  }

  if (alignment_success) {
    std::cout << "" => Alignment succeeded"" << std::endl;
    reconstruction.Write(output_path);

    std::vector<double> errors;
    errors.reserve(ref_image_names.size());

    for (size_t i = 0; i < ref_image_names.size(); ++i) {
      const Image* image = reconstruction.FindImageWithName(ref_image_names[i]);
      if (image != nullptr) {
        errors.push_back((image->ProjectionCenter() - ref_locations[i]).norm());
      }
    }

    std::cout << StringPrintf("" => Alignment error: %f (mean), %f (median)"",
                              Mean(errors), Median(errors))
              << std::endl;
  } else {
    std::cout << "" => Alignment failed"" << std::endl;
  }

  return EXIT_SUCCESS;
}

int RunModelAnalyzer(int argc, char** argv) {
  std::string path;

  OptionManager options;
  options.AddRequiredOption(""path"", &path);
  options.Parse(argc, argv);

  Reconstruction reconstruction;
  reconstruction.Read(path);

  std::cout << StringPrintf(""Cameras: %d"", reconstruction.NumCameras())
            << std::endl;
  std::cout << StringPrintf(""Images: %d"", reconstruction.NumImages())
            << std::endl;
  std::cout << StringPrintf(""Registered images: %d"",
                            reconstruction.NumRegImages())
            << std::endl;
  std::cout << StringPrintf(""Points: %d"", reconstruction.NumPoints3D())
            << std::endl;
  std::cout << StringPrintf(""Observations: %d"",
                            reconstruction.ComputeNumObservations())
            << std::endl;
  std::cout << StringPrintf(""Mean track length: %f"",
                            reconstruction.ComputeMeanTrackLength())
            << std::endl;
  std::cout << StringPrintf(""Mean observations per image: %f"",
                            reconstruction.ComputeMeanObservationsPerRegImage())
            << std::endl;
  std::cout << StringPrintf(""Mean reprojection error: %fpx"",
                            reconstruction.ComputeMeanReprojectionError())
            << std::endl;

  return EXIT_SUCCESS;
}

int RunModelConverter(int argc, char** argv) {
  std::string input_path;
  std::string output_path;
  std::string output_type;

  OptionManager options;
  options.AddRequiredOption(""input_path"", &input_path);
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddRequiredOption(""output_type"", &output_type,
                            ""{BIN, TXT, NVM, Bundler, VRML, PLY}"");
  options.Parse(argc, argv);

  Reconstruction reconstruction;
  reconstruction.Read(input_path);

  StringToLower(&output_type);
  if (output_type == ""bin"") {
    reconstruction.WriteBinary(output_path);
  } else if (output_type == ""txt"") {
    reconstruction.WriteText(output_path);
  } else if (output_type == ""nvm"") {
    reconstruction.ExportNVM(output_path);
  } else if (output_type == ""bundler"") {
    reconstruction.ExportBundler(output_path + "".bundle.out"",
                                 output_path + "".list.txt"");
  } else if (output_type == ""ply"") {
    reconstruction.ExportPLY(output_path);
  } else if (output_type == ""vrml"") {
    const auto base_path = output_path.substr(0, output_path.find_last_of("".""));
    reconstruction.ExportVRML(base_path + "".images.wrl"",
                              base_path + "".points3D.wrl"", 1,
                              Eigen::Vector3d(1, 0, 0));
  } else {
    std::cerr << ""ERROR: Invalid `output_type`"" << std::endl;
    return EXIT_FAILURE;
  }

  return EXIT_SUCCESS;
}

int RunModelMerger(int argc, char** argv) {
  std::string input_path1;
  std::string input_path2;
  std::string output_path;
  double max_reproj_error = 64.0;

  OptionManager options;
  options.AddRequiredOption(""input_path1"", &input_path1);
  options.AddRequiredOption(""input_path2"", &input_path2);
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddDefaultOption(""max_reproj_error"", &max_reproj_error);
  options.Parse(argc, argv);

  Reconstruction reconstruction1;
  reconstruction1.Read(input_path1);
  PrintHeading2(""Reconstruction 1"");
  std::cout << StringPrintf(""Images: %d"", reconstruction1.NumRegImages())
            << std::endl;
  std::cout << StringPrintf(""Points: %d"", reconstruction1.NumPoints3D())
            << std::endl;

  Reconstruction reconstruction2;
  reconstruction2.Read(input_path2);
  PrintHeading2(""Reconstruction 2"");
  std::cout << StringPrintf(""Images: %d"", reconstruction2.NumRegImages())
            << std::endl;
  std::cout << StringPrintf(""Points: %d"", reconstruction2.NumPoints3D())
            << std::endl;

  PrintHeading2(""Merging reconstructions"");
  if (reconstruction1.Merge(reconstruction2, max_reproj_error)) {
    std::cout << ""=> Merge succeeded"" << std::endl;
    PrintHeading2(""Merged reconstruction"");
    std::cout << StringPrintf(""Images: %d"", reconstruction1.NumRegImages())
              << std::endl;
    std::cout << StringPrintf(""Points: %d"", reconstruction1.NumPoints3D())
              << std::endl;
  } else {
    std::cout << ""=> Merge failed"" << std::endl;
  }

  reconstruction1.Write(output_path);

  return EXIT_SUCCESS;
}

int RunModelOrientationAligner(int argc, char** argv) {
  std::string input_path;
  std::string output_path;
  std::string method = ""MANHATTAN-WORLD"";

  ManhattanWorldFrameEstimationOptions frame_estimation_options;

  OptionManager options;
  options.AddImageOptions();
  options.AddRequiredOption(""input_path"", &input_path);
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddDefaultOption(""method"", &method,
                           ""{MANHATTAN-WORLD, IMAGE-ORIENTATION}"");
  options.AddDefaultOption(""max_image_size"",
                           &frame_estimation_options.max_image_size);
  options.Parse(argc, argv);

  StringToLower(&method);
  if (method != ""manhattan-world"" && method != ""image-orientation"") {
    std::cout << ""ERROR: Invalid `method` - supported values are ""
                 ""'MANHATTAN-WORLD' or 'IMAGE-ORIENTATION'.""
              << std::endl;
    return EXIT_FAILURE;
  }

  Reconstruction reconstruction;
  reconstruction.Read(input_path);

  PrintHeading1(""Aligning Reconstruction"");

  Eigen::Matrix3d tform;

  if (method == ""manhattan-world"") {
    const Eigen::Matrix3d frame = EstimateManhattanWorldFrame(
        frame_estimation_options, reconstruction, *options.image_path);

    if (frame.col(0).nonZeros() == 0) {
      std::cout << ""Only aligning vertical axis"" << std::endl;
      tform = RotationFromUnitVectors(frame.col(1), Eigen::Vector3d(0, 1, 0));
    } else if (frame.col(1).nonZeros() == 0) {
      tform = RotationFromUnitVectors(frame.col(0), Eigen::Vector3d(1, 0, 0));
      std::cout << ""Only aligning horizontal axis"" << std::endl;
    } else {
      tform = frame.transpose();
      std::cout << ""Aligning horizontal and vertical axes"" << std::endl;
    }
  } else if (method == ""image-orientation"") {
    const Eigen::Vector3d gravity_axis =
        EstimateGravityVectorFromImageOrientation(reconstruction);
    tform = RotationFromUnitVectors(gravity_axis, Eigen::Vector3d(0, 1, 0));
  } else {
    LOG(FATAL) << ""Alignment method not supported"";
  }

  std::cout << ""Using the rotation matrix:"" << std::endl;
  std::cout << tform << std::endl;

  reconstruction.Transform(SimilarityTransform3(
      1, RotationMatrixToQuaternion(tform), Eigen::Vector3d(0, 0, 0)));

  std::cout << ""Writing aligned reconstruction..."" << std::endl;
  reconstruction.Write(output_path);

  return EXIT_SUCCESS;
}

int RunSequentialMatcher(int argc, char** argv) {
  OptionManager options;
  options.AddDatabaseOptions();
  options.AddSequentialMatchingOptions();
  options.Parse(argc, argv);

  std::unique_ptr<QApplication> app;
  if (options.sift_matching->use_gpu && kUseOpenGL) {
    app.reset(new QApplication(argc, argv));
  }

  SequentialFeatureMatcher feature_matcher(*options.sequential_matching,
                                           *options.sift_matching,
                                           *options.database_path);

  if (options.sift_matching->use_gpu && kUseOpenGL) {
    RunThreadWithOpenGLContext(&feature_matcher);
  } else {
    feature_matcher.Start();
    feature_matcher.Wait();
  }

  return EXIT_SUCCESS;
}

int RunPointFiltering(int argc, char** argv) {
  std::string input_path;
  std::string output_path;

  size_t min_track_len = 2;
  double max_reproj_error = 4.0;
  double min_tri_angle = 1.5;

  OptionManager options;
  options.AddRequiredOption(""input_path"", &input_path);
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddDefaultOption(""min_track_len"", &min_track_len);
  options.AddDefaultOption(""max_reproj_error"", &max_reproj_error);
  options.AddDefaultOption(""min_tri_angle"", &min_tri_angle);
  options.Parse(argc, argv);

  Reconstruction reconstruction;
  reconstruction.Read(input_path);

  size_t num_filtered =
      reconstruction.FilterAllPoints3D(max_reproj_error, min_tri_angle);

  for (const auto point3D_id : reconstruction.Point3DIds()) {
    const auto& point3D = reconstruction.Point3D(point3D_id);
    if (point3D.Track().Length() < min_track_len) {
      num_filtered += point3D.Track().Length();
      reconstruction.DeletePoint3D(point3D_id);
    }
  }

  std::cout << ""Filtered observations: "" << num_filtered << std::endl;

  reconstruction.Write(output_path);

  return EXIT_SUCCESS;
}

int RunPointTriangulator(int argc, char** argv) {
  std::string input_path;
  std::string output_path;
  bool clear_points = false;

  OptionManager options;
  options.AddDatabaseOptions();
  options.AddImageOptions();
  options.AddRequiredOption(""input_path"", &input_path);
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddDefaultOption(
      ""clear_points"", &clear_points,
      ""Whether to clear all existing points and observations"");
  options.AddMapperOptions();
  options.Parse(argc, argv);

  if (!ExistsDir(input_path)) {
    std::cerr << ""ERROR: `input_path` is not a directory"" << std::endl;
    return EXIT_FAILURE;
  }

  if (!ExistsDir(output_path)) {
    std::cerr << ""ERROR: `output_path` is not a directory"" << std::endl;
    return EXIT_FAILURE;
  }

  const auto& mapper_options = *options.mapper;

  PrintHeading1(""Loading model"");

  Reconstruction reconstruction;
  reconstruction.Read(input_path);

  PrintHeading1(""Loading database"");

  DatabaseCache database_cache;

  {
    Timer timer;
    timer.Start();

    Database database(*options.database_path);

    const size_t min_num_matches =
        static_cast<size_t>(mapper_options.min_num_matches);
    database_cache.Load(database, min_num_matches,
                        mapper_options.ignore_watermarks,
                        mapper_options.image_names);

    if (clear_points) {
      reconstruction.DeleteAllPoints2DAndPoints3D();
      reconstruction.TranscribeImageIdsToDatabase(database);
    }

    std::cout << std::endl;
    timer.PrintMinutes();
  }

  std::cout << std::endl;

  CHECK_GE(reconstruction.NumRegImages(), 2)
      << ""Need at least two images for triangulation"";

  IncrementalMapper mapper(&database_cache);
  mapper.BeginReconstruction(&reconstruction);

  //////////////////////////////////////////////////////////////////////////////
  // Triangulation
  //////////////////////////////////////////////////////////////////////////////

  const auto tri_options = mapper_options.Triangulation();

  const auto& reg_image_ids = reconstruction.RegImageIds();

  for (size_t i = 0; i < reg_image_ids.size(); ++i) {
    const image_t image_id = reg_image_ids[i];

    const auto& image = reconstruction.Image(image_id);

    PrintHeading1(StringPrintf(""Triangulating image #%d (%d)"", image_id, i));

    const size_t num_existing_points3D = image.NumPoints3D();

    std::cout << ""  => Image sees "" << num_existing_points3D << "" / ""
              << image.NumObservations() << "" points"" << std::endl;

    mapper.TriangulateImage(tri_options, image_id);

    std::cout << ""  => Triangulated ""
              << (image.NumPoints3D() - num_existing_points3D) << "" points""
              << std::endl;
  }

  //////////////////////////////////////////////////////////////////////////////
  // Retriangulation
  //////////////////////////////////////////////////////////////////////////////

  PrintHeading1(""Retriangulation"");

  CompleteAndMergeTracks(mapper_options, &mapper);

  //////////////////////////////////////////////////////////////////////////////
  // Bundle adjustment
  //////////////////////////////////////////////////////////////////////////////

  auto ba_options = mapper_options.GlobalBundleAdjustment();
  ba_options.refine_focal_length = false;
  ba_options.refine_principal_point = false;
  ba_options.refine_extra_params = false;
  ba_options.refine_extrinsics = false;

  // Configure bundle adjustment.
  BundleAdjustmentConfig ba_config;
  for (const image_t image_id : reconstruction.RegImageIds()) {
    ba_config.AddImage(image_id);
  }

  for (int i = 0; i < mapper_options.ba_global_max_refinements; ++i) {
    // Avoid degeneracies in bundle adjustment.
    reconstruction.FilterObservationsWithNegativeDepth();

    const size_t num_observations = reconstruction.ComputeNumObservations();

    PrintHeading1(""Bundle adjustment"");
    BundleAdjuster bundle_adjuster(ba_options, ba_config);
    CHECK(bundle_adjuster.Solve(&reconstruction));

    size_t num_changed_observations = 0;
    num_changed_observations += CompleteAndMergeTracks(mapper_options, &mapper);
    num_changed_observations += FilterPoints(mapper_options, &mapper);
    const double changed =
        static_cast<double>(num_changed_observations) / num_observations;
    std::cout << StringPrintf(""  => Changed observations: %.6f"", changed)
              << std::endl;
    if (changed < mapper_options.ba_global_max_refinement_change) {
      break;
    }
  }

  PrintHeading1(""Extracting colors"");
  reconstruction.ExtractColorsForAllImages(*options.image_path);

  const bool kDiscardReconstruction = false;
  mapper.EndReconstruction(kDiscardReconstruction);

  reconstruction.Write(output_path);

  return EXIT_SUCCESS;
}

// Read the configuration of the camera rigs from a JSON file. The input images
// of a camera rig must be named consistently to assign them to the appropriate
// camera rig and the respective snapshots.
//
// An example configuration of a single camera rig:
// [
//   {
//     ""ref_camera_id"": 1,
//     ""cameras"":
//     [
//       {
//           ""camera_id"": 1,
//           ""image_prefix"": ""left1_image""
//       },
//       {
//           ""camera_id"": 2,
//           ""image_prefix"": ""left2_image""
//       },
//       {
//           ""camera_id"": 3,
//           ""image_prefix"": ""right1_image""
//       },
//       {
//           ""camera_id"": 4,
//           ""image_prefix"": ""right2_image""
//       }
//     ]
//   }
// ]
//
// This file specifies the configuration for a single camera rig and that you
// could potentially define multiple camera rigs. The rig is composed of 4
// cameras: all images of the first camera must have ""left1_image"" as a name
// prefix, e.g., ""left1_image_frame000.png"" or ""left1_image/frame000.png"".
// Images with the same suffix (""_frame000.png"" and ""/frame000.png"") are
// assigned to the same snapshot, i.e., they are assumed to be captured at the
// same time. Only snapshots with the reference image registered will be added
// to the bundle adjustment problem. The remaining images will be added with
// independent poses to the bundle adjustment problem. The above configuration
// could have the following input image file structure:
//
//    /path/to/images/...
//        left1_image/...
//            frame000.png
//            frame001.png
//            frame002.png
//            ...
//        left2_image/...
//            frame000.png
//            frame001.png
//            frame002.png
//            ...
//        right1_image/...
//            frame000.png
//            frame001.png
//            frame002.png
//            ...
//        right2_image/...
//            frame000.png
//            frame001.png
//            frame002.png
//            ...
//
// TODO: Provide an option to manually / explicitly set the relative extrinsics
// of the camera rig. At the moment, the relative extrinsics are automatically
// inferred from the reconstruction.
std::vector<CameraRig> ReadCameraRigConfig(
    const std::string& rig_config_path, const Reconstruction& reconstruction) {
  boost::property_tree::ptree pt;
  boost::property_tree::read_json(rig_config_path.c_str(), pt);

  std::vector<CameraRig> camera_rigs;
  for (const auto& rig_config : pt) {
    CameraRig camera_rig;

    std::vector<std::string> image_prefixes;
    for (const auto& camera : rig_config.second.get_child(""cameras"")) {
      const int camera_id = camera.second.get<int>(""camera_id"");
      image_prefixes.push_back(camera.second.get<std::string>(""image_prefix""));
      camera_rig.AddCamera(camera_id, ComposeIdentityQuaternion(),
                           Eigen::Vector3d(0, 0, 0));
    }

    camera_rig.SetRefCameraId(rig_config.second.get<int>(""ref_camera_id""));

    std::unordered_map<std::string, std::vector<image_t>> snapshots;
    for (const auto image_id : reconstruction.RegImageIds()) {
      const auto& image = reconstruction.Image(image_id);
      for (const auto& image_prefix : image_prefixes) {
        if (StringContains(image.Name(), image_prefix)) {
          const std::string image_suffix =
              StringGetAfter(image.Name(), image_prefix);
          snapshots[image_suffix].push_back(image_id);
        }
      }
    }

    for (const auto& snapshot : snapshots) {
      bool has_ref_camera = false;
      for (const auto image_id : snapshot.second) {
        const auto& image = reconstruction.Image(image_id);
        if (image.CameraId() == camera_rig.RefCameraId()) {
          has_ref_camera = true;
        }
      }

      if (has_ref_camera) {
        camera_rig.AddSnapshot(snapshot.second);
      }
    }

    camera_rig.Check(reconstruction);
    camera_rig.ComputeRelativePoses(reconstruction);

    camera_rigs.push_back(camera_rig);
  }

  return camera_rigs;
}

int RunRigBundleAdjuster(int argc, char** argv) {
  std::string input_path;
  std::string output_path;
  std::string rig_config_path;

  OptionManager options;
  options.AddRequiredOption(""input_path"", &input_path);
  options.AddRequiredOption(""output_path"", &output_path);
  options.AddRequiredOption(""rig_config_path"", &rig_config_path);
  options.AddBundleAdjustmentOptions();
  options.Parse(argc, argv);

  Reconstruction reconstruction;
  reconstruction.Read(input_path);

  PrintHeading1(""Camera rig configuration"");

  auto camera_rigs = ReadCameraRigConfig(rig_config_path, reconstruction);

  BundleAdjustmentConfig config;
  for (size_t i = 0; i < camera_rigs.size(); ++i) {
    const auto& camera_rig = camera_rigs[i];
    PrintHeading2(StringPrintf(""Camera Rig %d"", i + 1));
    std::cout << StringPrintf(""Cameras: %d"", camera_rig.NumCameras())
              << std::endl;
    std::cout << StringPrintf(""Snapshots: %d"", camera_rig.NumSnapshots())
              << std::endl;

    // Add all registered images to the bundle adjustment configuration.
    for (const auto image_id : reconstruction.RegImageIds()) {
      config.AddImage(image_id);
    }
  }

  PrintHeading1(""Rig bundle adjustment"");

  BundleAdjustmentOptions ba_options = *options.bundle_adjustment;
  ba_options.solver_options.minimizer_progress_to_stdout = true;
  RigBundleAdjuster::Options rig_ba_options;
  RigBundleAdjuster bundle_adjuster(ba_options, rig_ba_options, config);
  CHECK(bundle_adjuster.Solve(&reconstruction, &camera_rigs));

  reconstruction.Write(output_path);

  return EXIT_SUCCESS;
}

int RunSpatialMatcher(int argc, char** argv) {
  OptionManager options;
  options.AddDatabaseOptions();
  options.AddSpatialMatchingOptions();
  options.Parse(argc, argv);

  std::unique_ptr<QApplication> app;
  if (options.sift_matching->use_gpu && kUseOpenGL) {
    app.reset(new QApplication(argc, argv));
  }

  SpatialFeatureMatcher feature_matcher(*options.spatial_matching,
                                        *options.sift_matching,
                                        *options.database_path);

  if (options.sift_matching->use_gpu && kUseOpenGL) {
    RunThreadWithOpenGLContext(&feature_matcher);
  } else {
    feature_matcher.Start();
    feature_matcher.Wait();
  }

  return EXIT_SUCCESS;
}

int RunTransitiveMatcher(int argc, char** argv) {
  OptionManager options;
  options.AddDatabaseOptions();
  options.AddTransitiveMatchingOptions();
  options.Parse(argc, argv);

  std::unique_ptr<QApplication> app;
  if (options.sift_matching->use_gpu && kUseOpenGL) {
    app.reset(new QApplication(argc, argv));
  }

  TransitiveFeatureMatcher feature_matcher(*options.transitive_matching,
                                           *options.sift_matching,
                                           *options.database_path);

  if (options.sift_matching->use_gpu && kUseOpenGL) {
    RunThreadWithOpenGLContext(&feature_matcher);
  } else {
    feature_matcher.Start();
    feature_matcher.Wait();
  }

  return EXIT_SUCCESS;
}

// Loads descriptors for training from the database. Loads all descriptors from
// the database if max_num_images < 0, otherwise the descriptors of a random
// subset of images are selected.
FeatureDescriptors LoadRandomDatabaseDescriptors(
    const std::string& database_path, const int max_num_images) {
  Database database(database_path);
  DatabaseTransaction database_transaction(&database);

  const std::vector<Image> images = database.ReadAllImages();

  FeatureDescriptors descriptors;

  std::vector<size_t> image_idxs;
  size_t num_descriptors = 0;
  if (max_num_images < 0) {
    // All images in the database.
    image_idxs.resize(images.size());
    std::iota(image_idxs.begin(), image_idxs.end(), 0);
    num_descriptors = database.NumDescriptors();
  } else {
    // Random subset of images in the database.
    CHECK_LE(max_num_images, images.size());
    RandomSampler random_sampler(max_num_images);
    random_sampler.Initialize(images.size());
    image_idxs = random_sampler.Sample();
    for (const auto image_idx : image_idxs) {
      const auto& image = images.at(image_idx);
      num_descriptors += database.NumDescriptorsForImage(image.ImageId());
    }
  }

  descriptors.resize(num_descriptors, 128);

  size_t descriptor_row = 0;
  for (const auto image_idx : image_idxs) {
    const auto& image = images.at(image_idx);
    const FeatureDescriptors image_descriptors =
        database.ReadDescriptors(image.ImageId());
    descriptors.block(descriptor_row, 0, image_descriptors.rows(), 128) =
        image_descriptors;
    descriptor_row += image_descriptors.rows();
  }

  CHECK_EQ(descriptor_row, num_descriptors);

  return descriptors;
}

int RunVocabTreeBuilder(int argc, char** argv) {
  std::string vocab_tree_path;
  retrieval::VisualIndex<>::BuildOptions build_options;
  int max_num_images = -1;

  OptionManager options;
  options.AddDatabaseOptions();
  options.AddRequiredOption(""vocab_tree_path"", &vocab_tree_path);
  options.AddDefaultOption(""num_visual_words"", &build_options.num_visual_words);
  options.AddDefaultOption(""num_checks"", &build_options.num_checks);
  options.AddDefaultOption(""branching"", &build_options.branching);
  options.AddDefaultOption(""num_iterations"", &build_options.num_iterations);
  options.AddDefaultOption(""max_num_images"", &max_num_images);
  options.Parse(argc, argv);

  retrieval::VisualIndex<> visual_index;

  std::cout << ""Loading descriptors..."" << std::endl;
  const auto descriptors =
      LoadRandomDatabaseDescriptors(*options.database_path, max_num_images);
  std::cout << ""  => Loaded a total of "" << descriptors.rows() << "" descriptors""
            << std::endl;

  std::cout << ""Building index for visual words..."" << std::endl;
  visual_index.Build(build_options, descriptors);
  std::cout << "" => Quantized descriptor space using ""
            << visual_index.NumVisualWords() << "" visual words"" << std::endl;

  std::cout << ""Saving index to file..."" << std::endl;
  visual_index.Write(vocab_tree_path);

  return EXIT_SUCCESS;
}

int RunVocabTreeMatcher(int argc, char** argv) {
  OptionManager options;
  options.AddDatabaseOptions();
  options.AddVocabTreeMatchingOptions();
  options.Parse(argc, argv);

  std::unique_ptr<QApplication> app;
  if (options.sift_matching->use_gpu && kUseOpenGL) {
    app.reset(new QApplication(argc, argv));
  }

  VocabTreeFeatureMatcher feature_matcher(*options.vocab_tree_matching,
                                          *options.sift_matching,
                                          *options.database_path);

  if (options.sift_matching->use_gpu && kUseOpenGL) {
    RunThreadWithOpenGLContext(&feature_matcher);
  } else {
    feature_matcher.Start();
    feature_matcher.Wait();
  }

  return EXIT_SUCCESS;
}

std::vector<Image> ReadVocabTreeRetrievalImageList(const std::string& path,
                                                   Database* database) {
  std::vector<Image> images;
  if (path.empty()) {
    images.reserve(database->NumImages());
    for (const auto& image : database->ReadAllImages()) {
      images.push_back(image);
    }
  } else {
    DatabaseTransaction database_transaction(database);

    const auto image_names = ReadTextFileLines(path);
    images.reserve(image_names.size());
    for (const auto& image_name : image_names) {
      const auto image = database->ReadImageWithName(image_name);
      CHECK_NE(image.ImageId(), kInvalidImageId);
      images.push_back(image);
    }
  }
  return images;
}

int RunVocabTreeRetriever(int argc, char** argv) {
  std::string vocab_tree_path;
  std::string database_image_list_path;
  std::string query_image_list_path;
  std::string output_index_path;
  retrieval::VisualIndex<>::QueryOptions query_options;
  int max_num_features = -1;

  OptionManager options;
  options.AddDatabaseOptions();
  options.AddRequiredOption(""vocab_tree_path"", &vocab_tree_path);
  options.AddDefaultOption(""database_image_list_path"",
                           &database_image_list_path);
  options.AddDefaultOption(""query_image_list_path"", &query_image_list_path);
  options.AddDefaultOption(""output_index_path"", &output_index_path);
  options.AddDefaultOption(""num_images"", &query_options.max_num_images);
  options.AddDefaultOption(""num_neighbors"", &query_options.num_neighbors);
  options.AddDefaultOption(""num_checks"", &query_options.num_checks);
  options.AddDefaultOption(""num_images_after_verification"",
                           &query_options.num_images_after_verification);
  options.AddDefaultOption(""max_num_features"", &max_num_features);
  options.Parse(argc, argv);

  retrieval::VisualIndex<> visual_index;
  visual_index.Read(vocab_tree_path);

  Database database(*options.database_path);

  const auto database_images =
      ReadVocabTreeRetrievalImageList(database_image_list_path, &database);
  const auto query_images =
      (!query_image_list_path.empty() || output_index_path.empty())
          ? ReadVocabTreeRetrievalImageList(query_image_list_path, &database)
          : std::vector<Image>();

  //////////////////////////////////////////////////////////////////////////////
  // Perform image indexing
  //////////////////////////////////////////////////////////////////////////////

  for (size_t i = 0; i < database_images.size(); ++i) {
    Timer timer;
    timer.Start();

    std::cout << StringPrintf(""Indexing image [%d/%d]"", i + 1,
                              database_images.size())
              << std::flush;

    if (visual_index.ImageIndexed(database_images[i].ImageId())) {
      std::cout << std::endl;
      continue;
    }

    auto keypoints = database.ReadKeypoints(database_images[i].ImageId());
    auto descriptors = database.ReadDescriptors(database_images[i].ImageId());
    if (max_num_features > 0 && descriptors.rows() > max_num_features) {
      ExtractTopScaleFeatures(&keypoints, &descriptors, max_num_features);
    }

    visual_index.Add(retrieval::VisualIndex<>::IndexOptions(),
                     database_images[i].ImageId(), keypoints, descriptors);

    std::cout << StringPrintf("" in %.3fs"", timer.ElapsedSeconds()) << std::endl;
  }

  // Compute the TF-IDF weights, etc.
  visual_index.Prepare();

  // Optionally save the indexing data for the database images (as well as the
  // original vocabulary tree data) to speed up future indexing.
  if (!output_index_path.empty()) {
    visual_index.Write(output_index_path);
  }

  if (query_images.empty()) {
    return EXIT_SUCCESS;
  }

  //////////////////////////////////////////////////////////////////////////////
  // Perform image queries
  //////////////////////////////////////////////////////////////////////////////

  std::unordered_map<image_t, const Image*> image_id_to_image;
  image_id_to_image.reserve(database_images.size());
  for (const auto& image : database_images) {
    image_id_to_image.emplace(image.ImageId(), &image);
  }

  for (size_t i = 0; i < query_images.size(); ++i) {
    Timer timer;
    timer.Start();

    std::cout << StringPrintf(""Querying for image %s [%d/%d]"",
                              query_images[i].Name().c_str(), i + 1,
                              query_images.size())
              << std::flush;

    auto keypoints = database.ReadKeypoints(query_images[i].ImageId());
    auto descriptors = database.ReadDescriptors(query_images[i].ImageId());
    if (max_num_features > 0 && descriptors.rows() > max_num_features) {
      ExtractTopScaleFeatures(&keypoints, &descriptors, max_num_features);
    }

    std::vector<retrieval::ImageScore> image_scores;
    visual_index.Query(query_options, keypoints, descriptors, &image_scores);

    std::cout << StringPrintf("" in %.3fs"", timer.ElapsedSeconds()) << std::endl;
    for (const auto& image_score : image_scores) {
      const auto& image = *image_id_to_image.at(image_score.image_id);
      std::cout << StringPrintf(""  image_id=%d, image_name=%s, score=%f"",
                                image_score.image_id, image.Name().c_str(),
                                image_score.score)
                << std::endl;
    }
  }

  return EXIT_SUCCESS;
}

typedef std::function<int(int, char**)> command_func_t;

int ShowHelp(
    const std::vector<std::pair<std::string, command_func_t>>& commands) {
  std::cout << StringPrintf(
                   ""%s -- Structure-from-Motion and Multi-View Stereo\\n""
                   ""              (%s)"",
                   GetVersionInfo().c_str(), GetBuildInfo().c_str())
            << std::endl
            << std::endl;

  std::cout << ""Usage:"" << std::endl;
  std::cout << ""  colmap [command] [options]"" << std::endl << std::endl;

  std::cout << ""Documentation:"" << std::endl;
  std::cout << ""  https://colmap.github.io/"" << std::endl << std::endl;

  std::cout << ""Example usage:"" << std::endl;
  std::cout << ""  colmap help [ -h, --help ]"" << std::endl;
  std::cout << ""  colmap gui"" << std::endl;
  std::cout << ""  colmap gui -h [ --help ]"" << std::endl;
  std::cout << ""  colmap automatic_reconstructor -h [ --help ]"" << std::endl;
  std::cout << ""  colmap automatic_reconstructor --image_path IMAGES ""
               ""--workspace_path WORKSPACE""
            << std::endl;
  std::cout << ""  colmap feature_extractor --image_path IMAGES --database_path ""
               ""DATABASE""
            << std::endl;
  std::cout << ""  colmap exhaustive_matcher --database_path DATABASE""
            << std::endl;
  std::cout << ""  colmap mapper --image_path IMAGES --database_path DATABASE ""
               ""--output_path MODEL""
            << std::endl;
  std::cout << ""  ..."" << std::endl << std::endl;

  std::cout << ""Available commands:"" << std::endl;
  std::cout << ""  help"" << std::endl;
  for (const auto& command : commands) {
    std::cout << ""  "" << command.first << std::endl;
  }
  std::cout << std::endl;

  return EXIT_SUCCESS;
}

int main(int argc, char** argv) {
  InitializeGlog(argv);

  std::vector<std::pair<std::string, command_func_t>> commands;
  commands.emplace_back(""gui"", &RunGraphicalUserInterface);
  commands.emplace_back(""automatic_reconstructor"", &RunAutomaticReconstructor);
  commands.emplace_back(""bundle_adjuster"", &RunBundleAdjuster);
  commands.emplace_back(""color_extractor"", &RunColorExtractor);
  commands.emplace_back(""database_creator"", &RunDatabaseCreator);
  commands.emplace_back(""database_merger"", &RunDatabaseMerger);
  commands.emplace_back(""delaunay_mesher"", &RunDelaunayMesher);
  commands.emplace_back(""exhaustive_matcher"", &RunExhaustiveMatcher);
  commands.emplace_back(""feature_extractor"", &RunFeatureExtractor);
  commands.emplace_back(""feature_importer"", &RunFeatureImporter);
  commands.emplace_back(""hierarchical_mapper"", &RunHierarchicalMapper);
  commands.emplace_back(""image_deleter"", &RunImageDeleter);
  commands.emplace_back(""image_filterer"", &RunImageFilterer);
  commands.emplace_back(""image_rectifier"", &RunImageRectifier);
  commands.emplace_back(""image_registrator"", &RunImageRegistrator);
  commands.emplace_back(""image_undistorter"", &RunImageUndistorter);
  commands.emplace_back(""mapper"", &RunMapper);
  commands.emplace_back(""matches_importer"", &RunMatchesImporter);
  commands.emplace_back(""model_aligner"", &RunModelAligner);
  commands.emplace_back(""model_analyzer"", &RunModelAnalyzer);
  commands.emplace_back(""model_converter"", &RunModelConverter);
  commands.emplace_back(""model_merger"", &RunModelMerger);
  commands.emplace_back(""model_orientation_aligner"",
                        &RunModelOrientationAligner);
  commands.emplace_back(""patch_match_stereo"", &RunPatchMatchStereo);
  commands.emplace_back(""point_filtering"", &RunPointFiltering);
  commands.emplace_back(""point_triangulator"", &RunPointTriangulator);
  commands.emplace_back(""poisson_mesher"", &RunPoissonMesher);
  commands.emplace_back(""project_generator"", &RunProjectGenerator);
  commands.emplace_back(""rig_bundle_adjuster"", &RunRigBundleAdjuster);
  commands.emplace_back(""sequential_matcher"", &RunSequentialMatcher);
  commands.emplace_back(""spatial_matcher"", &RunSpatialMatcher);
  commands.emplace_back(""stereo_fusion"", &RunStereoFuser);
  commands.emplace_back(""transitive_matcher"", &RunTransitiveMatcher);
  commands.emplace_back(""vocab_tree_builder"", &RunVocabTreeBuilder);
  commands.emplace_back(""vocab_tree_matcher"", &RunVocabTreeMatcher);
  commands.emplace_back(""vocab_tree_retriever"", &RunVocabTreeRetriever);

  if (argc == 1) {
    return ShowHelp(commands);
  }

  const std::string command = argv[1];
  if (command == ""help"" || command == ""-h"" || command == ""--help"") {
    return ShowHelp(commands);
  } else {
    command_func_t matched_command_func = nullptr;
    for (const auto& command_func : commands) {
      if (command == command_func.first) {
        matched_command_func = command_func.second;
        break;
      }
    }
    if (matched_command_func == nullptr) {
      std::cerr << StringPrintf(
                       ""ERROR: Command `%s` not recognized. To list the ""
                       ""available commands, run `colmap help`."",
                       command.c_str())
                << std::endl;
      return EXIT_FAILURE;
    } else {
      int command_argc = argc - 1;
      char** command_argv = &argv[1];
      command_argv[0] = argv[0];
      return matched_command_func(command_argc, command_argv);
    }
  }

  return ShowHelp(commands);
}
",16162,True,3090.1958958223195,median
"[[scoreCalculation]]
= Score calculation
:doctype: book
:sectnums:
:icons: font


[[scoreTerminology]]
== Score terminology


[[whatIsAScore]]
=== What is a score?

Every `@PlanningSolution` class has a score.
The score is an objective way to compare two solutions.
The solution with the higher score is better.
The `Solver` aims to find the solution with the highest `Score` of all possible solutions.
The _best solution_ is the solution with the highest `Score` that `Solver` has encountered during solving,
which might be the __optimal solution__.

OptaPlanner cannot automatically know which solution is best for your business,
so you need to tell it how to calculate the score of a given `@PlanningSolution` instance according to your business needs.
If you forget or are unable to implement an important business constraint, the solution is probably useless:

image::score-calculation/optimalWithIncompleteConstraints.png[align=""center""]


[[formalizeTheBusinessConstraints]]
=== Formalize the business constraints

To implement a verbal business constraint, it needs to be formalized as a score constraint.
Luckily, defining constraints in OptaPlanner is very flexible through the following score techniques:

* **Score signum (positive or negative)**: maximize or minimize a constraint type
* **Score weight**: put a cost/profit on a constraint type
* **Score level (hard, soft, ...)**: prioritize a group of constraint types
* *Pareto scoring* (rarely used)

Take the time to acquaint yourself with the first three techniques.
Once you understand them, formalizing most business constraints becomes straightforward.

[NOTE]
====
Do not presume that your business knows all its score constraints in advance.
Expect score constraints to be added, changed or removed after the first releases.
====


[[scoreConstraintSignum]]
=== Score constraint signum (positive or negative)

All score techniques are based on constraints.
A constraint can be a simple pattern (such as __Maximize the apple harvest in the solution__) or a more complex pattern.
A positive constraint is a constraint you want to maximize.
A negative constraint is a constraint you want to minimize

image::score-calculation/positiveAndNegativeConstraints.png[align=""center""]

The image above illustrates that **the optimal solution always has the highest score**,
regardless if the constraints are positive or negative.

Most planning problems have only negative constraints and therefore have a negative score.
In that case, the score is the sum of the weight of the negative constraints being broken, with a perfect score of 0.
For example in n queens, the score is the negative of the number of queen pairs which can attack each other.

Negative and positive constraints can be combined, even in the same score level.

When a constraint activates (because the negative constraint is broken or the positive constraint is fulfilled)
on a certain planning entity set, it is called a __constraint match__.


[[scoreConstraintWeight]]
=== Score constraint weight

Not all score constraints are equally important.
If breaking one constraint is equally bad as breaking another constraint x times,
then those two constraints have a different weight (but they are in the same score level).
For example in vehicle routing, you can make one _unhappy driver_ constraint match count
as much as two _fuel tank usage_ constraint matches:

image::score-calculation/scoreWeighting.png[align=""center""]

Score weighting is easy in use cases where you can __put a price tag on everything__.
In that case, the positive constraints maximize revenue and the negative constraints minimize expenses, so together they maximize profit.
Alternatively, score weighting is also often used to create social <<fairnessScoreConstraints,fairness>>.
For example, a nurse, who requests a free day, pays a higher weight on New Years eve than on a normal day.

The weight of a constraint match can depend on the planning entities involved.
For example in cloud balancing, the weight of the soft constraint match for an active `Computer`
is the maintenance `cost` of that `Computer` (which differs per computer).

Putting a good weight on a constraint is often a difficult analytical decision,
because it is about making choices and trade-offs against other constraints.
Different stakeholders have different priorities.
*Don't waste time with constraint weight discussions at the start of an implementation,
instead add a <<constraintConfiguration, constraint configuration>>
and  allow users to change them through a UI.*
A non-accurate weight is less damaging than mediocre algorithms:

image::score-calculation/scoreTradeoffInPerspective.png[align=""center""]

Most use cases use a `Score` with `int` weights, such as <<hardSoftScore,HardSoftScore>>.


[[scoreLevel]]
=== Score constraint level (hard, soft, ...)

Sometimes a score constraint outranks another score constraint, no matter how many times the latter is broken.
In that case, those score constraints are in different levels.
For example, a nurse cannot do two shifts at the same time (due to the constraints of physical reality),
so this outranks all nurse happiness constraints.

Most use cases have only two score levels, hard and soft.
The levels of two scores are compared lexicographically.
The first score level gets compared first.
If those differ, the remaining score levels are ignored.
For example, a score that breaks `0` hard constraints and `1000000` soft constraints is better
than a score that breaks `1` hard constraint and `0` soft constraints.

image::score-calculation/scoreLevels.png[align=""center""]

If there are two (or more) score levels, for example <<hardSoftScore,HardSoftScore>>,
then a score is _feasible_ if no hard constraints are broken.

[NOTE]
====
By default, OptaPlanner will always assign all planning variables a planning value.
If there is no feasible solution, this means the best solution will be infeasible.
To instead leave some of the planning entities unassigned, apply xref:repeated-planning/repeated-planning.adoc#overconstrainedPlanning[overconstrained planning].
====

For each constraint, you need to pick a score level, a score weight and a score signum.
For example: `-1soft` which has score level of ``soft``, a weight of `1` and a negative signum.
Do not use a big constraint weight when your business actually wants different score levels.
That hack, known as __score folding__, is broken:

image::score-calculation/scoreFoldingIsBroken.png[align=""center""]


[NOTE]
====
Your business might tell you that your hard constraints all have the same weight, because they cannot be broken (so the weight does not matter). This is not true because if no feasible solution exists for a specific dataset, the least infeasible solution allows the business to estimate how many business resources they are lacking.
For example in cloud balancing, how many new computers to buy.

Furthermore, it will likely create a <<scoreTrap,score trap>>.
For example in cloud balance if a `Computer` has seven CPU too little for its ``Process``es, then it must be weighted seven times as much as if it had only one CPU too little.
====

Three or more score levels are also supported.
For example: a company might decide that profit outranks employee satisfaction (or vice versa),
while both are outranked by the constraints of physical reality.

[NOTE]
====
To model <<fairnessScoreConstraints,fairness or load balancing>>, there is no need to use lots of score levels
(even though OptaPlanner can handle many score levels).
====

Most use cases use a `Score` with two or three weights,
such as <<hardSoftScore,HardSoftScore>> and <<hardMediumSoftScore,HardMediumSoftScore>>.


[[paretoScoring]]
=== Pareto scoring (AKA multi-objective optimization scoring)

Far less common is the use case of pareto optimization, which is also known as _multi-objective optimization_.
In pareto scoring, score constraints are in the same score level, yet they are not weighted against each other.
When two scores are compared, each of the score constraints are compared individually and the score with the most dominating score constraints wins.
Pareto scoring can even be combined with score levels and score constraint weighting.

Consider this example with positive constraints, where we want to get the most apples and oranges.
Since it is impossible to compare apples and oranges, we cannot weigh them against each other.
Yet, despite that we cannot compare them, we can state that two apples are better than one apple.
Similarly, we can state that two apples and one orange are better than just one orange.
So despite our inability to compare some Scores conclusively (at which point we declare them equal), we can find a set of optimal scores.
Those are called pareto optimal.

image::score-calculation/paretoOptimizationScoring.png[align=""center""]

Scores are considered equal far more often.
It is left up to a human to choose the better out of a set of best solutions (with equal scores) found by OptaPlanner.
In the example above, the user must choose between solution A (three apples and one orange) and solution B (one apple and six oranges). It is guaranteed that OptaPlanner has not found another solution which has more apples or more oranges or even a better combination of both (such as two apples and three oranges).

Pareto scoring is currently not supported in OptaPlanner.

[NOTE]
====
A pareto ``Score``'s `compareTo` method is not transitive because it does a pareto comparison.
For example: having two apples is greater than one apple.
One apple is equal to One orange.
Yet, two apples are not greater than one orange (but actually equal). Pareto comparison violates the contract of the interface ``java.lang.Comparable``'s `compareTo` method, but Planners systems are __pareto comparison safe__, unless explicitly stated otherwise in this documentation.
====


[[combiningScoreTechniques]]
=== Combining score techniques

All the score techniques mentioned above, can be combined seamlessly:

image::score-calculation/scoreComposition.png[align=""center""]


[[scoreInterface]]
=== `Score` interface

A score is represented by the `Score` interface, which naturally extends ``Comparable``:

[source,java,options=""nowrap""]
----
public interface Score<...> extends Comparable<...> {
    ...
}
----

The `Score` implementation to use depends on your use case.
Your score might not efficiently fit in a single `long` value.
OptaPlanner has several built-in `Score` implementations, but you can implement a custom `Score` too.
Most use cases tend to use the built-in ``HardSoftScore``.

image::score-calculation/scoreClassDiagram.png[align=""center""]

All Score implementations also have an `initScore` (which is an ``int``).It is mostly intended for internal use in OptaPlanner: it is the negative number of uninitialized planning variables.
From a user's perspective this is ``0``, unless a Construction Heuristic is terminated before it could initialize all planning variables (in which case `Score.isSolutionInitialized()` returns ``false``).

The `Score` implementation (for example ``HardSoftScore``) must be the same throughout a `Solver` runtime.
The `Score` implementation is configured in the solution domain class:

[source,java,options=""nowrap""]
----
@PlanningSolution
public class CloudBalance {
    ...

    @PlanningScore
    private HardSoftScore score;

}
----

[[avoidFloatingPointNumbersInScoreCalculation]]
=== Avoid floating point numbers in score calculation

Avoid the use of `float` or `double` in score calculation.
Use `BigDecimal` or scaled `long` instead.

Floating point numbers (``float`` and ``double``) cannot represent a decimal number correctly.
For example: a `double` cannot hold the value `0.05` correctly.
Instead, it holds the nearest representable value.
Arithmetic (including addition and subtraction) with floating point numbers, especially for planning problems, leads to incorrect decisions:

image::score-calculation/scoreWeightType.png[align=""center""]

Additionally, floating point number addition is not associative:

[source,java,options=""nowrap""]
----
System.out.println( ((0.01 + 0.02) + 0.03) == (0.01 + (0.02 + 0.03)) ); // returns false
----

This leads to __score corruption__.

Decimal numbers (``BigDecimal``) have none of these problems.

[NOTE]
====
BigDecimal arithmetic is considerably slower than ``int``, `long` or `double` arithmetic.
In experiments we have seen the score calculation take five times longer.

Therefore, in many cases, it can be worthwhile to multiply _all_ numbers for a single score weight by a plural of ten, so the score weight fits in a scaled `int` or ``long``.
For example, if we multiply all weights by ``1000``, a fuelCost of `0.07` becomes a fuelCostMillis of `70` and no longer uses a decimal score weight.
====


[[scoreType]]
== Choose a score type

Depending on the number of score levels and type of score weights you need, choose a `Score` type.
Most use cases use a ``HardSoftScore``.

[NOTE]
====
To properly write a `Score` to a database (with JPA/Hibernate) or to XML/JSON (with XStream/JAXB/Jackson),
see xref:integration/integration.adoc#integration[the integration chapter].
====


[[simpleScore]]
=== `SimpleScore`

A `SimpleScore` has a single `int` value, for example ``-123``.
It has a single score level.

[source,java,options=""nowrap""]
----
    @PlanningScore
    private SimpleScore score;
----

Variants of this `Score` type:

* `SimpleLongScore` uses a `long` value instead of an `int` value.
* `SimpleBigDecimalScore` uses a `BigDecimal` value instead of an `int` value.


[[hardSoftScore]]
=== `HardSoftScore` (Recommended)

A `HardSoftScore` has a hard `int` value and a soft `int` value, for example ``-123hard/-456soft``.
It has two score levels (hard and soft).

[source,java,options=""nowrap""]
----
    @PlanningScore
    private HardSoftScore score;
----

Variants of this `Score` type:

* `HardSoftLongScore` uses `long` values instead of `int` values.
* `HardSoftBigDecimalScore` uses `BigDecimal` values instead of `int` values.


[[hardMediumSoftScore]]
=== `HardMediumSoftScore`

A `HardMediumSoftScore` which has a hard `int` value, a medium `int` value and a soft `int` value, for example ``-123hard/-456medium/-789soft``.
It has three score levels (hard, medium and soft).
The hard level determines if the solution is feasible,
and the medium level and soft level score values determine
how well the solution meets business goals.
Higher medium values take precedence over soft values irrespective of the soft value.

[source,java,options=""nowrap""]
----
    @PlanningScore
    private HardMediumSoftScore score;
----

Variants of this `Score` type:

* `HardMediumSoftLongScore` uses `long` values instead of `int` values.
* `HardMediumSoftBigDecimalScore` uses `BigDecimal` values instead of `int` values.


[[bendableScore]]
=== `BendableScore`

A `BendableScore` has a configurable number of score levels.
It has an array of hard `int` values and an array of soft `int` values,
for example with two hard levels and three soft levels, the score can be ``[-123/-456]hard/[-789/-012/-345]soft``.
In that case, it has five score levels.
A solution is feasible if all hard levels are at least zero.

A BendableScore with one hard level and one soft level is equivalent to a HardSoftScore,
while a BendableScore with one hard level and two soft levels is equivalent to a HardMediumSoftScore.

[source,java,options=""nowrap""]
----
    @PlanningScore(bendableHardLevelsSize = 2, bendableSoftLevelsSize = 3)
    private BendableScore score;
----

The number of hard and soft score levels need to be set at compilation time.
It is not flexible to change during solving.

[NOTE]
====
Do not use a `BendableScore` with seven levels just because you have seven constraints.
It is extremely rare to use a different score level for each constraint, because that means one constraint match on soft 0 outweighs even a million constraint matches of soft 1.

Usually, multiple constraints share the same level and are weighted against each other.
Use <<explainingTheScore,explaining the score>> to get the weight of individual constraints in the same level.
====

Variants of this `Score` type:

* `BendableLongScore` uses `long` values instead of `int` values.
* `BendableBigDecimalScore` uses `BigDecimal` values instead of `int` values.


[[calculateTheScore]]
== Calculate the `Score`


[[scoreCalculationTypes]]
=== Score calculation types

There are several ways to calculate the `Score` of a solution:

* **<<easyJavaScoreCalculation,Easy Java score calculation>>**: Implement all constraints together in a single method in Java (or another JVM language). Does not scale.
* **xref:constraint-streams/constraint-streams.adoc#constraintStreams[Constraint streams score calculation]**: Implement each constraint as a separate Constraint Stream in Java (or another JVM language). Fast and scalable.
* **<<incrementalJavaScoreCalculation,Incremental Java score calculation>>** (not recommended): Implement multiple low-level methods in Java (or another JVM language). Fast and scalable. Very difficult to implement and maintain.
* **xref:drools-score-calculation/drools-score-calculation.adoc#droolsScoreCalculation[Drools score calculation]**: Implement each constraint as a separate score rule in DRL. Scalable.

Every score calculation type can work with any Score definition (such as ``HardSoftScore`` or ``HardMediumSoftScore``).
All score calculation types are Object Oriented and can reuse existing Java code.

[IMPORTANT]
====
The score calculation must be read-only.
It must not change the planning entities or the problem facts in any way.
For example, it must not call a setter method on a planning entity in the score calculation.

OptaPlanner does not recalculate the score of a solution if it can predict it (unless an xref:planner-configuration/planner-configuration.adoc#environmentMode[environmentMode assertion] is enabled).
For example, after a winning step is done, there is no need to calculate the score because that move was done and undone earlier.
As a result, there is no guarantee that changes applied during score calculation actually happen.

To update planning entities when the planning variable change, use xref:shadow-variable/shadow-variable.adoc#shadowVariable[shadow variables] instead.
====


[[easyJavaScoreCalculation]]
=== Easy Java score calculation

An easy way to implement your score calculation in Java.

* Advantages:
** Plain old Java: no learning curve
** Opportunity to delegate score calculation to an existing code base or legacy system
* Disadvantages:
** Slower
** Does not scale because there is no <<incrementalScoreCalculation,incremental score calculation>>

Implement the one method of the interface ``EasyScoreCalculator``:

[source,java,options=""nowrap""]
----
public interface EasyScoreCalculator<Solution_, Score_ extends Score<Score_>> {

    Score_ calculateScore(Solution_ solution);

}
----

For example in n queens:

[source,java,options=""nowrap""]
----
public class NQueensEasyScoreCalculator
    implements EasyScoreCalculator<NQueens, SimpleScore> {

    @Override
    public SimpleScore calculateScore(NQueens nQueens) {
        int n = nQueens.getN();
        List<Queen> queenList = nQueens.getQueenList();

        int score = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                Queen leftQueen = queenList.get(i);
                Queen rightQueen = queenList.get(j);
                if (leftQueen.getRow() != null && rightQueen.getRow() != null) {
                    if (leftQueen.getRowIndex() == rightQueen.getRowIndex()) {
                        score--;
                    }
                    if (leftQueen.getAscendingDiagonalIndex() == rightQueen.getAscendingDiagonalIndex()) {
                        score--;
                    }
                    if (leftQueen.getDescendingDiagonalIndex() == rightQueen.getDescendingDiagonalIndex()) {
                        score--;
                    }
                }
            }
        }
        return SimpleScore.valueOf(score);
    }

}
----

Configure it in the solver configuration:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <easyScoreCalculatorClass>org.optaplanner.examples.nqueens.optional.score.NQueensEasyScoreCalculator</easyScoreCalculatorClass>
  </scoreDirectorFactory>
----

To configure values of an `EasyScoreCalculator` dynamically in the solver configuration
(so the xref:benchmarking-and-tweaking/benchmarking-and-tweaking.adoc#benchmarker[Benchmarker] can tweak those parameters),
add the `easyScoreCalculatorCustomProperties` element and use xref:planner-configuration/planner-configuration.adoc#customPropertiesConfiguration[custom properties]:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <easyScoreCalculatorClass>...MyEasyScoreCalculator</easyScoreCalculatorClass>
    <easyScoreCalculatorCustomProperties>
      <property name=""myCacheSize"" value=""1000"" />
    </easyScoreCalculatorCustomProperties>
  </scoreDirectorFactory>
----


[[incrementalJavaScoreCalculation]]
=== Incremental Java score calculation

A way to implement your score calculation incrementally in Java.

* Advantages:
** Very fast and scalable
*** Currently the fastest if implemented correctly
* Disadvantages:
** Hard to write
*** A scalable implementation heavily uses maps, indexes, ... (things the Drools rule engine can do for you)
*** You have to learn, design, write and improve all these performance optimizations yourself
** Hard to read
*** Regular score constraint changes can lead to a high maintenance cost

Implement all the methods of the interface `IncrementalScoreCalculator`:

[source,java,options=""nowrap""]
----
public interface IncrementalScoreCalculator<Solution_, Score_ extends Score<Score_>> {

    void resetWorkingSolution(Solution_ workingSolution);

    void beforeEntityAdded(Object entity);

    void afterEntityAdded(Object entity);

    void beforeVariableChanged(Object entity, String variableName);

    void afterVariableChanged(Object entity, String variableName);

    void beforeEntityRemoved(Object entity);

    void afterEntityRemoved(Object entity);

    Score_ calculateScore();

}
----

image::score-calculation/incrementalScoreCalculatorSequenceDiagram.png[align=""center""]

For example in n queens:

[source,java,options=""nowrap""]
----
public class NQueensAdvancedIncrementalScoreCalculator
    implements IncrementalScoreCalculator<NQueens, SimpleScore> {

    private Map<Integer, List<Queen>> rowIndexMap;
    private Map<Integer, List<Queen>> ascendingDiagonalIndexMap;
    private Map<Integer, List<Queen>> descendingDiagonalIndexMap;

    private int score;

    public void resetWorkingSolution(NQueens nQueens) {
        int n = nQueens.getN();
        rowIndexMap = new HashMap<Integer, List<Queen>>(n);
        ascendingDiagonalIndexMap = new HashMap<Integer, List<Queen>>(n * 2);
        descendingDiagonalIndexMap = new HashMap<Integer, List<Queen>>(n * 2);
        for (int i = 0; i < n; i++) {
            rowIndexMap.put(i, new ArrayList<Queen>(n));
            ascendingDiagonalIndexMap.put(i, new ArrayList<Queen>(n));
            descendingDiagonalIndexMap.put(i, new ArrayList<Queen>(n));
            if (i != 0) {
                ascendingDiagonalIndexMap.put(n - 1 + i, new ArrayList<Queen>(n));
                descendingDiagonalIndexMap.put((-i), new ArrayList<Queen>(n));
            }
        }
        score = 0;
        for (Queen queen : nQueens.getQueenList()) {
            insert(queen);
        }
    }

    public void beforeEntityAdded(Object entity) {
        // Do nothing
    }

    public void afterEntityAdded(Object entity) {
        insert((Queen) entity);
    }

    public void beforeVariableChanged(Object entity, String variableName) {
        retract((Queen) entity);
    }

    public void afterVariableChanged(Object entity, String variableName) {
        insert((Queen) entity);
    }

    public void beforeEntityRemoved(Object entity) {
        retract((Queen) entity);
    }

    public void afterEntityRemoved(Object entity) {
        // Do nothing
    }

    private void insert(Queen queen) {
        Row row = queen.getRow();
        if (row != null) {
            int rowIndex = queen.getRowIndex();
            List<Queen> rowIndexList = rowIndexMap.get(rowIndex);
            score -= rowIndexList.size();
            rowIndexList.add(queen);
            List<Queen> ascendingDiagonalIndexList = ascendingDiagonalIndexMap.get(queen.getAscendingDiagonalIndex());
            score -= ascendingDiagonalIndexList.size();
            ascendingDiagonalIndexList.add(queen);
            List<Queen> descendingDiagonalIndexList = descendingDiagonalIndexMap.get(queen.getDescendingDiagonalIndex());
            score -= descendingDiagonalIndexList.size();
            descendingDiagonalIndexList.add(queen);
        }
    }

    private void retract(Queen queen) {
        Row row = queen.getRow();
        if (row != null) {
            List<Queen> rowIndexList = rowIndexMap.get(queen.getRowIndex());
            rowIndexList.remove(queen);
            score += rowIndexList.size();
            List<Queen> ascendingDiagonalIndexList = ascendingDiagonalIndexMap.get(queen.getAscendingDiagonalIndex());
            ascendingDiagonalIndexList.remove(queen);
            score += ascendingDiagonalIndexList.size();
            List<Queen> descendingDiagonalIndexList = descendingDiagonalIndexMap.get(queen.getDescendingDiagonalIndex());
            descendingDiagonalIndexList.remove(queen);
            score += descendingDiagonalIndexList.size();
        }
    }

    public SimpleScore calculateScore() {
        return SimpleScore.valueOf(score);
    }

}
----

Configure it in the solver configuration:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <incrementalScoreCalculatorClass>org.optaplanner.examples.nqueens.optional.score.NQueensAdvancedIncrementalScoreCalculator</incrementalScoreCalculatorClass>
  </scoreDirectorFactory>
----

[IMPORTANT]
====
A piece of incremental score calculator code can be difficult to write and to review.
<<invalidScoreDetection,Assert its correctness>> by using an ``EasyScoreCalculator`` to fulfill
the assertions triggered by the ``environmentMode``.
====

To configure values of an `IncrementalScoreCalculator` dynamically in the solver configuration
(so the xref:benchmarking-and-tweaking/benchmarking-and-tweaking.adoc#benchmarker[Benchmarker] can tweak those parameters),
add the `incrementalScoreCalculatorCustomProperties` element and use xref:planner-configuration/planner-configuration.adoc#customPropertiesConfiguration[custom properties]:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <incrementalScoreCalculatorClass>...MyIncrementalScoreCalculator</incrementalScoreCalculatorClass>
    <incrementalScoreCalculatorCustomProperties>
      <property name=""myCacheSize"" value=""1000""/>
    </incrementalScoreCalculatorCustomProperties>
  </scoreDirectorFactory>
----


[[constraintMatchAwareIncrementalScoreCalculator]]
==== `ConstraintMatchAwareIncrementalScoreCalculator`

Optionally, also implement the `ConstraintMatchAwareIncrementalScoreCalculator` interface to:

* Explain a score by splitting it up per score constraint with `ScoreExplanation.getConstraintMatchTotalMap()`.
* Visualize or sort planning entities by how many constraints each one breaks with `ScoreExplanation.getIndictmentMap()`.
* Receive a detailed analysis if the `IncrementalScoreCalculator` is corrupted in `FAST_ASSERT` or `FULL_ASSERT` `environmentMode`,

[source,java,options=""nowrap""]
----
public interface ConstraintMatchAwareIncrementalScoreCalculator<Solution_, Score_ extends Score<Score_>> {

    void resetWorkingSolution(Solution_ workingSolution, boolean constraintMatchEnabled);

    Collection<ConstraintMatchTotal<Score_>> getConstraintMatchTotals();

    Map<Object, Indictment<Score_>> getIndictmentMap();
}
----

For example in machine reassignment, create one `ConstraintMatchTotal` per constraint type and call `addConstraintMatch()` for each constraint match:

[source,java,options=""nowrap""]
----
public class MachineReassignmentIncrementalScoreCalculator
        implements ConstraintMatchAwareIncrementalScoreCalculator<MachineReassignment, HardSoftLongScore> {
    ...

    @Override
    public void resetWorkingSolution(MachineReassignment workingSolution, boolean constraintMatchEnabled) {
        resetWorkingSolution(workingSolution);
        // ignore constraintMatchEnabled, it is always presumed enabled
    }

    @Override
    public Collection<ConstraintMatchTotal<HardSoftLongScore>> getConstraintMatchTotals() {
        ConstraintMatchTotal<HardSoftLongScore> maximumCapacityMatchTotal = new DefaultConstraintMatchTotal<>(CONSTRAINT_PACKAGE,
            ""maximumCapacity"", HardSoftLongScore.ZERO);
        ...
        for (MrMachineScorePart machineScorePart : machineScorePartMap.values()) {
            for (MrMachineCapacityScorePart machineCapacityScorePart : machineScorePart.machineCapacityScorePartList) {
                if (machineCapacityScorePart.maximumAvailable < 0L) {
                    maximumCapacityMatchTotal.addConstraintMatch(
                            Arrays.asList(machineCapacityScorePart.machineCapacity),
                            HardSoftLongScore.valueOf(machineCapacityScorePart.maximumAvailable, 0));
                }
            }
        }
        ...
        List<ConstraintMatchTotal<HardSoftLongScore>> constraintMatchTotalList = new ArrayList<>(4);
        constraintMatchTotalList.add(maximumCapacityMatchTotal);
        ...
        return constraintMatchTotalList;
    }

    @Override
    public Map<Object, Indictment<HardSoftLongScore>> getIndictmentMap() {
        return null; // Calculate it non-incrementally from getConstraintMatchTotals()
    }
}
----

That `getConstraintMatchTotals()` code often duplicates some of the logic of the normal `IncrementalScoreCalculator` methods.
Constraint Streams and Drools Score Calculation don't have this disadvantage, because they are constraint match aware automatically when needed,
without any extra domain-specific code.


[[initializingScoreTrend]]
=== `InitializingScoreTrend`

The `InitializingScoreTrend` specifies how the Score will change as more and more variables are initialized (while the already initialized variables do not change). Some optimization algorithms (such Construction Heuristics and Exhaustive Search) run faster if they have such information.

For the Score (or each <<scoreLevel,score level>> separately), specify a trend:

* `ANY` (default): Initializing an extra variable can change the score positively or negatively. Gives no performance gain.
* `ONLY_UP` (rare): Initializing an extra variable can only change the score positively. Implies that:
** There are only positive constraints
** And initializing the next variable cannot unmatch a positive constraint that was matched by a previous initialized variable.
* ``ONLY_DOWN``: Initializing an extra variable can only change the score negatively. Implies that:
** There are only negative constraints
** And initializing the next variable cannot unmatch a negative constraint that was matched by a previous initialized variable.

Most use cases only have negative constraints.
Many of those have an `InitializingScoreTrend` that only goes down:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <constraintProviderClass>org.optaplanner.examples.cloudbalancing.score.CloudBalancingConstraintProvider</constraintProviderClass>
    <initializingScoreTrend>ONLY_DOWN</initializingScoreTrend>
  </scoreDirectorFactory>
----

Alternatively, you can also specify the trend for each score level separately:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <constraintProviderClass>org.optaplanner.examples.cloudbalancing.score.CloudBalancingConstraintProvider</constraintProviderClass>
    <initializingScoreTrend>ONLY_DOWN/ONLY_DOWN</initializingScoreTrend>
  </scoreDirectorFactory>
----


[[invalidScoreDetection]]
=== Invalid score detection

When you put the xref:planner-configuration/planner-configuration.adoc#environmentMode[`environmentMode`] in `FULL_ASSERT` (or ``FAST_ASSERT``),
it will detect score corruption in the <<incrementalScoreCalculation,incremental score calculation>>.
However, that will not verify that your score calculator actually implements your score constraints as your business desires.
For example, one constraint might consistently match the wrong pattern.
To verify the constraints against an independent implementation, configure a ``assertionScoreDirectorFactory``:

[source,xml,options=""nowrap""]
----
  <environmentMode>FAST_ASSERT</environmentMode>
  ...
  <scoreDirectorFactory>
    <constraintProviderClass>org.optaplanner.examples.nqueens.optional.score.NQueensConstraintProviderorg.optaplanner.examples.nqueens.optional.score.NQueensConstraintProvider</constraintProviderClass>
    <assertionScoreDirectorFactory>
      <easyScoreCalculatorClass>org.optaplanner.examples.nqueens.optional.score.NQueensEasyScoreCalculator</easyScoreCalculatorClass>
    </assertionScoreDirectorFactory>
  </scoreDirectorFactory>
----

This way, the `NQueensConstraintProvider` implementation is validated by the ``EasyScoreCalculator``.

[NOTE]
====
This works well to isolate score corruption,
but to verify that the constraint implement the real business needs,
xref:constraint-streams/constraint-streams.adoc#constraintStreamsTesting[a unit test with a ConstraintVerifier] is usually better.
====


[[scoreCalculationPerformanceTricks]]
== Score calculation performance tricks


[[scoreCalculationPerformanceTricksOverview]]
=== Overview

The `Solver` will normally spend most of its execution time running the score calculation
(which is called in its deepest loops).
Faster score calculation will return the same solution in less time with the same algorithm,
which normally means a better solution in equal time.


[[scoreCalculationSpeed]]
=== Score calculation speed

After solving a problem, the `Solver` will log the __score calculation speed per second__.
This is a good measurement of Score calculation performance,
despite that it is affected by non score calculation execution time.
It depends on the problem scale of the problem dataset.
Normally, even for high scale problems, it is higher than ``1000``, except if you are using an ``EasyScoreCalculator``.

[IMPORTANT]
====
When improving your score calculation, focus on maximizing the score calculation speed, instead of maximizing the best score.
A big improvement in score calculation can sometimes yield little or no best score improvement, for example when the algorithm is stuck in a local or global optima.
If you are watching the calculation speed instead, score calculation improvements are far more visible.

Furthermore, watching the calculation speed allows you to remove or add score constraints,
and still compare it with the original's calculation speed.
Comparing the best score with the original's best score is pointless: it's comparing apples and oranges.
====


[[incrementalScoreCalculation]]
=== Incremental score calculation (with deltas)

When a solution changes, incremental score calculation (AKA delta based score calculation)
calculates the delta with the previous state to find the new ``Score``,
instead of recalculating the entire score on every solution evaluation.

For example, when a single queen A moves from row `1` to ``2``,
it will not bother to check if queen B and C can attack each other, since neither of them changed:

image::score-calculation/incrementalScoreCalculationNQueens04.png[align=""center""]

Similarly in employee rostering:

image::score-calculation/incrementalScoreCalculationEmployeeRostering.png[align=""center""]

This is a huge performance and scalability gain.
*xref:constraint-streams/constraint-streams.adoc#constraintStreams[Constraint Streams] or xref:drools-score-calculation/drools-score-calculation.adoc#droolsScoreCalculation[Drools score calculation] give you this huge scalability gain without forcing you to write a complicated incremental score calculation algorithm.*
Just let the rule engine do the hard work.

Notice that the speedup is relative to the size of your planning problem (your __n__), making incremental score calculation far more scalable.


[[avoidCallingRemoteServicesDuringScoreCalculation]]
=== Avoid calling remote services during score calculation

Do not call remote services in your score calculation (except if you are bridging `EasyScoreCalculator` to a legacy system). The network latency will kill your score calculation performance.
Cache the results of those remote services if possible.

If some parts of a constraint can be calculated once, when the `Solver` starts, and never change during solving,
then turn them into xref:planner-configuration/planner-configuration.adoc#cachedProblemFact[cached problem facts].


[[pointlessConstraints]]
=== Pointless constraints

If you know a certain constraint can never be broken (or it is always broken), do not write a score constraint for it.
For example in n queens, the score calculation does not check if multiple queens occupy the same column,
because a ``Queen``'s `column` never changes and every solution starts with each `Queen` on a different ``column``.

[NOTE]
====
Do not go overboard with this.
If some datasets do not use a specific constraint but others do, just return out of the constraint as soon as you can.
There is no need to dynamically change your score calculation based on the dataset.
====


[[buildInHardConstraint]]
=== Built-in hard constraint

Instead of implementing a hard constraint, it can sometimes be built in.
For example, if `Lecture` A should never be assigned to `Room` X, but it uses `ValueRangeProvider` on Solution,
so the `Solver` will often try to assign it to `Room` X too (only to find out that it breaks a hard constraint).
Use xref:planner-configuration/planner-configuration.adoc#valueRangeProviderOnPlanningEntity[a ValueRangeProvider on the planning entity] or xref:move-and-neighborhood-selection/move-and-neighborhood-selection.adoc#filteredSelection[filtered selection] to define that Course A should only be assigned a `Room` different than X.

This can give a good performance gain in some use cases, not just because the score calculation is faster,
but mainly because most optimization algorithms will spend less time evaluating infeasible solutions.
However, usually this is not a good idea because there is a real risk of trading short term benefits for long term harm:

* Many optimization algorithms rely on the freedom to break hard constraints when changing planning entities,
to get out of local optima.
* Both implementation approaches have limitations (feature compatibility, disabling automatic performance optimizations),
as explained in their documentation.


[[otherScoreCalculationPerformanceTricks]]
=== Other score calculation performance tricks

* Verify that your score calculation happens in the correct `Number` type.
If you are making the sum of `int` values, do not sum it in a `double` which takes longer.
* For optimal performance, always use server mode (``java -server``).
We have seen performance increases of 50% by turning on server mode.
* For optimal performance, use the latest Java version.
For example, in the past we have seen performance increases of 30% by switching from java 1.5 to 1.6.
* Always remember that premature optimization is the root of all evil.
Make sure your design is flexible enough to allow configuration based tweaking.


[[scoreTrap]]
=== Score trap

Make sure that none of your score constraints cause a score trap.
A trapped score constraint uses the same weight for different constraint matches, when it could just as easily use a different weight.
It effectively lumps its constraint matches together, which creates a flatlined score function for that constraint.
This can cause a solution state in which several moves need to be done to resolve or lower the weight of that single constraint.
Some examples of score traps:

* You need two doctors at each table, but you are only moving one doctor at a time. So the solver has no incentive to move a doctor to a table with no doctors. Punish a table with no doctors more than a table with only one doctor in that score constraint in the score function.
* Two exams need to be conducted at the same time, but you are only moving one exam at a time. So the solver has to move one of those exams to another timeslot without moving the other in the same move. Add a coarse-grained move that moves both exams at the same time.

For example, consider this score trap.
If the blue item moves from an overloaded computer to an empty computer, the hard score should improve.
The trapped score implementation fails to do that:

image::score-calculation/scoreTrap.png[align=""center""]

The Solver should eventually get out of this trap, but it will take a lot of effort (especially if there are even more processes on the overloaded computer). Before they do that, they might actually start moving more processes into that overloaded computer, as there is no penalty for doing so.

[NOTE]
====
Avoiding score traps does not mean that your score function should be smart enough to avoid local optima.
Leave it to the optimization algorithms to deal with the local optima.

Avoiding score traps means to avoid, for each score constraint individually, a flatlined score function.
====

[IMPORTANT]
====
Always specify the degree of infeasibility.
The business will often say ""if the solution is infeasible, it does not matter how infeasible it is."" While that is true for the business, it is not true for score calculation as it benefits from knowing how infeasible it is.
In practice, soft constraints usually do this naturally and it is just a matter of doing it for the hard constraints too.
====

There are several ways to deal with a score trap:

* Improve the score constraint to make a distinction in the score weight. For example, penalize `-1hard` for every missing CPU, instead of just `-1hard` if any CPU is missing.
* If changing the score constraint is not allowed from the business perspective, add a lower score level with a score constraint that makes such a distinction. For example, penalize `-1subsoft` for every missing CPU, on top of `-1hard` if any CPU is missing. The business ignores the subsoft score level.
* Add coarse-grained moves and union select them with the existing fine-grained moves. A coarse-grained move effectively does multiple moves to directly get out of a score trap with a single move. For example, move multiple items from the same container to another container.


[[stepLimitBenchmark]]
=== `stepLimit` benchmark

Not all score constraints have the same performance cost.
Sometimes one score constraint can kill the score calculation performance outright.
Use the xref:benchmarking-and-tweaking/benchmarking-and-tweaking.adoc#benchmarker[Benchmarker] to do a one minute run and check what happens to the score calculation speed if you comment out all but one of the score constraints.


[[fairnessScoreConstraints]]
=== Fairness score constraints

Some use cases have a business requirement to provide a fair schedule (usually as a soft score constraint), for example:

* Fairly distribute the workload amongst the employees, to avoid envy.
* Evenly distribute the workload amongst assets, to improve reliability.

Implementing such a constraint can seem difficult (especially because there are different ways to formalize fairness), but usually the _squared workload_ implementation behaves most desirable.
For each employee/asset, count the workload `w` and subtract `w²` from the score.

image::score-calculation/fairnessScoreConstraint.png[align=""center""]

As shown above, the _squared workload_ implementation guarantees that if you select two employees from a given solution and make their distribution between those two employees fairer, then the resulting new solution will have a better overall score.
Do not just use the difference from the average workload, as that can lead to unfairness, as demonstrated below.

image::score-calculation/fairnessScoreConstraintPitfall.png[align=""center""]


[NOTE]
====
Instead of the _squared workload_, it is also possible to use the https://en.wikipedia.org/wiki/Variance[variance]
(squared difference to the average) or the http://en.wikipedia.org/wiki/Standard_deviation[standard deviation]
(square root of the variance).
This has no effect on the score comparison, because the average will not change during planning.
It is just more work to implement (because the average needs to be known) and trivially slower (because the calculation is a bit longer).
====

When the workload is perfectly balanced, the user often likes to see a `0` score, instead of the distracting `-34soft` in the image above (for the last solution which is almost perfectly balanced).
To nullify this, either add the average multiplied by the number of entities to the score or instead show the variance or standard deviation in the UI.

[[constraintConfiguration]]
== Constraint configuration: adjust constraint weights dynamically

Deciding the correct <<scoreConstraintWeight,weight>> and <<scoreLevel,level>> for each constraint is not easy.
It often involves negotiating with different stakeholders and their priorities.
Furthermore, quantifying the impact of soft constraints is often a new experience for business managers, so they'll need a number of iterations to get it right.

Don't get stuck between a rock and a hard place.
Provide a UI to adjust the constraint weights and visualize the resulting solution, so the business managers can tweak the constraint weights themselves:

image::score-calculation/parameterizeTheScoreWeights.png[align=""center""]

[[createAConstraintConfiguration]]
=== Create a constraint configuration

First, create a new class to hold the constraint weights and other constraint parameters.
Annotate it with `@ConstraintConfiguration`:

[source,java,options=""nowrap""]
----
@ConstraintConfiguration
public class ConferenceConstraintConfiguration {
    ...
}
----

There will be exactly one instance of this class per planning solution.
The planning solution and the constraint configuration have a one-to-one relationship,
but they serve a different purpose, so they aren't merged into a single class.
A `@ConstraintConfiguration` class can extend a parent `@ConstraintConfiguration` class,
which can be useful in international use cases with many regional constraints.

Add the constraint configuration on the planning solution
and annotate that field or property with `@ConstraintConfigurationProvider`:

[source,java,options=""nowrap""]
----
@PlanningSolution
public class ConferenceSolution {

    @ConstraintConfigurationProvider
    private ConferenceConstraintConfiguration constraintConfiguration;

    ...
}
----

The `@ConstraintConfigurationProvider` annotation automatically exposes the constraint configuration
as a xref:planner-configuration/planner-configuration.adoc#problemFacts[problem fact], there is no need to add a `@ProblemFactProperty` annotation.

The constraint configuration class holds the <<constraintWeight, constraint weights>>,
but it can also hold constraint parameters.
For example in conference scheduling, the minimum pause constraint has a constraint weight (like any other constraint),
but it also has a constraint parameter that defines the length of the minimum pause between two talks of the same speaker.
That pause length depends on the conference (= the planning problem):
in some big conferences 20 minutes isn't enough to go from one room to the other.
That pause length is a field in the constraint configuration without a `@ConstraintWeight` annotation.


[[constraintWeight]]
=== Add a constraint weight for each constraint

In the constraint configuration class, add a `@ConstraintWeight` field or property for each constraint:

[source,java,options=""nowrap""]
----
@ConstraintConfiguration(constraintPackage = ""...conferencescheduling.score"")
public class ConferenceConstraintConfiguration {

    @ConstraintWeight(""Speaker conflict"")
    private HardMediumSoftScore speakerConflict = HardMediumSoftScore.ofHard(10);

    @ConstraintWeight(""Theme track conflict"")
    private HardMediumSoftScore themeTrackConflict = HardMediumSoftScore.ofSoft(10);
    @ConstraintWeight(""Content conflict"")
    private HardMediumSoftScore contentConflict = HardMediumSoftScore.ofSoft(100);

    ...
}
----

The type of the constraint weights must be the same score class as xref:planner-configuration/planner-configuration.adoc#scoreOfASolution[the planning solution's score member].
For example in conference scheduling, `ConferenceSolution.getScore()` and `ConferenceConstraintConfiguration.getSpeakerConflict()`
both return a `HardMediumSoftScore`.

A constraint weight cannot be null.
Give each constraint weight a default value, but expose them in a UI so the business users can tweak them.
The example above uses the `ofHard()`, `ofMedium()` and `ofSoft()` methods to do that.
Notice how it defaults the _content conflict_ constraint as ten times more important than the _theme track conflict_ constraint.
Normally, a constraint weight only uses one score level,
but it's possible to use multiple score levels (at a small performance cost).

Each constraint has a constraint package and a constraint name, together they form the constraint id.
These connect the constraint weight with the constraint implementation.
*For each constraint weight, there must be a constraint implementation with the same package and the same name.*

* The `@ConstraintConfiguration` annotation has a `constraintPackage` property that defaults to the package of the constraint configuration class.
Most cases with xref:drools-score-calculation/drools-score-calculation.adoc#droolsScoreCalculation[Drools score calculation], need to override that because the DRLs use another package.
For example, the DRL below uses the package `...conferencescheduling.score`,
so the constraint configuration above specifies a `constraintPackage`.
Cases with xref:constraint-streams/constraint-streams.adoc#constraintStreams[Constraint streams], normally don't need to specify it.

* The `@ConstraintWeight` annotation has a `value` which is the constraint name (for example ""Speaker conflict"").
It inherits the constraint package from the `@ConstraintConfiguration`,
but it can override that, for example `@ConstraintWeight(constraintPackage = ""...region.france"", ...)`
to use a different constraint package than some of the other weights.

So every constraint weight ends up with a constraint package and a constraint name.
Each constraint weight links with a constraint implementation,
for example in xref:drools-score-calculation/drools-score-calculation.adoc#droolsScoreCalculation[Drools score calculation]:

[source,options=""nowrap""]
----
package ...conferencescheduling.solver;

rule ""Speaker conflict""
    when
        ...
    then
        scoreHolder.penalize(kcontext);
end

rule ""Theme track conflict""
    when
        ...
    then
        scoreHolder.penalize(kcontext, ...);
end

rule ""Content conflict""
    when
        ...
    then
        scoreHolder.penalize(kcontext, ...);
end
----

Each of the constraint weights defines the score level and score weight of their constraint.
The constraint implementation calls `reward()` or `penalize()` and the constraint weight is automatically applied.

If the constraint implementation provides a match weight, that *match weight is multiplied with the constraint weight*.
For example, the _content conflict_ constraint weight defaults to `100soft`
and the constraint implementation penalizes each match based on the number of shared content tags:

[source,java,options=""nowrap""]
----
    @ConstraintWeight(""Content conflict"")
    private HardMediumSoftScore contentConflict = HardMediumSoftScore.ofSoft(100);
----

[source,options=""nowrap""]
----
rule ""Content conflict""
    when
        $talk1 : Talk(...)
        $talk2 : Talk(...)
    then
        scoreHolder.penalize(kcontext,
                $talk2.overlappingContentCount($talk1));
end
----

So when 2 overlapping talks share only 1 content tag, the score is impacted by `-100soft`.
But when 2 overlapping talks share 3 content tags, the match weight is `3`, so the score is impacted by `-300soft`.

[[explainingTheScore]]
== Explaining the score: which constraints are broken?

The easiest way to explain the score during development is to print the return value of `explainScore()`, but only use that method for diagnostic purposes:

[source,java,options=""nowrap""]
----
System.out.println(scoreManager.explainScore(solution));
----

For example in conference scheduling, this prints that talk `S51` is responsible for breaking the hard constraint `Speaker required room tag`:

----
Explanation of score (-1hard/-806soft):
    Constraint match totals:
        -1hard: constraint (Speaker required room tag) has 1 matches:
            -1hard: justifications ([S51])
        -340soft: constraint (Theme track conflict) has 32 matches:
            -20soft: justifications ([S68, S66])
            -20soft: justifications ([S61, S44])
            ...
        ...
    Indictments (top 5 of 72):
        -1hard/-22soft: justification (S51) has 12 matches:
            -1hard: constraint (Speaker required room tag)
            -10soft: constraint (Theme track conflict)
            ...
        ...
----

[IMPORTANT]
====
Do not attempt to parse this string or use it in your UI or exposed services.
Instead use the ConstraintMatch API below and do it properly.
====

[[usingScoreCalculationOutsideTheSolver]]
=== Using score calculation outside the `Solver`

If other parts of your application, for example your webUI, need to calculate the score of a solution, use the `ScoreManager` API:

[source,java,options=""nowrap""]
----
ScoreManager<CloudBalance, HardSoftScore> scoreManager = ScoreManager.create(solverFactory);
ScoreExplanation<CloudBalance, HardSoftScore> scoreExplanation = scoreManager.explain(cloudBalance);
----

Then use it when you need to calculate the `Score` of a solution:

[source,java,options=""nowrap""]
----
HardSoftScore score = scoreExplanation.getScore();
----

Furthermore, the `ScoreExplanation` can help explain the score through constraint match totals and/or indictments:

image::score-calculation/scoreVisualization.png[align=""center""]

[[constraintMatchTotal]]
=== Constraint match total: break down the score by constraint

To break down the score per constraint, get the ``ConstraintMatchTotal``s from the ``ScoreExplanation``:

[source,java,options=""nowrap""]
----
Collection<ConstraintMatchTotal<HardSoftScore>> constraintMatchTotals = scoreExplanation.getConstraintMatchTotalMap().values();
for (ConstraintMatchTotal<HardSoftScore> constraintMatchTotal : constraintMatchTotals) {
    String constraintName = constraintMatchTotal.getConstraintName();
    // The score impact of that constraint
    HardSoftScore totalScore = constraintMatchTotal.getScore();

    for (ConstraintMatch<HardSoftScore> constraintMatch : constraintMatchTotal.getConstraintMatchSet()) {
        List<Object> justificationList = constraintMatch.getJustificationList();
        HardSoftScore score = constraintMatch.getScore();
        ...
    }
}
----

Each `ConstraintMatchTotal` represents one constraint and has a part of the overall score.
The sum of all the `ConstraintMatchTotal.getScore()` equals the overall score.

[NOTE]
====
xref:constraint-streams/constraint-streams.adoc#constraintStreams[Constraint streams] and xref:drools-score-calculation/drools-score-calculation.adoc#droolsScoreCalculation[Drools score calculation] supports constraint matches automatically, but <<incrementalJavaScoreCalculation,incremental Java score calculation>> requires
<<constraintMatchAwareIncrementalScoreCalculator,implementing an extra interface>>.
====

[[indictmentHeatMap]]
=== Indictment heat map: visualize the hot planning entities

To show a heat map in the UI that highlights the planning entities and problem facts have an impact on the ``Score``, get the `Indictment` map from the ``ScoreExplanation``:

[source,java,options=""nowrap""]
----
Map<Object, Indictment<HardSoftScore>> indictmentMap = scoreExplanation.getIndictmentMap();
for (CloudProcess process : cloudBalance.getProcessList()) {
    Indictment<HardSoftScore> indictment = indictmentMap.get(process);
    if (indictment == null) {
        continue;
    }
    // The score impact of that planning entity
    HardSoftScore totalScore = indictment.getScore();

    for (ConstraintMatch<HardSoftScore> constraintMatch : indictment.getConstraintMatchSet()) {
        String constraintName = constraintMatch.getConstraintName();
        HardSoftScore score = constraintMatch.getScore();
        ...
    }
}
----

Each `Indictment` is the sum of all constraints where that justification object is involved with.
The sum of all the `Indictment.getScoreTotal()` differs from the overall score, because multiple ``Indictment``s can share the same `ConstraintMatch`.

[NOTE]
====
xref:constraint-streams/constraint-streams.adoc#constraintStreams[Constraint streams] and xref:drools-score-calculation/drools-score-calculation.adoc#droolsScoreCalculation[Drools score calculation] supports constraint matches automatically, but <<incrementalJavaScoreCalculation,incremental Java score calculation>> requires
<<constraintMatchAwareIncrementalScoreCalculator,implementing an extra interface>>.
====


[[testingScoreConstraints]]
== Testing score constraints

It's recommended to write a unit test for each score constraint individually to check that it behaves correctly.
Different score calculation types come with different tools for testing.
For more, see xref:constraint-streams/constraint-streams.adoc#constraintStreamsTesting[testing Constraint Streams] or
xref:drools-score-calculation/drools-score-calculation.adoc#testingDroolsConstraints[testing Drools constraints].
",12285,False,2174.9979158824112,median
"/******************************************************************************
 * $Id: ogr_gensql.cpp 27044 2014-03-16 23:41:27Z rouault $
 *
 * Project:  OpenGIS Simple Features Reference Implementation
 * Purpose:  Implements OGRGenSQLResultsLayer.
 * Author:   Frank Warmerdam, warmerdam@pobox.com
 *
 ******************************************************************************
 * Copyright (c) 2002, Frank Warmerdam
 * Copyright (c) 2008-2014, Even Rouault <even dot rouault at mines-paris dot org>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the ""Software""),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 ****************************************************************************/

#include ""swq.h""
#include ""ogr_p.h""
#include ""ogr_gensql.h""
#include ""cpl_string.h""
#include ""ogr_api.h""
#include ""cpl_time.h""
#include <vector>

CPL_CVSID(""$Id: ogr_gensql.cpp 27044 2014-03-16 23:41:27Z rouault $"");


class OGRGenSQLGeomFieldDefn: public OGRGeomFieldDefn
{
    public:
        OGRGenSQLGeomFieldDefn(OGRGeomFieldDefn* poGeomFieldDefn) :
            OGRGeomFieldDefn(poGeomFieldDefn->GetNameRef(),
                             poGeomFieldDefn->GetType()), bForceGeomType(FALSE)
        {
            SetSpatialRef(poGeomFieldDefn->GetSpatialRef());
        }

        int bForceGeomType;
};

/************************************************************************/
/*               OGRGenSQLResultsLayerHasSpecialField()                 */
/************************************************************************/

static
int OGRGenSQLResultsLayerHasSpecialField(swq_expr_node* expr,
                                         int nMinIndexForSpecialField)
{
    if (expr->eNodeType == SNT_COLUMN)
    {
        if (expr->table_index == 0)
        {
            return expr->field_index >= nMinIndexForSpecialField &&
                   expr->field_index < nMinIndexForSpecialField + SPECIAL_FIELD_COUNT;
        }
    }
    else if (expr->eNodeType == SNT_OPERATION)
    {
        for( int i = 0; i < expr->nSubExprCount; i++ )
        {
            if (OGRGenSQLResultsLayerHasSpecialField(expr->papoSubExpr[i],
                                                     nMinIndexForSpecialField))
                return TRUE;
        }
    }
    return FALSE;
}

/************************************************************************/
/*                       OGRGenSQLResultsLayer()                        */
/************************************************************************/

OGRGenSQLResultsLayer::OGRGenSQLResultsLayer( OGRDataSource *poSrcDS,
                                              void *pSelectInfo, 
                                              OGRGeometry *poSpatFilter,
                                              const char *pszWHERE,
                                              const char *pszDialect )

{
    swq_select *psSelectInfo = (swq_select *) pSelectInfo;

    this->poSrcDS = poSrcDS;
    this->pSelectInfo = pSelectInfo;
    poDefn = NULL;
    poSummaryFeature = NULL;
    panFIDIndex = NULL;
    bOrderByValid = FALSE;
    nIndexSize = 0;
    nNextIndexFID = 0;
    nExtraDSCount = 0;
    papoExtraDS = NULL;
    panGeomFieldToSrcGeomField = NULL;

/* -------------------------------------------------------------------- */
/*      Identify all the layers involved in the SELECT.                 */
/* -------------------------------------------------------------------- */
    int iTable;

    papoTableLayers = (OGRLayer **) 
        CPLCalloc( sizeof(OGRLayer *), psSelectInfo->table_count );

    for( iTable = 0; iTable < psSelectInfo->table_count; iTable++ )
    {
        swq_table_def *psTableDef = psSelectInfo->table_defs + iTable;
        OGRDataSource *poTableDS = poSrcDS;

        if( psTableDef->data_source != NULL )
        {
            OGRSFDriverRegistrar *poReg=OGRSFDriverRegistrar::GetRegistrar();

            poTableDS = 
                poReg->OpenShared( psTableDef->data_source, FALSE, NULL );
            if( poTableDS == NULL )
            {
                if( strlen(CPLGetLastErrorMsg()) == 0 )
                    CPLError( CE_Failure, CPLE_AppDefined, 
                              ""Unable to open secondary datasource\\n""
                              ""`%s' required by JOIN."",
                              psTableDef->data_source );
                return;
            }

            papoExtraDS = (OGRDataSource **)
                CPLRealloc( papoExtraDS, sizeof(void*) * ++nExtraDSCount );

            papoExtraDS[nExtraDSCount-1] = poTableDS;
        }

        papoTableLayers[iTable] = 
            poTableDS->GetLayerByName( psTableDef->table_name );
        
        CPLAssert( papoTableLayers[iTable] != NULL );

        if( papoTableLayers[iTable] == NULL )
            return;
    }
    
    poSrcLayer = papoTableLayers[0];

/* -------------------------------------------------------------------- */
/*      If the user has explicitely requested a OGRSQL dialect, then    */
/*      we should avoid to forward the where clause to the source layer */
/*      when there is a risk it cannot understand it (#4022)            */
/* -------------------------------------------------------------------- */
    int bForwardWhereToSourceLayer = TRUE;
    if( pszWHERE )
    {
        if( psSelectInfo->where_expr && pszDialect != NULL &&
            EQUAL(pszDialect, ""OGRSQL"") )
        {
            int nMinIndexForSpecialField = poSrcLayer->GetLayerDefn()->GetFieldCount();
            bForwardWhereToSourceLayer = !OGRGenSQLResultsLayerHasSpecialField
                            (psSelectInfo->where_expr, nMinIndexForSpecialField);
        }
        if (bForwardWhereToSourceLayer)
            this->pszWHERE = CPLStrdup(pszWHERE);
        else
            this->pszWHERE = NULL;
    }
    else
        this->pszWHERE = NULL;

/* -------------------------------------------------------------------- */
/*      Prepare a feature definition based on the query.                */
/* -------------------------------------------------------------------- */
    OGRFeatureDefn *poSrcDefn = poSrcLayer->GetLayerDefn();

    poDefn = new OGRFeatureDefn( psSelectInfo->table_defs[0].table_alias );
    poDefn->SetGeomType(wkbNone);
    poDefn->Reference();

    iFIDFieldIndex = poSrcDefn->GetFieldCount();

    /* + 1 since we can add an implicit geometry field */
    panGeomFieldToSrcGeomField = (int*) CPLMalloc(sizeof(int) * (1 + psSelectInfo->result_columns));

    for( int iField = 0; iField < psSelectInfo->result_columns; iField++ )
    {
        swq_col_def *psColDef = psSelectInfo->column_defs + iField;
        OGRFieldDefn oFDefn( """", OFTInteger );
        OGRGeomFieldDefn oGFDefn( """", wkbUnknown );
        OGRFieldDefn *poSrcFDefn = NULL;
        OGRGeomFieldDefn *poSrcGFDefn = NULL;
        int bIsGeometry = FALSE;
        OGRFeatureDefn *poLayerDefn = NULL;
        int iSrcGeomField = -1;

        if( psColDef->table_index != -1 )
            poLayerDefn = 
                papoTableLayers[psColDef->table_index]->GetLayerDefn();

        if( psColDef->field_index > -1 
            && poLayerDefn != NULL
            && psColDef->field_index < poLayerDefn->GetFieldCount() )
        {
            poSrcFDefn = poLayerDefn->GetFieldDefn(psColDef->field_index);
        }

        if( poLayerDefn != NULL &&
            IS_GEOM_FIELD_INDEX(poLayerDefn, psColDef->field_index) )
        {
            bIsGeometry = TRUE;
            iSrcGeomField =
                ALL_FIELD_INDEX_TO_GEOM_FIELD_INDEX(poLayerDefn, psColDef->field_index);
            poSrcGFDefn = poLayerDefn->GetGeomFieldDefn(iSrcGeomField);
        }

        if( psColDef->target_type == SWQ_GEOMETRY )
            bIsGeometry = TRUE;

        if( psColDef->col_func == SWQCF_COUNT )
            bIsGeometry = FALSE;

        if( strlen(psColDef->field_name) == 0 && !bIsGeometry )
        {
            CPLFree( psColDef->field_name );
            psColDef->field_name = (char *) CPLMalloc(40);
            sprintf( psColDef->field_name, ""FIELD_%d"", poDefn->GetFieldCount()+1 );
        }

        if( psColDef->field_alias != NULL )
        {
            if( bIsGeometry )
                oGFDefn.SetName(psColDef->field_alias);
            else
                oFDefn.SetName(psColDef->field_alias);
        }
        else if( psColDef->col_func != SWQCF_NONE )
        {
            const swq_operation *op = swq_op_registrar::GetOperator( 
                (swq_op) psColDef->col_func );

            oFDefn.SetName( CPLSPrintf( ""%s_%s"",
                                        op->pszName,
                                        psColDef->field_name ) );
        }
        else
        {
            if( bIsGeometry )
                oGFDefn.SetName(psColDef->field_name);
            else
                oFDefn.SetName( psColDef->field_name );
        }

        if( psColDef->col_func == SWQCF_COUNT )
            oFDefn.SetType( OFTInteger );
        else if( poSrcFDefn != NULL )
        {
            if( psColDef->col_func != SWQCF_AVG ||
                psColDef->field_type == SWQ_DATE ||
                psColDef->field_type == SWQ_TIME ||
                psColDef->field_type == SWQ_TIMESTAMP )
                oFDefn.SetType( poSrcFDefn->GetType() );
            else
                oFDefn.SetType( OFTReal );
            if( psColDef->col_func != SWQCF_AVG &&
                psColDef->col_func != SWQCF_SUM )
            {
                oFDefn.SetWidth( poSrcFDefn->GetWidth() );
                oFDefn.SetPrecision( poSrcFDefn->GetPrecision() );
            }
        }
        else if( poSrcGFDefn != NULL )
        {
            oGFDefn.SetType( poSrcGFDefn->GetType() );
            oGFDefn.SetSpatialRef( poSrcGFDefn->GetSpatialRef() );
        }
        else if ( psColDef->field_index >= iFIDFieldIndex )
        {
            switch ( SpecialFieldTypes[psColDef->field_index-iFIDFieldIndex] )
            {
              case SWQ_INTEGER:
                oFDefn.SetType( OFTInteger );
                break;
              case SWQ_FLOAT:
                oFDefn.SetType( OFTReal );
                break;
              default:
                oFDefn.SetType( OFTString );
                break;
            }
        }
        else
        {
            switch( psColDef->field_type )
            {
              case SWQ_INTEGER:
              case SWQ_BOOLEAN:
                oFDefn.SetType( OFTInteger );
                break;
                
              case SWQ_FLOAT:
                oFDefn.SetType( OFTReal );
                break;

              default:
                oFDefn.SetType( OFTString );
                break;
            }
        }

        /* setting up the target_type */
        switch (psColDef->target_type)
        {
          case SWQ_OTHER:
            break;
          case SWQ_INTEGER:
          case SWQ_BOOLEAN:
            oFDefn.SetType( OFTInteger );
            break;
          case SWQ_FLOAT:
            oFDefn.SetType( OFTReal );
            break;
          case SWQ_STRING:
            oFDefn.SetType( OFTString );
            break;
          case SWQ_TIMESTAMP:
            oFDefn.SetType( OFTDateTime );
            break;
          case SWQ_DATE:
            oFDefn.SetType( OFTDate );
            break;
          case SWQ_TIME:
            oFDefn.SetType( OFTTime );
            break;
          case SWQ_GEOMETRY:
            break;

          default:
            CPLAssert( FALSE );
            oFDefn.SetType( OFTString );
            break;
        }

        if (psColDef->field_length > 0)
        {
            oFDefn.SetWidth( psColDef->field_length );
        }

        if (psColDef->field_precision >= 0)
        {
            oFDefn.SetPrecision( psColDef->field_precision );
        }

        if( bIsGeometry )
        {
            panGeomFieldToSrcGeomField[poDefn->GetGeomFieldCount()] = iSrcGeomField;
            /* Hack while drivers haven't been updated so that */
            /* poSrcDefn->GetGeomFieldDefn(0)->GetSpatialRef() == poSrcLayer->GetSpatialRef() */
            if( iSrcGeomField == 0 &&
                poSrcDefn->GetGeomFieldCount() == 1 &&
                oGFDefn.GetSpatialRef() == NULL )
            {
                oGFDefn.SetSpatialRef(poSrcLayer->GetSpatialRef());
            }
            int bForceGeomType = FALSE;
            if( psColDef->eGeomType != wkbUnknown )
            {
                oGFDefn.SetType( psColDef->eGeomType );
                bForceGeomType = TRUE;
            }
            if( psColDef->nSRID > 0 )
            {
                OGRSpatialReference* poSRS = new OGRSpatialReference();
                if( poSRS->importFromEPSG( psColDef->nSRID ) == OGRERR_NONE )
                {
                    oGFDefn.SetSpatialRef( poSRS );
                }
                poSRS->Release();
            }

            OGRGenSQLGeomFieldDefn* poMyGeomFieldDefn =
                new OGRGenSQLGeomFieldDefn(&oGFDefn);
            poMyGeomFieldDefn->bForceGeomType = bForceGeomType;
            poDefn->AddGeomFieldDefn( poMyGeomFieldDefn, FALSE );
        }
        else
            poDefn->AddFieldDefn( &oFDefn );
    }

/* -------------------------------------------------------------------- */
/*      Add implicit geometry field.                                    */
/* -------------------------------------------------------------------- */
    if( psSelectInfo->query_mode == SWQM_RECORDSET &&
        poDefn->GetGeomFieldCount() == 0 &&
        poSrcDefn->GetGeomFieldCount() == 1 )
    {
        psSelectInfo->result_columns++;

        psSelectInfo->column_defs = (swq_col_def *) 
            CPLRealloc( psSelectInfo->column_defs, sizeof(swq_col_def) * psSelectInfo->result_columns );

        swq_col_def *col_def = psSelectInfo->column_defs + psSelectInfo->result_columns - 1;

        memset( col_def, 0, sizeof(swq_col_def) );
        const char* pszName = poSrcDefn->GetGeomFieldDefn(0)->GetNameRef();
        if( *pszName != '\\0' )
            col_def->field_name = CPLStrdup( pszName );
        else
            col_def->field_name = CPLStrdup( OGR_GEOMETRY_DEFAULT_NON_EMPTY_NAME );
        col_def->field_alias = NULL;
        col_def->table_index = 0;
        col_def->field_index = GEOM_FIELD_INDEX_TO_ALL_FIELD_INDEX(poSrcDefn, 0);
        col_def->field_type = SWQ_GEOMETRY;
        col_def->target_type = SWQ_GEOMETRY;

        panGeomFieldToSrcGeomField[poDefn->GetGeomFieldCount()] = 0;

        OGRGenSQLGeomFieldDefn* poMyGeomFieldDefn =
            new OGRGenSQLGeomFieldDefn(poSrcDefn->GetGeomFieldDefn(0));
        poDefn->AddGeomFieldDefn( poMyGeomFieldDefn, FALSE );

        /* Hack while drivers haven't been updated so that */
        /* poSrcDefn->GetGeomFieldDefn(0)->GetSpatialRef() == poSrcLayer->GetSpatialRef() */
        if( poSrcDefn->GetGeomFieldDefn(0)->GetSpatialRef() == NULL )
        {
            poDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSrcLayer->GetSpatialRef());
        }
    }

/* -------------------------------------------------------------------- */
/*      Now that we have poSrcLayer, we can install a spatial filter    */
/*      if there is one.                                                */
/* -------------------------------------------------------------------- */
    if( poSpatFilter != NULL )
        SetSpatialFilter( 0, poSpatFilter );

    ResetReading();

    FindAndSetIgnoredFields();

    if( !bForwardWhereToSourceLayer )
        SetAttributeFilter( pszWHERE );
}

/************************************************************************/
/*                       ~OGRGenSQLResultsLayer()                       */
/************************************************************************/

OGRGenSQLResultsLayer::~OGRGenSQLResultsLayer()

{
    if( m_nFeaturesRead > 0 && poDefn != NULL )
    {
        CPLDebug( ""GenSQL"", ""%d features read on layer '%s'."",
                  (int) m_nFeaturesRead, 
                  poDefn->GetName() );
    }

    ClearFilters();

/* -------------------------------------------------------------------- */
/*      Free various datastructures.                                    */
/* -------------------------------------------------------------------- */
    CPLFree( papoTableLayers );
    papoTableLayers = NULL;
             
    CPLFree( panFIDIndex );
    CPLFree( panGeomFieldToSrcGeomField );

    delete poSummaryFeature;
    delete (swq_select *) pSelectInfo;

    if( poDefn != NULL )
    {
        poDefn->Release();
    }

/* -------------------------------------------------------------------- */
/*      Release any additional datasources being used in joins.         */
/* -------------------------------------------------------------------- */
    OGRSFDriverRegistrar *poReg=OGRSFDriverRegistrar::GetRegistrar();

    for( int iEDS = 0; iEDS < nExtraDSCount; iEDS++ )
        poReg->ReleaseDataSource( papoExtraDS[iEDS] );

    CPLFree( papoExtraDS );
    CPLFree( pszWHERE );
}

/************************************************************************/
/*                            ClearFilters()                            */
/*                                                                      */
/*      Clear up all filters currently in place on the target layer,    */
/*      and joined layers.  We try not to leave them installed          */
/*      except when actively fetching features.                         */
/************************************************************************/

void OGRGenSQLResultsLayer::ClearFilters()

{
/* -------------------------------------------------------------------- */
/*      Clear any filters installed on the target layer.                */
/* -------------------------------------------------------------------- */
    if( poSrcLayer != NULL )
    {
        poSrcLayer->SetAttributeFilter( """" );
        poSrcLayer->SetSpatialFilter( NULL );
    }

/* -------------------------------------------------------------------- */
/*      Clear any attribute filter installed on the joined layers.      */
/* -------------------------------------------------------------------- */
    swq_select *psSelectInfo = (swq_select *) pSelectInfo;
    int iJoin;

    if( psSelectInfo != NULL )
    {
        for( iJoin = 0; iJoin < psSelectInfo->join_count; iJoin++ )
        {
            swq_join_def *psJoinInfo = psSelectInfo->join_defs + iJoin;
            OGRLayer *poJoinLayer = 
                papoTableLayers[psJoinInfo->secondary_table];
            
            poJoinLayer->SetAttributeFilter( """" );
        }
    }

/* -------------------------------------------------------------------- */
/*      Clear any ignored field lists installed on source layers        */
/* -------------------------------------------------------------------- */
    if( psSelectInfo != NULL )
    {
        for( int iTable = 0; iTable < psSelectInfo->table_count; iTable++ )
        {
            OGRLayer* poLayer = papoTableLayers[iTable];
            poLayer->SetIgnoredFields(NULL);
        }
    }
}

/************************************************************************/
/*                    MustEvaluateSpatialFilterOnGenSQL()               */
/************************************************************************/

int OGRGenSQLResultsLayer::MustEvaluateSpatialFilterOnGenSQL()
{
    int bEvaluateSpatialFilter = FALSE;
    if( m_poFilterGeom != NULL &&
        m_iGeomFieldFilter >= 0 &&
        m_iGeomFieldFilter < GetLayerDefn()->GetGeomFieldCount() )
    {
        int iSrcGeomField = panGeomFieldToSrcGeomField[m_iGeomFieldFilter];
        if( iSrcGeomField < 0 )
            bEvaluateSpatialFilter = TRUE;
    }
    return bEvaluateSpatialFilter;
}

/************************************************************************/
/*                       ApplyFiltersToSource()                         */
/************************************************************************/

void OGRGenSQLResultsLayer::ApplyFiltersToSource()
{
    poSrcLayer->SetAttributeFilter( pszWHERE );
    if( m_iGeomFieldFilter >= 0 &&
        m_iGeomFieldFilter < GetLayerDefn()->GetGeomFieldCount() )
    {
        int iSrcGeomField = panGeomFieldToSrcGeomField[m_iGeomFieldFilter];
        if( iSrcGeomField >= 0 )
            poSrcLayer->SetSpatialFilter( iSrcGeomField, m_poFilterGeom );
    }

    poSrcLayer->ResetReading();
}

/************************************************************************/
/*                            ResetReading()                            */
/************************************************************************/

void OGRGenSQLResultsLayer::ResetReading() 

{
    swq_select *psSelectInfo = (swq_select *) pSelectInfo;

    if( psSelectInfo->query_mode == SWQM_RECORDSET )
    {
        ApplyFiltersToSource();
    }

    nNextIndexFID = 0;
}

/************************************************************************/
/*                           SetNextByIndex()                           */
/*                                                                      */
/*      If we already have an FID list, we can easily resposition       */
/*      ourselves in it.                                                */
/************************************************************************/

OGRErr OGRGenSQLResultsLayer::SetNextByIndex( long nIndex )

{
    swq_select *psSelectInfo = (swq_select *) pSelectInfo;

    CreateOrderByIndex();

    if( psSelectInfo->query_mode == SWQM_SUMMARY_RECORD 
        || psSelectInfo->query_mode == SWQM_DISTINCT_LIST 
        || panFIDIndex != NULL )
    {
        nNextIndexFID = nIndex;
        return OGRERR_NONE;
    }
    else
    {
        return poSrcLayer->SetNextByIndex( nIndex );
    }
}

/************************************************************************/
/*                             GetExtent()                              */
/************************************************************************/

OGRErr OGRGenSQLResultsLayer::GetExtent( int iGeomField,
                                         OGREnvelope *psExtent, 
                                         int bForce )

{
    swq_select *psSelectInfo = (swq_select *) pSelectInfo;

    if( iGeomField < 0 || iGeomField >= GetLayerDefn()->GetGeomFieldCount() ||
        GetLayerDefn()->GetGeomFieldDefn(iGeomField)->GetType() == wkbNone )
    {
        if( iGeomField != 0 )
        {
            CPLError(CE_Failure, CPLE_AppDefined,
                     ""Invalid geometry field index : %d"", iGeomField);
        }
        return OGRERR_FAILURE;
    }

    if( psSelectInfo->query_mode == SWQM_RECORDSET )
    {
        int iSrcGeomField = panGeomFieldToSrcGeomField[iGeomField];
        if( iSrcGeomField >= 0 )
            return poSrcLayer->GetExtent( iSrcGeomField, psExtent, bForce );
        else if( iGeomField == 0 )
            return OGRLayer::GetExtent( psExtent, bForce );
        else
            return OGRLayer::GetExtent( iGeomField, psExtent, bForce );
    }
    else
        return OGRERR_FAILURE;
}

/************************************************************************/
/*                          GetFeatureCount()                           */
/************************************************************************/

int OGRGenSQLResultsLayer::GetFeatureCount( int bForce )

{
    swq_select *psSelectInfo = (swq_select *) pSelectInfo;

    CreateOrderByIndex();

    if( psSelectInfo->query_mode == SWQM_DISTINCT_LIST )
    {
        if( !PrepareSummary() )
            return 0;

        swq_summary *psSummary = psSelectInfo->column_summary + 0;

        if( psSummary == NULL )
            return 0;

        return psSummary->count;
    }
    else if( psSelectInfo->query_mode != SWQM_RECORDSET )
        return 1;
    else if( m_poAttrQuery == NULL && !MustEvaluateSpatialFilterOnGenSQL() )
        return poSrcLayer->GetFeatureCount( bForce );
    else
        return OGRLayer::GetFeatureCount( bForce );
}

/************************************************************************/
/*                           TestCapability()                           */
/************************************************************************/

int OGRGenSQLResultsLayer::TestCapability( const char *pszCap )

{
    swq_select *psSelectInfo = (swq_select *) pSelectInfo;

    if( EQUAL(pszCap,OLCFastSetNextByIndex) )
    {
        if( psSelectInfo->query_mode == SWQM_SUMMARY_RECORD 
            || psSelectInfo->query_mode == SWQM_DISTINCT_LIST 
            || panFIDIndex != NULL )
            return TRUE;
        else 
            return poSrcLayer->TestCapability( pszCap );
    }

    if( psSelectInfo->query_mode == SWQM_RECORDSET
        && (EQUAL(pszCap,OLCFastFeatureCount) 
            || EQUAL(pszCap,OLCRandomRead) 
            || EQUAL(pszCap,OLCFastGetExtent)) )
        return poSrcLayer->TestCapability( pszCap );

    else if( psSelectInfo->query_mode != SWQM_RECORDSET )
    {
        if( EQUAL(pszCap,OLCFastFeatureCount) )
            return TRUE;
    }
    return FALSE;
}

/************************************************************************/
/*                        ContainGeomSpecialField()                     */
/************************************************************************/

int OGRGenSQLResultsLayer::ContainGeomSpecialField(swq_expr_node* expr)
{
    if (expr->eNodeType == SNT_COLUMN)
    {
        if( expr->table_index == 0 && expr->field_index != -1 )
        {
            OGRLayer* poLayer = papoTableLayers[expr->table_index];
            int nSpecialFieldIdx = expr->field_index -
                            poLayer->GetLayerDefn()->GetFieldCount();
            if( nSpecialFieldIdx == SPF_OGR_GEOMETRY ||
                nSpecialFieldIdx == SPF_OGR_GEOM_WKT ||
                nSpecialFieldIdx == SPF_OGR_GEOM_AREA )
                return TRUE;
            if( expr->field_index ==
                    GEOM_FIELD_INDEX_TO_ALL_FIELD_INDEX(poLayer->GetLayerDefn(), 0) )
                return TRUE;
            return FALSE;
        }
    }
    else if (expr->eNodeType == SNT_OPERATION)
    {
        for( int i = 0; i < expr->nSubExprCount; i++ )
        {
            if (ContainGeomSpecialField(expr->papoSubExpr[i]))
                return TRUE;
        }
    }
    return FALSE;
}

/************************************************************************/
/*                           PrepareSummary()                           */
/************************************************************************/

int OGRGenSQLResultsLayer::PrepareSummary()

{
    swq_select *psSelectInfo = (swq_select *) pSelectInfo;

    if( poSummaryFeature != NULL )
        return TRUE;

    poSummaryFeature = new OGRFeature( poDefn );
    poSummaryFeature->SetFID( 0 );

/* -------------------------------------------------------------------- */
/*      Ensure our query parameters are in place on the source          */
/*      layer.  And initialize reading.                                 */
/* -------------------------------------------------------------------- */
    ApplyFiltersToSource();

/* -------------------------------------------------------------------- */
/*      Ignore geometry reading if no spatial filter in place and that  */
/*      the where clause and no column references OGR_GEOMETRY,         */
/*      OGR_GEOM_WKT or OGR_GEOM_AREA special fields.                   */
/* -------------------------------------------------------------------- */
    int bSaveIsGeomIgnored = poSrcLayer->GetLayerDefn()->IsGeometryIgnored();
    if ( m_poFilterGeom == NULL && ( psSelectInfo->where_expr == NULL ||
                !ContainGeomSpecialField(psSelectInfo->where_expr) ) )
    {
        int bFoundGeomExpr = FALSE;
        for( int iField = 0; iField < psSelectInfo->result_columns; iField++ )
        {
            swq_col_def *psColDef = psSelectInfo->column_defs + iField;
            if (psColDef->table_index == 0 && psColDef->field_index != -1)
            {
                OGRLayer* poLayer = papoTableLayers[psColDef->table_index];
                int nSpecialFieldIdx = psColDef->field_index -
                                poLayer->GetLayerDefn()->GetFieldCount();
                if (nSpecialFieldIdx == SPF_OGR_GEOMETRY ||
                    nSpecialFieldIdx == SPF_OGR_GEOM_WKT ||
                    nSpecialFieldIdx == SPF_OGR_GEOM_AREA)
                {
                    bFoundGeomExpr = TRUE;
                    break;
                }
                if( psColDef->field_index ==
                        GEOM_FIELD_INDEX_TO_ALL_FIELD_INDEX(poLayer->GetLayerDefn(), 0) )
                {
                    bFoundGeomExpr = TRUE;
                    break;
                }
            }
            if (psColDef->expr != NULL && ContainGeomSpecialField(psColDef->expr))
            {
                bFoundGeomExpr = TRUE;
                break;
            }
        }
        if (!bFoundGeomExpr)
            poSrcLayer->GetLayerDefn()->SetGeometryIgnored(TRUE);
    }

/* -------------------------------------------------------------------- */
/*      We treat COUNT(*) as a special case, and fill with              */
/*      GetFeatureCount().                                              */
/* -------------------------------------------------------------------- */

    if( psSelectInfo->result_columns == 1 
        && psSelectInfo->column_defs[0].col_func == SWQCF_COUNT
        && psSelectInfo->column_defs[0].field_index < 0 )
    {
        poSummaryFeature->SetField( 0, poSrcLayer->GetFeatureCount( TRUE ) );
        poSrcLayer->GetLayerDefn()->SetGeometryIgnored(bSaveIsGeomIgnored);
        return TRUE;
    }

/* -------------------------------------------------------------------- */
/*      Otherwise, process all source feature through the summary       */
/*      building facilities of SWQ.                                     */
/* -------------------------------------------------------------------- */
    const char *pszError;
    OGRFeature *poSrcFeature;
    int iField;

    while( (poSrcFeature = poSrcLayer->GetNextFeature()) != NULL )
    {
        for( iField = 0; iField < psSelectInfo->result_columns; iField++ )
        {
            swq_col_def *psColDef = psSelectInfo->column_defs + iField;

            if (psColDef->col_func == SWQCF_COUNT)
            {
                /* psColDef->field_index can be -1 in the case of a COUNT(*) */
                if (psColDef->field_index < 0)
                    pszError = swq_select_summarize( psSelectInfo, iField, """" );
                else if (IS_GEOM_FIELD_INDEX(poSrcLayer->GetLayerDefn(), psColDef->field_index) )
                {
                    int iSrcGeomField = ALL_FIELD_INDEX_TO_GEOM_FIELD_INDEX(
                            poSrcLayer->GetLayerDefn(), psColDef->field_index);
                    OGRGeometry* poGeom = poSrcFeature->GetGeomFieldRef(iSrcGeomField);
                    if( poGeom != NULL )
                        pszError = swq_select_summarize( psSelectInfo, iField, """" );
                    else
                        pszError = NULL;
                }
                else if (poSrcFeature->IsFieldSet(psColDef->field_index))
                    pszError = swq_select_summarize( psSelectInfo, iField, poSrcFeature->GetFieldAsString(
                                                psColDef->field_index ) );
                else
                    pszError = NULL;
            }
            else
            {
                const char* pszVal = NULL;
                if (poSrcFeature->IsFieldSet(psColDef->field_index))
                    pszVal = poSrcFeature->GetFieldAsString(
                                                psColDef->field_index );
                pszError = swq_select_summarize( psSelectInfo, iField, pszVal );
            }
            
            if( pszError != NULL )
            {
                delete poSrcFeature;
                delete poSummaryFeature;
                poSummaryFeature = NULL;

                poSrcLayer->GetLayerDefn()->SetGeometryIgnored(bSaveIsGeomIgnored);

                CPLError( CE_Failure, CPLE_AppDefined, ""%s"", pszError );
                return FALSE;
            }
        }

        delete poSrcFeature;
    }

    poSrcLayer->GetLayerDefn()->SetGeometryIgnored(bSaveIsGeomIgnored);

    pszError = swq_select_finish_summarize( psSelectInfo );
    if( pszError != NULL )
    {
        delete poSummaryFeature;
        poSummaryFeature = NULL;
        
        CPLError( CE_Failure, CPLE_AppDefined, ""%s"", pszError );
        return FALSE;
    }

/* -------------------------------------------------------------------- */
/*      If we have run out of features on the source layer, clear       */
/*      away the filters we have installed till a next run through      */
/*      the features.                                                   */
/* -------------------------------------------------------------------- */
    if( poSrcFeature == NULL )
        ClearFilters();

/* -------------------------------------------------------------------- */
/*      Now apply the values to the summary feature.  If we are in      */
/*      DISTINCT_LIST mode we don't do this step.                       */
/* -------------------------------------------------------------------- */
    if( psSelectInfo->query_mode == SWQM_SUMMARY_RECORD )
    {
        for( iField = 0; iField < psSelectInfo->result_columns; iField++ )
        {
            swq_col_def *psColDef = psSelectInfo->column_defs + iField;
            if (psSelectInfo->column_summary != NULL)
            {
                swq_summary *psSummary = psSelectInfo->column_summary + iField;

                if( psColDef->col_func == SWQCF_AVG )
                {
                    if( psColDef->field_type == SWQ_DATE ||
                        psColDef->field_type == SWQ_TIME ||
                        psColDef->field_type == SWQ_TIMESTAMP)
                    {
                        struct tm brokendowntime;
                        CPLUnixTimeToYMDHMS((GIntBig)(psSummary->sum / psSummary->count), &brokendowntime);
                        poSummaryFeature->SetField( iField,
                                                    brokendowntime.tm_year + 1900,
                                                    brokendowntime.tm_mon + 1,
                                                    brokendowntime.tm_mday,
                                                    brokendowntime.tm_hour,
                                                    brokendowntime.tm_min,
                                                    brokendowntime.tm_sec, 0);
                    }
                    else
                        poSummaryFeature->SetField( iField,
                                                    psSummary->sum / psSummary->count );
                }
                else if( psColDef->col_func == SWQCF_MIN )
                {
                    if( psColDef->field_type == SWQ_DATE ||
                        psColDef->field_type == SWQ_TIME ||
                        psColDef->field_type == SWQ_TIMESTAMP)
                        poSummaryFeature->SetField( iField, psSummary->szMin );
                    else
                        poSummaryFeature->SetField( iField, psSummary->min );
                }
                else if( psColDef->col_func == SWQCF_MAX )
                {
                    if( psColDef->field_type == SWQ_DATE ||
                        psColDef->field_type == SWQ_TIME ||
                        psColDef->field_type == SWQ_TIMESTAMP)
                        poSummaryFeature->SetField( iField, psSummary->szMax );
                    else
                        poSummaryFeature->SetField( iField, psSummary->max );
                }
                else if( psColDef->col_func == SWQCF_COUNT )
                    poSummaryFeature->SetField( iField, psSummary->count );
                else if( psColDef->col_func == SWQCF_SUM )
                    poSummaryFeature->SetField( iField, psSummary->sum );
            }
            else if ( psColDef->col_func == SWQCF_COUNT )
                poSummaryFeature->SetField( iField, 0 );
        }
    }

    return TRUE;
}

/************************************************************************/
/*                       OGRMultiFeatureFetcher()                       */
/************************************************************************/

static swq_expr_node *OGRMultiFeatureFetcher( swq_expr_node *op, 
                                              void *pFeatureList )

{
    std::vector<OGRFeature*> *papoFeatures = 
        (std::vector<OGRFeature*> *) pFeatureList;
    OGRFeature *poFeature;
    swq_expr_node *poRetNode = NULL;

    CPLAssert( op->eNodeType == SNT_COLUMN );

/* -------------------------------------------------------------------- */
/*      What feature are we using?  The primary or one of the joined ones?*/
/* -------------------------------------------------------------------- */
    if( op->table_index < 0 || op->table_index >= (int)papoFeatures->size() )
    {
        CPLError( CE_Failure, CPLE_AppDefined,
                  ""Request for unexpected table_index (%d) in field fetcher."",
                  op->table_index );
        return NULL;
    }
    
    poFeature = (*papoFeatures)[op->table_index];

/* -------------------------------------------------------------------- */
/*      Fetch the value.                                                */
/* -------------------------------------------------------------------- */
    switch( op->field_type )
    {
      case SWQ_INTEGER:
      case SWQ_BOOLEAN:
        if( poFeature == NULL 
            || !poFeature->IsFieldSet(op->field_index) )
        {
            poRetNode = new swq_expr_node(0);
            poRetNode->is_null = TRUE;
        }
        else
            poRetNode = new swq_expr_node( 
                poFeature->GetFieldAsInteger(op->field_index) );
        break;

      case SWQ_FLOAT:
        if( poFeature == NULL 
            || !poFeature->IsFieldSet(op->field_index) )
        {
            poRetNode = new swq_expr_node( 0.0 );
            poRetNode->is_null = TRUE;
        }
        else
            poRetNode = new swq_expr_node( 
                poFeature->GetFieldAsDouble(op->field_index) );
        break;
        
      case SWQ_GEOMETRY:
        if( poFeature == NULL )
        {
            poRetNode = new swq_expr_node( (OGRGeometry*) NULL );
        }
        else
        {
            int iSrcGeomField = ALL_FIELD_INDEX_TO_GEOM_FIELD_INDEX(
                poFeature->GetDefnRef(), op->field_index);
            poRetNode = new swq_expr_node(
                poFeature->GetGeomFieldRef(iSrcGeomField) );
        }
        break;

      default:
        if( poFeature == NULL 
            || !poFeature->IsFieldSet(op->field_index) )
        {
            poRetNode = new swq_expr_node("""");
            poRetNode->is_null = TRUE;
        }
        else
            poRetNode = new swq_expr_node( 
                poFeature->GetFieldAsString(op->field_index) );
        break;
    }

    return poRetNode;
}

/************************************************************************/
/*                          TranslateFeature()                          */
/************************************************************************/

OGRFeature *OGRGenSQLResultsLayer::TranslateFeature( OGRFeature *poSrcFeat )

{
    swq_select *psSelectInfo = (swq_select *) pSelectInfo;
    OGRFeature *poDstFeat;
    std::vector<OGRFeature*> apoFeatures;

    if( poSrcFeat == NULL )
        return NULL;

    m_nFeaturesRead++;

    apoFeatures.push_back( poSrcFeat );

/* -------------------------------------------------------------------- */
/*      Fetch the corresponding features from any jointed tables.       */
/* -------------------------------------------------------------------- */
    int iJoin;

    for( iJoin = 0; iJoin < psSelectInfo->join_count; iJoin++ )
    {
        CPLString osFilter;

        swq_join_def *psJoinInfo = psSelectInfo->join_defs + iJoin;

        /* OGRMultiFeatureFetcher assumes that the features are pushed in */
        /* apoFeatures with increasing secondary_table, so make sure */
        /* we have taken care of this */
        CPLAssert(psJoinInfo->secondary_table == iJoin + 1);

        OGRLayer *poJoinLayer = papoTableLayers[psJoinInfo->secondary_table];
        
        // if source key is null, we can't do join.
        if( !poSrcFeat->IsFieldSet( psJoinInfo->primary_field ) )
        {
            apoFeatures.push_back( NULL );
            continue;
        }
        
        OGRFieldDefn* poSecondaryFieldDefn =
            poJoinLayer->GetLayerDefn()->GetFieldDefn( 
                     psJoinInfo->secondary_field );
        OGRFieldType ePrimaryFieldType = poSrcLayer->GetLayerDefn()->
                    GetFieldDefn(psJoinInfo->primary_field )->GetType();
        OGRFieldType eSecondaryFieldType = poSecondaryFieldDefn->GetType();

        // Prepare attribute query to express fetching on the joined variable
        
        // If joining a (primary) numeric column with a (secondary) string column
        // then add implicit casting of the secondary column to numeric. This behaviour
        // worked in GDAL < 1.8, and it is consistant with how sqlite behaves too. See #4321
        // For the reverse case, joining a string column with a numeric column, the
        // string constant will be cast to float by SWQAutoConvertStringToNumeric (#4259)
        if( eSecondaryFieldType == OFTString &&
            (ePrimaryFieldType == OFTInteger || ePrimaryFieldType == OFTReal) )
            osFilter.Printf(""CAST(%s AS FLOAT) = "", poSecondaryFieldDefn->GetNameRef() );
        else
            osFilter.Printf(""%s = "", poSecondaryFieldDefn->GetNameRef() );

        OGRField *psSrcField = 
            poSrcFeat->GetRawFieldRef(psJoinInfo->primary_field);

        switch( ePrimaryFieldType )
        {
          case OFTInteger:
            osFilter += CPLString().Printf(""%d"", psSrcField->Integer );
            break;

          case OFTReal:
            osFilter += CPLString().Printf(""%.16g"", psSrcField->Real );
            break;

          case OFTString:
          {
              char *pszEscaped = CPLEscapeString( psSrcField->String, 
                                                  strlen(psSrcField->String),
                                                  CPLES_SQL );
              osFilter += ""'"";
              osFilter += pszEscaped;
              osFilter += ""'"";
              CPLFree( pszEscaped );
          }
          break;

          default:
            CPLAssert( FALSE );
            continue;
        }

        OGRFeature *poJoinFeature = NULL;

        poJoinLayer->ResetReading();
        if( poJoinLayer->SetAttributeFilter( osFilter.c_str() ) == OGRERR_NONE )
            poJoinFeature = poJoinLayer->GetNextFeature();

        apoFeatures.push_back( poJoinFeature );
    }

/* -------------------------------------------------------------------- */
/*      Create destination feature.                                     */
/* -------------------------------------------------------------------- */
    poDstFeat = new OGRFeature( poDefn );

    poDstFeat->SetFID( poSrcFeat->GetFID() );

    poDstFeat->SetStyleString( poSrcFeat->GetStyleString() );

/* -------------------------------------------------------------------- */
/*      Evaluate fields that are complex expressions.                   */
/* -------------------------------------------------------------------- */
    int iRegularField = 0;
    int iGeomField = 0;
    for( int iField = 0; iField < psSelectInfo->result_columns; iField++ )
    {
        swq_col_def *psColDef = psSelectInfo->column_defs + iField;
        swq_expr_node *poResult;

        if( psColDef->field_index != -1 )
        {
            if( psColDef->field_type == SWQ_GEOMETRY ||
                psColDef->target_type == SWQ_GEOMETRY )
                iGeomField++;
            else
                iRegularField++;
            continue;
        }

        poResult = psColDef->expr->Evaluate( OGRMultiFeatureFetcher, 
                                             (void *) &apoFeatures );
        
        if( poResult == NULL )
        {
            delete poDstFeat;
            return NULL;
        }

        if( poResult->is_null )
        {
            if( poResult->field_type == SWQ_GEOMETRY )
                iGeomField++;
            else
                iRegularField++;
            delete poResult;
            continue;
        }

        switch( poResult->field_type )
        {
          case SWQ_INTEGER:
            poDstFeat->SetField( iRegularField++, poResult->int_value );
            break;
            
          case SWQ_FLOAT:
            poDstFeat->SetField( iRegularField++, poResult->float_value );
            break;
            
          case SWQ_GEOMETRY:
          {
            OGRGenSQLGeomFieldDefn* poGeomFieldDefn =
                (OGRGenSQLGeomFieldDefn*) poDstFeat->GetGeomFieldDefnRef(iGeomField);
            if( poGeomFieldDefn->bForceGeomType &&
                poResult->geometry_value != NULL )
            {
                OGRwkbGeometryType eCurType =
                    wkbFlatten(poResult->geometry_value->getGeometryType());
                OGRwkbGeometryType eReqType =
                    wkbFlatten(poGeomFieldDefn->GetType());
                if( eCurType == wkbPolygon && eReqType == wkbMultiPolygon )
                {
                    poResult->geometry_value = (OGRGeometry*)
                        OGR_G_ForceToMultiPolygon( (OGRGeometryH) poResult->geometry_value );
                }
                else if( (eCurType == wkbMultiPolygon || eCurType == wkbGeometryCollection) &&
                         eReqType == wkbPolygon )
                {
                    poResult->geometry_value = (OGRGeometry*)
                        OGR_G_ForceToPolygon( (OGRGeometryH) poResult->geometry_value );
                }
                else if( eCurType == wkbLineString && eReqType == wkbMultiLineString )
                {
                    poResult->geometry_value = (OGRGeometry*)
                        OGR_G_ForceToMultiLineString( (OGRGeometryH) poResult->geometry_value );
                }
                else if( (eCurType == wkbMultiLineString || eCurType == wkbGeometryCollection) &&
                         eReqType == wkbLineString )
                {
                    poResult->geometry_value = (OGRGeometry*)
                        OGR_G_ForceToLineString( (OGRGeometryH) poResult->geometry_value );
                }
            }
            poDstFeat->SetGeomField( iGeomField++, poResult->geometry_value );
            break;
          }
            
          default:
            poDstFeat->SetField( iRegularField++, poResult->string_value );
            break;
        }

        delete poResult;
    }
    
/* -------------------------------------------------------------------- */
/*      Copy fields from primary record to the destination feature.     */
/* -------------------------------------------------------------------- */
    iRegularField = 0;
    iGeomField = 0;
    for( int iField = 0; iField < psSelectInfo->result_columns; iField++ )
    {
        swq_col_def *psColDef = psSelectInfo->column_defs + iField;

        if( psColDef->table_index != 0 )
        {
            if( psColDef->field_type == SWQ_GEOMETRY ||
                psColDef->target_type == SWQ_GEOMETRY )
                iGeomField++;
            else
                iRegularField++;
            continue;
        }

        if( IS_GEOM_FIELD_INDEX(poSrcFeat->GetDefnRef(), psColDef->field_index) )
        {
            int iSrcGeomField = ALL_FIELD_INDEX_TO_GEOM_FIELD_INDEX(
                poSrcFeat->GetDefnRef(), psColDef->field_index);
            poDstFeat->SetGeomField( iGeomField ++,
                                     poSrcFeat->GetGeomFieldRef(iSrcGeomField) );
        }
        else if( psColDef->field_index >= iFIDFieldIndex &&
                 psColDef->field_index < iFIDFieldIndex + SPECIAL_FIELD_COUNT )
        {
            switch (SpecialFieldTypes[psColDef->field_index - iFIDFieldIndex])
            {
              case SWQ_INTEGER:
                poDstFeat->SetField( iRegularField, poSrcFeat->GetFieldAsInteger(psColDef->field_index) );
                break;
              case SWQ_FLOAT:
                poDstFeat->SetField( iRegularField, poSrcFeat->GetFieldAsDouble(psColDef->field_index) );
                break;
              default:
                poDstFeat->SetField( iRegularField, poSrcFeat->GetFieldAsString(psColDef->field_index) );
            }
            iRegularField ++;
        }
        else
        {
            switch (psColDef->target_type)
            {
              case SWQ_INTEGER:
                poDstFeat->SetField( iRegularField, poSrcFeat->GetFieldAsInteger(psColDef->field_index) );
                break;

              case SWQ_FLOAT:
                poDstFeat->SetField( iRegularField, poSrcFeat->GetFieldAsDouble(psColDef->field_index) );
                break;
              
              case SWQ_STRING:
              case SWQ_TIMESTAMP:
              case SWQ_DATE:
              case SWQ_TIME:
                poDstFeat->SetField( iRegularField, poSrcFeat->GetFieldAsString(psColDef->field_index) );
                break;
                
              case SWQ_GEOMETRY:
                  CPLAssert(0);
                  break;

              default:
                poDstFeat->SetField( iRegularField,
                         poSrcFeat->GetRawFieldRef( psColDef->field_index ) );
            }
            iRegularField ++;
        }
    }

/* -------------------------------------------------------------------- */
/*      Copy values from any joined tables.                             */
/* -------------------------------------------------------------------- */
    for( iJoin = 0; iJoin < psSelectInfo->join_count; iJoin++ )
    {
        CPLString osFilter;

        swq_join_def *psJoinInfo = psSelectInfo->join_defs + iJoin;
        OGRFeature *poJoinFeature = apoFeatures[iJoin+1];

        if( poJoinFeature == NULL )
            continue;

        // Copy over selected field values. 
        iRegularField = 0;
        for( int iField = 0; iField < psSelectInfo->result_columns; iField++ )
        {
            swq_col_def *psColDef = psSelectInfo->column_defs + iField;

            if( psColDef->field_type == SWQ_GEOMETRY ||
                psColDef->target_type == SWQ_GEOMETRY )
                continue;

            if( psColDef->table_index == psJoinInfo->secondary_table )
                poDstFeat->SetField( iRegularField,
                                     poJoinFeature->GetRawFieldRef( 
                                         psColDef->field_index ) );

            iRegularField ++;
        }

        delete poJoinFeature;
    }

    return poDstFeat;
}

/************************************************************************/
/*                           GetNextFeature()                           */
/************************************************************************/

OGRFeature *OGRGenSQLResultsLayer::GetNextFeature()

{
    swq_select *psSelectInfo = (swq_select *) pSelectInfo;

    CreateOrderByIndex();

/* -------------------------------------------------------------------- */
/*      Handle summary sets.                                            */
/* -------------------------------------------------------------------- */
    if( psSelectInfo->query_mode == SWQM_SUMMARY_RECORD 
        || psSelectInfo->query_mode == SWQM_DISTINCT_LIST )
        return GetFeature( nNextIndexFID++ );

    int bEvaluateSpatialFilter = MustEvaluateSpatialFilterOnGenSQL();

/* -------------------------------------------------------------------- */
/*      Handle ordered sets.                                            */
/* -------------------------------------------------------------------- */
    while( TRUE )
    {
        OGRFeature *poFeature;

        if( panFIDIndex != NULL )
            poFeature =  GetFeature( nNextIndexFID++ );
        else
        {
            OGRFeature *poSrcFeat = poSrcLayer->GetNextFeature();

            if( poSrcFeat == NULL )
                return NULL;
            
            poFeature = TranslateFeature( poSrcFeat );
            delete poSrcFeat;
        }

        if( poFeature == NULL )
            return NULL;

        if( (m_poAttrQuery == NULL
            || m_poAttrQuery->Evaluate( poFeature )) &&
            (!bEvaluateSpatialFilter ||
             FilterGeometry( poFeature->GetGeomFieldRef(m_iGeomFieldFilter) )) )
            return poFeature;

        delete poFeature;
    }

    return NULL;
}

/************************************************************************/
/*                             GetFeature()                             */
/************************************************************************/

OGRFeature *OGRGenSQLResultsLayer::GetFeature( long nFID )

{
    swq_select *psSelectInfo = (swq_select *) pSelectInfo;

    CreateOrderByIndex();

/* -------------------------------------------------------------------- */
/*      Handle request for summary record.                              */
/* -------------------------------------------------------------------- */
    if( psSelectInfo->query_mode == SWQM_SUMMARY_RECORD )
    {
        if( !PrepareSummary() || nFID != 0 || poSummaryFeature == NULL )
            return NULL;
        else
            return poSummaryFeature->Clone();
    }

/* -------------------------------------------------------------------- */
/*      Handle request for distinct list record.                        */
/* -------------------------------------------------------------------- */
    if( psSelectInfo->query_mode == SWQM_DISTINCT_LIST )
    {
        if( !PrepareSummary() )
            return NULL;

        swq_summary *psSummary = psSelectInfo->column_summary + 0;

        if( psSummary == NULL )
            return NULL;

        if( nFID < 0 || nFID >= psSummary->count )
            return NULL;

        if( psSummary->distinct_list[nFID] != NULL )
            poSummaryFeature->SetField( 0, psSummary->distinct_list[nFID] );
        else
            poSummaryFeature->UnsetField( 0 );
        poSummaryFeature->SetFID( nFID );

        return poSummaryFeature->Clone();
    }

/* -------------------------------------------------------------------- */
/*      Are we running in sorted mode?  If so, run the fid through      */
/*      the index.                                                      */
/* -------------------------------------------------------------------- */
    if( panFIDIndex != NULL )
    {
        if( nFID < 0 || nFID >= nIndexSize )
            return NULL;
        else
            nFID = panFIDIndex[nFID];
    }

/* -------------------------------------------------------------------- */
/*      Handle request for random record.                               */
/* -------------------------------------------------------------------- */
    OGRFeature *poSrcFeature = poSrcLayer->GetFeature( nFID );
    OGRFeature *poResult;

    if( poSrcFeature == NULL )
        return NULL;

    poResult = TranslateFeature( poSrcFeature );
    poResult->SetFID( nFID );
    
    delete poSrcFeature;

    return poResult;
}

/************************************************************************/
/*                          GetSpatialFilter()                          */
/************************************************************************/

OGRGeometry *OGRGenSQLResultsLayer::GetSpatialFilter() 

{
    return NULL;
}

/************************************************************************/
/*                            GetLayerDefn()                            */
/************************************************************************/

OGRFeatureDefn *OGRGenSQLResultsLayer::GetLayerDefn()

{
    return poDefn;
}

/************************************************************************/
/*                         CreateOrderByIndex()                         */
/*                                                                      */
/*      This method is responsible for creating an index providing      */
/*      ordered access to the features according to the supplied        */
/*      ORDER BY clauses.                                               */
/*                                                                      */
/*      This is accomplished by making one pass through all the         */
/*      eligible source features, and capturing the order by fields     */
/*      of all records in memory.  A quick sort is then applied to      */
/*      this in memory copy of the order-by fields to create the        */
/*      required index.                                                 */
/*                                                                      */
/*      Keeping all the key values in memory will *not* scale up to     */
/*      very large input datasets.                                      */
/************************************************************************/

void OGRGenSQLResultsLayer::CreateOrderByIndex()

{
    swq_select *psSelectInfo = (swq_select *) pSelectInfo;
    OGRField *pasIndexFields;
    int      i, nOrderItems = psSelectInfo->order_specs;
    long     *panFIDList;

    if( ! (psSelectInfo->order_specs > 0
           && psSelectInfo->query_mode == SWQM_RECORDSET
           && nOrderItems != 0 ) )
        return;

    if( bOrderByValid )
        return;

    bOrderByValid = TRUE;

    ResetReading();

/* -------------------------------------------------------------------- */
/*      Allocate set of key values, and the output index.               */
/* -------------------------------------------------------------------- */
    int nFeaturesAlloc = 100;

    panFIDIndex = NULL;
    pasIndexFields = (OGRField *) 
        CPLCalloc(sizeof(OGRField), nOrderItems * nFeaturesAlloc);
    panFIDList = (long *) CPLMalloc(sizeof(long) * nFeaturesAlloc);

/* -------------------------------------------------------------------- */
/*      Read in all the key values.                                     */
/* -------------------------------------------------------------------- */
    OGRFeature *poSrcFeat;
    nIndexSize = 0;

    while( (poSrcFeat = poSrcLayer->GetNextFeature()) != NULL )
    {
        int iKey;

        if (nIndexSize == nFeaturesAlloc)
        {
            int nNewFeaturesAlloc = (nFeaturesAlloc * 4) / 3;
            OGRField* pasNewIndexFields = (OGRField *)
                VSIRealloc(pasIndexFields,
                           sizeof(OGRField) * nOrderItems * nNewFeaturesAlloc);
            if (pasNewIndexFields == NULL)
            {
                VSIFree(pasIndexFields);
                VSIFree(panFIDList);
                nIndexSize = 0;
                return;
            }
            pasIndexFields = pasNewIndexFields;

            long* panNewFIDList = (long *)
                VSIRealloc(panFIDList, sizeof(long) *  nNewFeaturesAlloc);
            if (panNewFIDList == NULL)
            {
                VSIFree(pasIndexFields);
                VSIFree(panFIDList);
                nIndexSize = 0;
                return;
            }
            panFIDList = panNewFIDList;

            memset(pasIndexFields + nFeaturesAlloc, 0,
                   sizeof(OGRField) * nOrderItems * (nNewFeaturesAlloc - nFeaturesAlloc));

            nFeaturesAlloc = nNewFeaturesAlloc;
        }

        for( iKey = 0; iKey < nOrderItems; iKey++ )
        {
            swq_order_def *psKeyDef = psSelectInfo->order_defs + iKey;
            OGRFieldDefn *poFDefn;
            OGRField *psSrcField, *psDstField;

            psDstField = pasIndexFields + nIndexSize * nOrderItems + iKey;

            if ( psKeyDef->field_index >= iFIDFieldIndex)
            {
                if ( psKeyDef->field_index < iFIDFieldIndex + SPECIAL_FIELD_COUNT )
                {
                    switch (SpecialFieldTypes[psKeyDef->field_index - iFIDFieldIndex])
                    {
                      case SWQ_INTEGER:
                        psDstField->Integer = poSrcFeat->GetFieldAsInteger(psKeyDef->field_index);
                        break;

                      case SWQ_FLOAT:
                        psDstField->Real = poSrcFeat->GetFieldAsDouble(psKeyDef->field_index);
                        break;

                      default:
                        psDstField->String = CPLStrdup( poSrcFeat->GetFieldAsString(psKeyDef->field_index) );
                        break;
                    }
                }
                continue;
            }
            
            poFDefn = poSrcLayer->GetLayerDefn()->GetFieldDefn( 
                psKeyDef->field_index );

            psSrcField = poSrcFeat->GetRawFieldRef( psKeyDef->field_index );

            if( poFDefn->GetType() == OFTInteger 
                || poFDefn->GetType() == OFTReal
                || poFDefn->GetType() == OFTDate
                || poFDefn->GetType() == OFTTime
                || poFDefn->GetType() == OFTDateTime)
                memcpy( psDstField, psSrcField, sizeof(OGRField) );
            else if( poFDefn->GetType() == OFTString )
            {
                if( poSrcFeat->IsFieldSet( psKeyDef->field_index ) )
                    psDstField->String = CPLStrdup( psSrcField->String );
                else
                    memcpy( psDstField, psSrcField, sizeof(OGRField) );
            }
        }

        panFIDList[nIndexSize] = poSrcFeat->GetFID();
        delete poSrcFeat;

        nIndexSize++;
    }

    //CPLDebug(""GenSQL"", ""CreateOrderByIndex() = %d features"", nIndexSize);

/* -------------------------------------------------------------------- */
/*      Initialize panFIDIndex                                          */
/* -------------------------------------------------------------------- */
    panFIDIndex = (long *) CPLMalloc(sizeof(long) * nIndexSize);
    for( i = 0; i < nIndexSize; i++ )
        panFIDIndex[i] = i;

/* -------------------------------------------------------------------- */
/*      Quick sort the records.                                         */
/* -------------------------------------------------------------------- */
    SortIndexSection( pasIndexFields, 0, nIndexSize );

/* -------------------------------------------------------------------- */
/*      Rework the FID map to map to real FIDs.                         */
/* -------------------------------------------------------------------- */
    int bAlreadySorted = TRUE;
    for( i = 0; i < nIndexSize; i++ )
    {
        if (panFIDIndex[i] != i)
            bAlreadySorted = FALSE;
        panFIDIndex[i] = panFIDList[panFIDIndex[i]];
    }

    CPLFree( panFIDList );

/* -------------------------------------------------------------------- */
/*      Free the key field values.                                      */
/* -------------------------------------------------------------------- */
    for( int iKey = 0; iKey < nOrderItems; iKey++ )
    {
        swq_order_def *psKeyDef = psSelectInfo->order_defs + iKey;
        OGRFieldDefn *poFDefn;

        if ( psKeyDef->field_index >= iFIDFieldIndex &&
            psKeyDef->field_index < iFIDFieldIndex + SPECIAL_FIELD_COUNT )
        {
            /* warning: only special fields of type string should be deallocated */
            if (SpecialFieldTypes[psKeyDef->field_index - iFIDFieldIndex] == SWQ_STRING)
            {
                for( i = 0; i < nIndexSize; i++ )
                {
                    OGRField *psField = pasIndexFields + iKey + i * nOrderItems;
                    CPLFree( psField->String );
                }
            }
            continue;
        }

        poFDefn = poSrcLayer->GetLayerDefn()->GetFieldDefn( 
            psKeyDef->field_index );

        if( poFDefn->GetType() == OFTString )
        {
            for( i = 0; i < nIndexSize; i++ )
            {
                OGRField *psField = pasIndexFields + iKey + i * nOrderItems;
                
                if( psField->Set.nMarker1 != OGRUnsetMarker 
                    || psField->Set.nMarker2 != OGRUnsetMarker )
                    CPLFree( psField->String );
            }
        }
    }

    CPLFree( pasIndexFields );

    /* If it is already sorted, then free than panFIDIndex array */
    /* so that GetNextFeature() can call a sequential GetNextFeature() */
    /* on the source array. Very usefull for layers where random access */
    /* is slow. */
    /* Use case: the GML result of a WFS GetFeature with a SORTBY */
    if (bAlreadySorted)
    {
        CPLFree( panFIDIndex );
        panFIDIndex = NULL;

        nIndexSize = 0;
    }

    ResetReading();
}

/************************************************************************/
/*                          SortIndexSection()                          */
/*                                                                      */
/*      Sort the records in a section of the index.                     */
/************************************************************************/

void OGRGenSQLResultsLayer::SortIndexSection( OGRField *pasIndexFields, 
                                              int nStart, int nEntries )

{
    if( nEntries < 2 )
        return;

    swq_select *psSelectInfo = (swq_select *) pSelectInfo;
    int      nOrderItems = psSelectInfo->order_specs;

    int nFirstGroup = nEntries / 2;
    int nFirstStart = nStart;
    int nSecondGroup = nEntries - nFirstGroup;
    int nSecondStart = nStart + nFirstGroup;
    int iMerge = 0;
    long *panMerged;

    SortIndexSection( pasIndexFields, nFirstStart, nFirstGroup );
    SortIndexSection( pasIndexFields, nSecondStart, nSecondGroup );

    panMerged = (long *) CPLMalloc( sizeof(long) * nEntries );
        
    while( iMerge < nEntries )
    {
        int  nResult;

        if( nFirstGroup == 0 )
            nResult = -1;
        else if( nSecondGroup == 0 )
            nResult = 1;
        else
            nResult = Compare( pasIndexFields 
                               + panFIDIndex[nFirstStart] * nOrderItems, 
                               pasIndexFields 
                               + panFIDIndex[nSecondStart] * nOrderItems );

        if( nResult < 0 )
        {
            panMerged[iMerge++] = panFIDIndex[nSecondStart++];
            nSecondGroup--;
        }
        else
        {
            panMerged[iMerge++] = panFIDIndex[nFirstStart++];
            nFirstGroup--;
        }
    }

    /* Copy the merge list back into the main index */

    memcpy( panFIDIndex + nStart, panMerged, sizeof(long) * nEntries );
    CPLFree( panMerged );
}

/************************************************************************/
/*                              Compare()                               */
/************************************************************************/

int OGRGenSQLResultsLayer::Compare( OGRField *pasFirstTuple,
                                    OGRField *pasSecondTuple )

{
    swq_select *psSelectInfo = (swq_select *) pSelectInfo;
    int  nResult = 0, iKey;

    for( iKey = 0; nResult == 0 && iKey < psSelectInfo->order_specs; iKey++ )
    {
        swq_order_def *psKeyDef = psSelectInfo->order_defs + iKey;
        OGRFieldDefn *poFDefn;

        if( psKeyDef->field_index >= iFIDFieldIndex + SPECIAL_FIELD_COUNT )
        {
            CPLAssert( FALSE );
            return 0;
        }
        else if( psKeyDef->field_index >= iFIDFieldIndex )
            poFDefn = NULL;
        else
            poFDefn = poSrcLayer->GetLayerDefn()->GetFieldDefn( 
                psKeyDef->field_index );
        
        if( (pasFirstTuple[iKey].Set.nMarker1 == OGRUnsetMarker 
             && pasFirstTuple[iKey].Set.nMarker2 == OGRUnsetMarker)
            || (pasSecondTuple[iKey].Set.nMarker1 == OGRUnsetMarker 
                && pasSecondTuple[iKey].Set.nMarker2 == OGRUnsetMarker) )
            nResult = 0;
        else if ( poFDefn == NULL )
        {
            switch (SpecialFieldTypes[psKeyDef->field_index - iFIDFieldIndex])
            {
              case SWQ_INTEGER:
                if( pasFirstTuple[iKey].Integer < pasSecondTuple[iKey].Integer )
                    nResult = -1;
                else if( pasFirstTuple[iKey].Integer > pasSecondTuple[iKey].Integer )
                    nResult = 1;
                break;
              case SWQ_FLOAT:
                if( pasFirstTuple[iKey].Real < pasSecondTuple[iKey].Real )
                    nResult = -1;
                else if( pasFirstTuple[iKey].Real > pasSecondTuple[iKey].Real )
                    nResult = 1;
                break;
              case SWQ_STRING:
                nResult = strcmp(pasFirstTuple[iKey].String,
                                 pasSecondTuple[iKey].String);
                break;

              default:
                CPLAssert( FALSE );
                nResult = 0;
            }
        }
        else if( poFDefn->GetType() == OFTInteger )
        {
            if( pasFirstTuple[iKey].Integer < pasSecondTuple[iKey].Integer )
                nResult = -1;
            else if( pasFirstTuple[iKey].Integer 
                     > pasSecondTuple[iKey].Integer )
                nResult = 1;
        }
        else if( poFDefn->GetType() == OFTString )
            nResult = strcmp(pasFirstTuple[iKey].String,
                             pasSecondTuple[iKey].String);
        else if( poFDefn->GetType() == OFTReal )
        {
            if( pasFirstTuple[iKey].Real < pasSecondTuple[iKey].Real )
                nResult = -1;
            else if( pasFirstTuple[iKey].Real > pasSecondTuple[iKey].Real )
                nResult = 1;
        }
        else if( poFDefn->GetType() == OFTDate ||
                 poFDefn->GetType() == OFTTime ||
                 poFDefn->GetType() == OFTDateTime)
        {
            nResult = OGRCompareDate(&pasFirstTuple[iKey],
                                     &pasSecondTuple[iKey]);
        }

        if( psKeyDef->ascending_flag )
            nResult *= -1;
    }

    return nResult;
}


/************************************************************************/
/*                         AddFieldDefnToSet()                          */
/************************************************************************/

void OGRGenSQLResultsLayer::AddFieldDefnToSet(int iTable, int iColumn,
                                              CPLHashSet* hSet)
{
    if (iTable != -1 && iColumn != -1)
    {
        OGRLayer* poLayer = papoTableLayers[iTable];
        if (iColumn < poLayer->GetLayerDefn()->GetFieldCount())
        {
            OGRFieldDefn* poFDefn =
                poLayer->GetLayerDefn()->GetFieldDefn(iColumn);
            CPLHashSetInsert(hSet, poFDefn);
        }
    }
}

/************************************************************************/
/*                   ExploreExprForIgnoredFields()                      */
/************************************************************************/

void OGRGenSQLResultsLayer::ExploreExprForIgnoredFields(swq_expr_node* expr,
                                                        CPLHashSet* hSet)
{
    if (expr->eNodeType == SNT_COLUMN)
    {
        AddFieldDefnToSet(expr->table_index, expr->field_index, hSet);
    }
    else if (expr->eNodeType == SNT_OPERATION)
    {
        for( int i = 0; i < expr->nSubExprCount; i++ )
            ExploreExprForIgnoredFields(expr->papoSubExpr[i], hSet);
    }
}

/************************************************************************/
/*                     FindAndSetIgnoredFields()                        */
/************************************************************************/

void OGRGenSQLResultsLayer::FindAndSetIgnoredFields()
{
    swq_select *psSelectInfo = (swq_select *) pSelectInfo;
    CPLHashSet* hSet = CPLHashSetNew(CPLHashSetHashPointer,
                                     CPLHashSetEqualPointer,
                                     NULL);

/* -------------------------------------------------------------------- */
/*      1st phase : explore the whole select infos to determine which   */
/*      source fields are used                                          */
/* -------------------------------------------------------------------- */
    for( int iField = 0; iField < psSelectInfo->result_columns; iField++ )
    {
        swq_col_def *psColDef = psSelectInfo->column_defs + iField;
        AddFieldDefnToSet(psColDef->table_index, psColDef->field_index, hSet);
        if (psColDef->expr)
            ExploreExprForIgnoredFields(psColDef->expr, hSet);
    }

    if (psSelectInfo->where_expr)
        ExploreExprForIgnoredFields(psSelectInfo->where_expr, hSet);

    for( int iJoin = 0; iJoin < psSelectInfo->join_count; iJoin++ )
    {
        swq_join_def *psJoinDef = psSelectInfo->join_defs + iJoin;
        AddFieldDefnToSet(0, psJoinDef->primary_field, hSet);
        AddFieldDefnToSet(psJoinDef->secondary_table, psJoinDef->secondary_field, hSet);
    }

    for( int iOrder = 0; iOrder < psSelectInfo->order_specs; iOrder++ )
    {
        swq_order_def *psOrderDef = psSelectInfo->order_defs + iOrder;
        AddFieldDefnToSet(psOrderDef->table_index, psOrderDef->field_index, hSet);
    }

/* -------------------------------------------------------------------- */
/*      2nd phase : now, we can exclude the unused fields               */
/* -------------------------------------------------------------------- */
    for( int iTable = 0; iTable < psSelectInfo->table_count; iTable++ )
    {
        OGRLayer* poLayer = papoTableLayers[iTable];
        OGRFeatureDefn *poSrcFDefn = poLayer->GetLayerDefn();
        int iSrcField;
        char** papszIgnoredFields = NULL;
        for(iSrcField=0;iSrcField<poSrcFDefn->GetFieldCount();iSrcField++)
        {
            OGRFieldDefn* poFDefn = poSrcFDefn->GetFieldDefn(iSrcField);
            if (CPLHashSetLookup(hSet,poFDefn) == NULL)
            {
                papszIgnoredFields = CSLAddString(papszIgnoredFields, poFDefn->GetNameRef());
                //CPLDebug(""OGR"", ""Adding %s to the list of ignored fields of layer %s"",
                //         poFDefn->GetNameRef(), poLayer->GetName());
            }
        }
        poLayer->SetIgnoredFields((const char**)papszIgnoredFields);
        CSLDestroy(papszIgnoredFields);
    }

    CPLHashSetDestroy(hSet);
}

/************************************************************************/
/*                       InvalidateOrderByIndex()                       */
/************************************************************************/

void OGRGenSQLResultsLayer::InvalidateOrderByIndex()
{
    CPLFree( panFIDIndex );
    panFIDIndex = NULL;

    nIndexSize = 0;
    bOrderByValid = FALSE;
}

/************************************************************************/
/*                       SetAttributeFilter()                           */
/************************************************************************/

OGRErr OGRGenSQLResultsLayer::SetAttributeFilter( const char* pszAttributeFilter )
{
    InvalidateOrderByIndex();
    return OGRLayer::SetAttributeFilter(pszAttributeFilter);
}

/************************************************************************/
/*                       SetSpatialFilter()                             */
/************************************************************************/

void OGRGenSQLResultsLayer::SetSpatialFilter( int iGeomField, OGRGeometry * poGeom )
{
    InvalidateOrderByIndex();
    if( iGeomField == 0 )
        OGRLayer::SetSpatialFilter(poGeom);
    else
        OGRLayer::SetSpatialFilter(iGeomField, poGeom);
}
",16291,True,3234.371652577684,median
"/* Copyright 2019 Axel Huebl, Benjamin Worpitz
 *
 * This file is part of alpaka.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#include <alpaka/meta/Integral.hpp>

#include <catch2/catch.hpp>

#include <type_traits>

TEST_CASE(""isIntegralSupersetTrue"", ""[meta]"")
{
    // unsigned - unsigned
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::uint64_t, std::uint64_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::uint64_t, std::uint32_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::uint64_t, std::uint16_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::uint64_t, std::uint8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        alpaka::meta::IsIntegralSuperset<std::uint32_t, std::uint32_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::uint32_t, std::uint16_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::uint32_t, std::uint8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        alpaka::meta::IsIntegralSuperset<std::uint16_t, std::uint16_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::uint16_t, std::uint8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        alpaka::meta::IsIntegralSuperset<std::uint8_t, std::uint8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    // signed - signed
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::int64_t, std::int64_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::int64_t, std::int32_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::int64_t, std::int16_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::int64_t, std::int8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        alpaka::meta::IsIntegralSuperset<std::int32_t, std::int32_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::int32_t, std::int16_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::int32_t, std::int8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        alpaka::meta::IsIntegralSuperset<std::int16_t, std::int16_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::int16_t, std::int8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        alpaka::meta::IsIntegralSuperset<std::int8_t, std::int8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    // unsigned - signed
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::uint64_t, std::int32_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::uint64_t, std::int16_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::uint64_t, std::int8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        alpaka::meta::IsIntegralSuperset<std::uint32_t, std::int16_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::uint32_t, std::int8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        alpaka::meta::IsIntegralSuperset<std::uint16_t, std::int8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    // signed - unsigned
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::int64_t, std::uint32_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::int64_t, std::uint16_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::int64_t, std::uint8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        alpaka::meta::IsIntegralSuperset<std::int32_t, std::uint16_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        alpaka::meta::IsIntegralSuperset<std::int32_t, std::uint8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        alpaka::meta::IsIntegralSuperset<std::int16_t, std::uint8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
}

TEST_CASE(""isIntegralSupersetNoIntegral"", ""[meta]"")
{
    static_assert(
        !alpaka::meta::IsIntegralSuperset<float, std::uint8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint64_t, double>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
}

TEST_CASE(""isIntegralSupersetFalse"", ""[meta]"")
{
    // unsigned - unsigned
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint8_t, std::uint64_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint8_t, std::uint32_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint8_t, std::uint16_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint16_t, std::uint64_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint16_t, std::uint32_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint32_t, std::uint64_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    // signed - signed
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::int8_t, std::int64_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::int8_t, std::int32_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::int8_t, std::int16_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::int16_t, std::int64_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::int16_t, std::int32_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::int32_t, std::int64_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    // unsigned - signed
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint64_t, std::int64_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint32_t, std::int64_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint32_t, std::int32_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint16_t, std::int64_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint16_t, std::int32_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint16_t, std::int16_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint8_t, std::int64_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint8_t, std::int32_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint8_t, std::int16_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::uint8_t, std::int8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    // signed - unsigned
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::int64_t, std::uint64_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::int32_t, std::uint64_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::int32_t, std::uint32_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::int16_t, std::uint64_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::int16_t, std::uint32_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::int16_t, std::uint16_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");

    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::int8_t, std::uint64_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::int8_t, std::uint32_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::int8_t, std::uint16_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
    static_assert(
        !alpaka::meta::IsIntegralSuperset<std::int8_t, std::uint8_t>::value,
        ""alpaka::meta::IsIntegralSuperset failed!"");
}

TEST_CASE(""higherMax"", ""[meta]"")
{
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int8_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int8_t, std::uint8_t>, std::uint8_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int8_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int8_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int8_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int8_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int8_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int8_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMax failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint8_t, std::int8_t>, std::uint8_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint8_t, std::uint8_t>, std::uint8_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint8_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint8_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint8_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint8_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint8_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint8_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMax failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int16_t, std::int8_t>, std::int16_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int16_t, std::uint8_t>, std::int16_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int16_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int16_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int16_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int16_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int16_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int16_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMax failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint16_t, std::int8_t>, std::uint16_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint16_t, std::uint8_t>, std::uint16_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint16_t, std::int16_t>, std::uint16_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint16_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint16_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint16_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint16_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint16_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMax failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int32_t, std::int8_t>, std::int32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int32_t, std::uint8_t>, std::int32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int32_t, std::int16_t>, std::int32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int32_t, std::uint16_t>, std::int32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int32_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int32_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int32_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int32_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMax failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint32_t, std::int8_t>, std::uint32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint32_t, std::uint8_t>, std::uint32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint32_t, std::int16_t>, std::uint32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint32_t, std::uint16_t>, std::uint32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint32_t, std::int32_t>, std::uint32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint32_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint32_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint32_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMax failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int64_t, std::int8_t>, std::int64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int64_t, std::uint8_t>, std::int64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int64_t, std::int16_t>, std::int64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int64_t, std::uint16_t>, std::int64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int64_t, std::int32_t>, std::int64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int64_t, std::uint32_t>, std::int64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int64_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::int64_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMax failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint64_t, std::int8_t>, std::uint64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint64_t, std::uint8_t>, std::uint64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint64_t, std::int16_t>, std::uint64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint64_t, std::uint16_t>, std::uint64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint64_t, std::int32_t>, std::uint64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint64_t, std::uint32_t>, std::uint64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint64_t, std::int64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMax<std::uint64_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMax failed!"");
}

TEST_CASE(""lowerMax"", ""[meta]"")
{
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int8_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int8_t, std::uint8_t>, std::int8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int8_t, std::int16_t>, std::int8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int8_t, std::uint16_t>, std::int8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int8_t, std::int32_t>, std::int8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int8_t, std::uint32_t>, std::int8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int8_t, std::int64_t>, std::int8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int8_t, std::uint64_t>, std::int8_t>,
        ""alpaka::meta::LowerMax failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint8_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint8_t, std::uint8_t>, std::uint8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint8_t, std::int16_t>, std::uint8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint8_t, std::uint16_t>, std::uint8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint8_t, std::int32_t>, std::uint8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint8_t, std::uint32_t>, std::uint8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint8_t, std::int64_t>, std::uint8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint8_t, std::uint64_t>, std::uint8_t>,
        ""alpaka::meta::LowerMax failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int16_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int16_t, std::uint8_t>, std::uint8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int16_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int16_t, std::uint16_t>, std::int16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int16_t, std::int32_t>, std::int16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int16_t, std::uint32_t>, std::int16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int16_t, std::int64_t>, std::int16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int16_t, std::uint64_t>, std::int16_t>,
        ""alpaka::meta::LowerMax failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint16_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint16_t, std::uint8_t>, std::uint8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint16_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint16_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint16_t, std::int32_t>, std::uint16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint16_t, std::uint32_t>, std::uint16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint16_t, std::int64_t>, std::uint16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint16_t, std::uint64_t>, std::uint16_t>,
        ""alpaka::meta::LowerMax failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int32_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int32_t, std::uint8_t>, std::uint8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int32_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int32_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int32_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int32_t, std::uint32_t>, std::int32_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int32_t, std::int64_t>, std::int32_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int32_t, std::uint64_t>, std::int32_t>,
        ""alpaka::meta::LowerMax failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint32_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint32_t, std::uint8_t>, std::uint8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint32_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint32_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint32_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint32_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint32_t, std::int64_t>, std::uint32_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint32_t, std::uint64_t>, std::uint32_t>,
        ""alpaka::meta::LowerMax failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int64_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int64_t, std::uint8_t>, std::uint8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int64_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int64_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int64_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int64_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int64_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::int64_t, std::uint64_t>, std::int64_t>,
        ""alpaka::meta::LowerMax failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint64_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint64_t, std::uint8_t>, std::uint8_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint64_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint64_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint64_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint64_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint64_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::LowerMax failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMax<std::uint64_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::LowerMax failed!"");
}

TEST_CASE(""higherMin"", ""[meta]"")
{
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int8_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int8_t, std::uint8_t>, std::uint8_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int8_t, std::int16_t>, std::int8_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int8_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int8_t, std::int32_t>, std::int8_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int8_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int8_t, std::int64_t>, std::int8_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int8_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMin failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint8_t, std::int8_t>, std::uint8_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint8_t, std::uint8_t>, std::uint8_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint8_t, std::int16_t>, std::uint8_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint8_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint8_t, std::int32_t>, std::uint8_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint8_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint8_t, std::int64_t>, std::uint8_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint8_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMin failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int16_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int16_t, std::uint8_t>, std::uint8_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int16_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int16_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int16_t, std::int32_t>, std::int16_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int16_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int16_t, std::int64_t>, std::int16_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int16_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMin failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint16_t, std::int8_t>, std::uint16_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint16_t, std::uint8_t>, std::uint16_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint16_t, std::int16_t>, std::uint16_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint16_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint16_t, std::int32_t>, std::uint16_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint16_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint16_t, std::int64_t>, std::uint16_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint16_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMin failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int32_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int32_t, std::uint8_t>, std::uint8_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int32_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int32_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int32_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int32_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int32_t, std::int64_t>, std::int32_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int32_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMin failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint32_t, std::int8_t>, std::uint32_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint32_t, std::uint8_t>, std::uint32_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint32_t, std::int16_t>, std::uint32_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint32_t, std::uint16_t>, std::uint32_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint32_t, std::int32_t>, std::uint32_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint32_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint32_t, std::int64_t>, std::uint32_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint32_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMin failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int64_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int64_t, std::uint8_t>, std::uint8_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int64_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int64_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int64_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int64_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int64_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::int64_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMin failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint64_t, std::int8_t>, std::uint64_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint64_t, std::uint8_t>, std::uint64_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint64_t, std::int16_t>, std::uint64_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint64_t, std::uint16_t>, std::uint64_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint64_t, std::int32_t>, std::uint64_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint64_t, std::uint32_t>, std::uint64_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint64_t, std::int64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::HigherMin<std::uint64_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::HigherMin failed!"");
}
TEST_CASE(""lowerMin"", ""[meta]"")
{
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int8_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int8_t, std::uint8_t>, std::int8_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int8_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int8_t, std::uint16_t>, std::int8_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int8_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int8_t, std::uint32_t>, std::int8_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int8_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int8_t, std::uint64_t>, std::int8_t>,
        ""alpaka::meta::LowerMin failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint8_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint8_t, std::uint8_t>, std::uint8_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint8_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint8_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint8_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint8_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint8_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint8_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::LowerMin failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int16_t, std::int8_t>, std::int16_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int16_t, std::uint8_t>, std::int16_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int16_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int16_t, std::uint16_t>, std::int16_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int16_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int16_t, std::uint32_t>, std::int16_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int16_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int16_t, std::uint64_t>, std::int16_t>,
        ""alpaka::meta::LowerMin failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint16_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint16_t, std::uint8_t>, std::uint16_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint16_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint16_t, std::uint16_t>, std::uint16_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint16_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint16_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint16_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint16_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::LowerMin failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int32_t, std::int8_t>, std::int32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int32_t, std::uint8_t>, std::int32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int32_t, std::int16_t>, std::int32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int32_t, std::uint16_t>, std::int32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int32_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int32_t, std::uint32_t>, std::int32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int32_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int32_t, std::uint64_t>, std::int32_t>,
        ""alpaka::meta::LowerMin failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint32_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint32_t, std::uint8_t>, std::uint32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint32_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint32_t, std::uint16_t>, std::uint32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint32_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint32_t, std::uint32_t>, std::uint32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint32_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint32_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::LowerMin failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int64_t, std::int8_t>, std::int64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int64_t, std::uint8_t>, std::int64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int64_t, std::int16_t>, std::int64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int64_t, std::uint16_t>, std::int64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int64_t, std::int32_t>, std::int64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int64_t, std::uint32_t>, std::int64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int64_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::int64_t, std::uint64_t>, std::int64_t>,
        ""alpaka::meta::LowerMin failed!"");

    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint64_t, std::int8_t>, std::int8_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint64_t, std::uint8_t>, std::uint64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint64_t, std::int16_t>, std::int16_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint64_t, std::uint16_t>, std::uint64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint64_t, std::int32_t>, std::int32_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint64_t, std::uint32_t>, std::uint64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint64_t, std::int64_t>, std::int64_t>,
        ""alpaka::meta::LowerMin failed!"");
    static_assert(
        std::is_same_v<alpaka::meta::LowerMin<std::uint64_t, std::uint64_t>, std::uint64_t>,
        ""alpaka::meta::LowerMin failed!"");
}
",16329,True,5657.344625438961,median
"//===--- BackendUtil.cpp - LLVM Backend Utilities -------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include ""clang/CodeGen/BackendUtil.h""
#include ""clang/Basic/CodeGenOptions.h""
#include ""clang/Basic/Diagnostic.h""
#include ""clang/Basic/LangOptions.h""
#include ""clang/Basic/TargetOptions.h""
#include ""clang/Frontend/FrontendDiagnostic.h""
#include ""clang/Frontend/Utils.h""
#include ""clang/Lex/HeaderSearchOptions.h""
#include ""llvm/ADT/SmallSet.h""
#include ""llvm/ADT/StringExtras.h""
#include ""llvm/ADT/StringSwitch.h""
#include ""llvm/ADT/Triple.h""
#include ""llvm/Analysis/StackSafetyAnalysis.h""
#include ""llvm/Analysis/TargetLibraryInfo.h""
#include ""llvm/Analysis/TargetTransformInfo.h""
#include ""llvm/Bitcode/BitcodeReader.h""
#include ""llvm/Bitcode/BitcodeWriter.h""
#include ""llvm/Bitcode/BitcodeWriterPass.h""
#include ""llvm/CodeGen/RegAllocRegistry.h""
#include ""llvm/CodeGen/SchedulerRegistry.h""
#include ""llvm/CodeGen/TargetSubtargetInfo.h""
#include ""llvm/IR/DataLayout.h""
#include ""llvm/IR/IRPrintingPasses.h""
#include ""llvm/IR/LegacyPassManager.h""
#include ""llvm/IR/Module.h""
#include ""llvm/IR/ModuleSummaryIndex.h""
#include ""llvm/IR/Verifier.h""
#include ""llvm/LTO/LTOBackend.h""
#include ""llvm/MC/MCAsmInfo.h""
#include ""llvm/MC/SubtargetFeature.h""
#include ""llvm/Passes/PassBuilder.h""
#include ""llvm/Passes/PassPlugin.h""
#include ""llvm/Passes/StandardInstrumentations.h""
#include ""llvm/Support/BuryPointer.h""
#include ""llvm/Support/CommandLine.h""
#include ""llvm/Support/MemoryBuffer.h""
#include ""llvm/Support/PrettyStackTrace.h""
#include ""llvm/Support/TargetRegistry.h""
#include ""llvm/Support/TimeProfiler.h""
#include ""llvm/Support/Timer.h""
#include ""llvm/Support/raw_ostream.h""
#include ""llvm/Target/TargetMachine.h""
#include ""llvm/Target/TargetOptions.h""
#include ""llvm/Transforms/Coroutines.h""
#include ""llvm/Transforms/Coroutines/CoroCleanup.h""
#include ""llvm/Transforms/Coroutines/CoroEarly.h""
#include ""llvm/Transforms/Coroutines/CoroElide.h""
#include ""llvm/Transforms/Coroutines/CoroSplit.h""
#include ""llvm/Transforms/IPO.h""
#include ""llvm/Transforms/IPO/AlwaysInliner.h""
#include ""llvm/Transforms/IPO/LowerTypeTests.h""
#include ""llvm/Transforms/IPO/PassManagerBuilder.h""
#include ""llvm/Transforms/IPO/ThinLTOBitcodeWriter.h""
#include ""llvm/Transforms/InstCombine/InstCombine.h""
#include ""llvm/Transforms/Instrumentation.h""
#include ""llvm/Transforms/Instrumentation/AddressSanitizer.h""
#include ""llvm/Transforms/Instrumentation/BoundsChecking.h""
#include ""llvm/Transforms/Instrumentation/GCOVProfiler.h""
#include ""llvm/Transforms/Instrumentation/HWAddressSanitizer.h""
#include ""llvm/Transforms/Instrumentation/InstrProfiling.h""
#include ""llvm/Transforms/Instrumentation/MemorySanitizer.h""
#include ""llvm/Transforms/Instrumentation/SanitizerCoverage.h""
#include ""llvm/Transforms/Instrumentation/ThreadSanitizer.h""
#include ""llvm/Transforms/ObjCARC.h""
#include ""llvm/Transforms/Scalar.h""
#include ""llvm/Transforms/Scalar/GVN.h""
#include ""llvm/Transforms/Utils.h""
#include ""llvm/Transforms/Utils/CanonicalizeAliases.h""
#include ""llvm/Transforms/Utils/EntryExitInstrumenter.h""
#include ""llvm/Transforms/Utils/NameAnonGlobals.h""
#include ""llvm/Transforms/Utils/SymbolRewriter.h""
#include <memory>
using namespace clang;
using namespace llvm;

#define HANDLE_EXTENSION(Ext)                                                  \\
  llvm::PassPluginLibraryInfo get##Ext##PluginInfo();
#include ""llvm/Support/Extension.def""

namespace {

// Default filename used for profile generation.
static constexpr StringLiteral DefaultProfileGenName = ""default_%m.profraw"";

class EmitAssemblyHelper {
  DiagnosticsEngine &Diags;
  const HeaderSearchOptions &HSOpts;
  const CodeGenOptions &CodeGenOpts;
  const clang::TargetOptions &TargetOpts;
  const LangOptions &LangOpts;
  Module *TheModule;

  Timer CodeGenerationTime;

  std::unique_ptr<raw_pwrite_stream> OS;

  TargetIRAnalysis getTargetIRAnalysis() const {
    if (TM)
      return TM->getTargetIRAnalysis();

    return TargetIRAnalysis();
  }

  void CreatePasses(legacy::PassManager &MPM, legacy::FunctionPassManager &FPM);

  /// Generates the TargetMachine.
  /// Leaves TM unchanged if it is unable to create the target machine.
  /// Some of our clang tests specify triples which are not built
  /// into clang. This is okay because these tests check the generated
  /// IR, and they require DataLayout which depends on the triple.
  /// In this case, we allow this method to fail and not report an error.
  /// When MustCreateTM is used, we print an error if we are unable to load
  /// the requested target.
  void CreateTargetMachine(bool MustCreateTM);

  /// Add passes necessary to emit assembly or LLVM IR.
  ///
  /// \\return True on success.
  bool AddEmitPasses(legacy::PassManager &CodeGenPasses, BackendAction Action,
                     raw_pwrite_stream &OS, raw_pwrite_stream *DwoOS);

  std::unique_ptr<llvm::ToolOutputFile> openOutputFile(StringRef Path) {
    std::error_code EC;
    auto F = std::make_unique<llvm::ToolOutputFile>(Path, EC,
                                                     llvm::sys::fs::OF_None);
    if (EC) {
      Diags.Report(diag::err_fe_unable_to_open_output) << Path << EC.message();
      F.reset();
    }
    return F;
  }

public:
  EmitAssemblyHelper(DiagnosticsEngine &_Diags,
                     const HeaderSearchOptions &HeaderSearchOpts,
                     const CodeGenOptions &CGOpts,
                     const clang::TargetOptions &TOpts,
                     const LangOptions &LOpts, Module *M)
      : Diags(_Diags), HSOpts(HeaderSearchOpts), CodeGenOpts(CGOpts),
        TargetOpts(TOpts), LangOpts(LOpts), TheModule(M),
        CodeGenerationTime(""codegen"", ""Code Generation Time"") {}

  ~EmitAssemblyHelper() {
    if (CodeGenOpts.DisableFree)
      BuryPointer(std::move(TM));
  }

  std::unique_ptr<TargetMachine> TM;

  void EmitAssembly(BackendAction Action,
                    std::unique_ptr<raw_pwrite_stream> OS);

  void EmitAssemblyWithNewPassManager(BackendAction Action,
                                      std::unique_ptr<raw_pwrite_stream> OS);
};

// We need this wrapper to access LangOpts and CGOpts from extension functions
// that we add to the PassManagerBuilder.
class PassManagerBuilderWrapper : public PassManagerBuilder {
public:
  PassManagerBuilderWrapper(const Triple &TargetTriple,
                            const CodeGenOptions &CGOpts,
                            const LangOptions &LangOpts)
      : PassManagerBuilder(), TargetTriple(TargetTriple), CGOpts(CGOpts),
        LangOpts(LangOpts) {}
  const Triple &getTargetTriple() const { return TargetTriple; }
  const CodeGenOptions &getCGOpts() const { return CGOpts; }
  const LangOptions &getLangOpts() const { return LangOpts; }

private:
  const Triple &TargetTriple;
  const CodeGenOptions &CGOpts;
  const LangOptions &LangOpts;
};
}

static void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
  if (Builder.OptLevel > 0)
    PM.add(createObjCARCAPElimPass());
}

static void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
  if (Builder.OptLevel > 0)
    PM.add(createObjCARCExpandPass());
}

static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
  if (Builder.OptLevel > 0)
    PM.add(createObjCARCOptPass());
}

static void addAddDiscriminatorsPass(const PassManagerBuilder &Builder,
                                     legacy::PassManagerBase &PM) {
  PM.add(createAddDiscriminatorsPass());
}

static void addBoundsCheckingPass(const PassManagerBuilder &Builder,
                                  legacy::PassManagerBase &PM) {
  PM.add(createBoundsCheckingLegacyPass());
}

static SanitizerCoverageOptions
getSancovOptsFromCGOpts(const CodeGenOptions &CGOpts) {
  SanitizerCoverageOptions Opts;
  Opts.CoverageType =
      static_cast<SanitizerCoverageOptions::Type>(CGOpts.SanitizeCoverageType);
  Opts.IndirectCalls = CGOpts.SanitizeCoverageIndirectCalls;
  Opts.TraceBB = CGOpts.SanitizeCoverageTraceBB;
  Opts.TraceCmp = CGOpts.SanitizeCoverageTraceCmp;
  Opts.TraceDiv = CGOpts.SanitizeCoverageTraceDiv;
  Opts.TraceGep = CGOpts.SanitizeCoverageTraceGep;
  Opts.Use8bitCounters = CGOpts.SanitizeCoverage8bitCounters;
  Opts.TracePC = CGOpts.SanitizeCoverageTracePC;
  Opts.TracePCGuard = CGOpts.SanitizeCoverageTracePCGuard;
  Opts.NoPrune = CGOpts.SanitizeCoverageNoPrune;
  Opts.Inline8bitCounters = CGOpts.SanitizeCoverageInline8bitCounters;
  Opts.PCTable = CGOpts.SanitizeCoveragePCTable;
  Opts.StackDepth = CGOpts.SanitizeCoverageStackDepth;
  return Opts;
}

static void addSanitizerCoveragePass(const PassManagerBuilder &Builder,
                                     legacy::PassManagerBase &PM) {
  const PassManagerBuilderWrapper &BuilderWrapper =
      static_cast<const PassManagerBuilderWrapper &>(Builder);
  const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
  auto Opts = getSancovOptsFromCGOpts(CGOpts);
  PM.add(createModuleSanitizerCoverageLegacyPassPass(Opts));
}

// Check if ASan should use GC-friendly instrumentation for globals.
// First of all, there is no point if -fdata-sections is off (expect for MachO,
// where this is not a factor). Also, on ELF this feature requires an assembler
// extension that only works with -integrated-as at the moment.
static bool asanUseGlobalsGC(const Triple &T, const CodeGenOptions &CGOpts) {
  if (!CGOpts.SanitizeAddressGlobalsDeadStripping)
    return false;
  switch (T.getObjectFormat()) {
  case Triple::MachO:
  case Triple::COFF:
    return true;
  case Triple::ELF:
    return CGOpts.DataSections && !CGOpts.DisableIntegratedAS;
  case Triple::XCOFF:
    llvm::report_fatal_error(""ASan not implemented for XCOFF."");
  case Triple::Wasm:
  case Triple::UnknownObjectFormat:
    break;
  }
  return false;
}

static void addAddressSanitizerPasses(const PassManagerBuilder &Builder,
                                      legacy::PassManagerBase &PM) {
  const PassManagerBuilderWrapper &BuilderWrapper =
      static_cast<const PassManagerBuilderWrapper&>(Builder);
  const Triple &T = BuilderWrapper.getTargetTriple();
  const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
  bool Recover = CGOpts.SanitizeRecover.has(SanitizerKind::Address);
  bool UseAfterScope = CGOpts.SanitizeAddressUseAfterScope;
  bool UseOdrIndicator = CGOpts.SanitizeAddressUseOdrIndicator;
  bool UseGlobalsGC = asanUseGlobalsGC(T, CGOpts);
  PM.add(createAddressSanitizerFunctionPass(/*CompileKernel*/ false, Recover,
                                            UseAfterScope));
  PM.add(createModuleAddressSanitizerLegacyPassPass(
      /*CompileKernel*/ false, Recover, UseGlobalsGC, UseOdrIndicator));
}

static void addKernelAddressSanitizerPasses(const PassManagerBuilder &Builder,
                                            legacy::PassManagerBase &PM) {
  PM.add(createAddressSanitizerFunctionPass(
      /*CompileKernel*/ true, /*Recover*/ true, /*UseAfterScope*/ false));
  PM.add(createModuleAddressSanitizerLegacyPassPass(
      /*CompileKernel*/ true, /*Recover*/ true, /*UseGlobalsGC*/ true,
      /*UseOdrIndicator*/ false));
}

static void addHWAddressSanitizerPasses(const PassManagerBuilder &Builder,
                                            legacy::PassManagerBase &PM) {
  const PassManagerBuilderWrapper &BuilderWrapper =
      static_cast<const PassManagerBuilderWrapper &>(Builder);
  const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
  bool Recover = CGOpts.SanitizeRecover.has(SanitizerKind::HWAddress);
  PM.add(
      createHWAddressSanitizerLegacyPassPass(/*CompileKernel*/ false, Recover));
}

static void addKernelHWAddressSanitizerPasses(const PassManagerBuilder &Builder,
                                            legacy::PassManagerBase &PM) {
  PM.add(createHWAddressSanitizerLegacyPassPass(
      /*CompileKernel*/ true, /*Recover*/ true));
}

static void addGeneralOptsForMemorySanitizer(const PassManagerBuilder &Builder,
                                             legacy::PassManagerBase &PM,
                                             bool CompileKernel) {
  const PassManagerBuilderWrapper &BuilderWrapper =
      static_cast<const PassManagerBuilderWrapper&>(Builder);
  const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
  int TrackOrigins = CGOpts.SanitizeMemoryTrackOrigins;
  bool Recover = CGOpts.SanitizeRecover.has(SanitizerKind::Memory);
  PM.add(createMemorySanitizerLegacyPassPass(
      MemorySanitizerOptions{TrackOrigins, Recover, CompileKernel}));

  // MemorySanitizer inserts complex instrumentation that mostly follows
  // the logic of the original code, but operates on ""shadow"" values.
  // It can benefit from re-running some general purpose optimization passes.
  if (Builder.OptLevel > 0) {
    PM.add(createEarlyCSEPass());
    PM.add(createReassociatePass());
    PM.add(createLICMPass());
    PM.add(createGVNPass());
    PM.add(createInstructionCombiningPass());
    PM.add(createDeadStoreEliminationPass());
  }
}

static void addMemorySanitizerPass(const PassManagerBuilder &Builder,
                                   legacy::PassManagerBase &PM) {
  addGeneralOptsForMemorySanitizer(Builder, PM, /*CompileKernel*/ false);
}

static void addKernelMemorySanitizerPass(const PassManagerBuilder &Builder,
                                         legacy::PassManagerBase &PM) {
  addGeneralOptsForMemorySanitizer(Builder, PM, /*CompileKernel*/ true);
}

static void addThreadSanitizerPass(const PassManagerBuilder &Builder,
                                   legacy::PassManagerBase &PM) {
  PM.add(createThreadSanitizerLegacyPassPass());
}

static void addDataFlowSanitizerPass(const PassManagerBuilder &Builder,
                                     legacy::PassManagerBase &PM) {
  const PassManagerBuilderWrapper &BuilderWrapper =
      static_cast<const PassManagerBuilderWrapper&>(Builder);
  const LangOptions &LangOpts = BuilderWrapper.getLangOpts();
  PM.add(createDataFlowSanitizerPass(LangOpts.SanitizerBlacklistFiles));
}

static void addMemTagOptimizationPasses(const PassManagerBuilder &Builder,
                                        legacy::PassManagerBase &PM) {
  PM.add(createStackSafetyGlobalInfoWrapperPass(/*SetMetadata=*/true));
}

static void addSoftPointerAuthPass(const PassManagerBuilder &Builder,
                                   legacy::PassManagerBase &PM) {
  PM.add(createSoftPointerAuthPass());
}

static TargetLibraryInfoImpl *createTLII(llvm::Triple &TargetTriple,
                                         const CodeGenOptions &CodeGenOpts) {
  TargetLibraryInfoImpl *TLII = new TargetLibraryInfoImpl(TargetTriple);

  switch (CodeGenOpts.getVecLib()) {
  case CodeGenOptions::Accelerate:
    TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::Accelerate);
    break;
  case CodeGenOptions::MASSV:
    TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::MASSV);
    break;
  case CodeGenOptions::SVML:
    TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::SVML);
    break;
  default:
    break;
  }
  return TLII;
}

static void addSymbolRewriterPass(const CodeGenOptions &Opts,
                                  legacy::PassManager *MPM) {
  llvm::SymbolRewriter::RewriteDescriptorList DL;

  llvm::SymbolRewriter::RewriteMapParser MapParser;
  for (const auto &MapFile : Opts.RewriteMapFiles)
    MapParser.parse(MapFile, &DL);

  MPM->add(createRewriteSymbolsPass(DL));
}

static CodeGenOpt::Level getCGOptLevel(const CodeGenOptions &CodeGenOpts) {
  switch (CodeGenOpts.OptimizationLevel) {
  default:
    llvm_unreachable(""Invalid optimization level!"");
  case 0:
    return CodeGenOpt::None;
  case 1:
    return CodeGenOpt::Less;
  case 2:
    return CodeGenOpt::Default; // O2/Os/Oz
  case 3:
    return CodeGenOpt::Aggressive;
  }
}

static Optional<llvm::CodeModel::Model>
getCodeModel(const CodeGenOptions &CodeGenOpts) {
  unsigned CodeModel = llvm::StringSwitch<unsigned>(CodeGenOpts.CodeModel)
                           .Case(""tiny"", llvm::CodeModel::Tiny)
                           .Case(""small"", llvm::CodeModel::Small)
                           .Case(""kernel"", llvm::CodeModel::Kernel)
                           .Case(""medium"", llvm::CodeModel::Medium)
                           .Case(""large"", llvm::CodeModel::Large)
                           .Case(""default"", ~1u)
                           .Default(~0u);
  assert(CodeModel != ~0u && ""invalid code model!"");
  if (CodeModel == ~1u)
    return None;
  return static_cast<llvm::CodeModel::Model>(CodeModel);
}

static CodeGenFileType getCodeGenFileType(BackendAction Action) {
  if (Action == Backend_EmitObj)
    return CGFT_ObjectFile;
  else if (Action == Backend_EmitMCNull)
    return CGFT_Null;
  else {
    assert(Action == Backend_EmitAssembly && ""Invalid action!"");
    return CGFT_AssemblyFile;
  }
}

static void initTargetOptions(llvm::TargetOptions &Options,
                              const CodeGenOptions &CodeGenOpts,
                              const clang::TargetOptions &TargetOpts,
                              const LangOptions &LangOpts,
                              const HeaderSearchOptions &HSOpts) {
  Options.ThreadModel =
      llvm::StringSwitch<llvm::ThreadModel::Model>(CodeGenOpts.ThreadModel)
          .Case(""posix"", llvm::ThreadModel::POSIX)
          .Case(""single"", llvm::ThreadModel::Single);

  // Set float ABI type.
  assert((CodeGenOpts.FloatABI == ""soft"" || CodeGenOpts.FloatABI == ""softfp"" ||
          CodeGenOpts.FloatABI == ""hard"" || CodeGenOpts.FloatABI.empty()) &&
         ""Invalid Floating Point ABI!"");
  Options.FloatABIType =
      llvm::StringSwitch<llvm::FloatABI::ABIType>(CodeGenOpts.FloatABI)
          .Case(""soft"", llvm::FloatABI::Soft)
          .Case(""softfp"", llvm::FloatABI::Soft)
          .Case(""hard"", llvm::FloatABI::Hard)
          .Default(llvm::FloatABI::Default);

  // Set FP fusion mode.
  switch (LangOpts.getDefaultFPContractMode()) {
  case LangOptions::FPC_Off:
    // Preserve any contraction performed by the front-end.  (Strict performs
    // splitting of the muladd intrinsic in the backend.)
    Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
    break;
  case LangOptions::FPC_On:
    Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
    break;
  case LangOptions::FPC_Fast:
    Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
    break;
  }

  Options.UseInitArray = CodeGenOpts.UseInitArray;
  Options.DisableIntegratedAS = CodeGenOpts.DisableIntegratedAS;
  Options.CompressDebugSections = CodeGenOpts.getCompressDebugSections();
  Options.RelaxELFRelocations = CodeGenOpts.RelaxELFRelocations;

  // Set EABI version.
  Options.EABIVersion = TargetOpts.EABIVersion;

  if (LangOpts.SjLjExceptions)
    Options.ExceptionModel = llvm::ExceptionHandling::SjLj;
  if (LangOpts.SEHExceptions)
    Options.ExceptionModel = llvm::ExceptionHandling::WinEH;
  if (LangOpts.DWARFExceptions)
    Options.ExceptionModel = llvm::ExceptionHandling::DwarfCFI;
  if (LangOpts.WasmExceptions)
    Options.ExceptionModel = llvm::ExceptionHandling::Wasm;

  Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
  Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
  Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
  Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
  Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
  Options.FunctionSections = CodeGenOpts.FunctionSections;
  Options.DataSections = CodeGenOpts.DataSections;
  Options.UniqueSectionNames = CodeGenOpts.UniqueSectionNames;
  Options.TLSSize = CodeGenOpts.TLSSize;
  Options.EmulatedTLS = CodeGenOpts.EmulatedTLS;
  Options.ExplicitEmulatedTLS = CodeGenOpts.ExplicitEmulatedTLS;
  Options.DebuggerTuning = CodeGenOpts.getDebuggerTuning();
  Options.EmitStackSizeSection = CodeGenOpts.StackSizeSection;
  Options.EmitAddrsig = CodeGenOpts.Addrsig;
  Options.ForceDwarfFrameSection = CodeGenOpts.ForceDwarfFrameSection;
  Options.EmitCallSiteInfo = CodeGenOpts.EmitCallSiteInfo;

  Options.MCOptions.SplitDwarfFile = CodeGenOpts.SplitDwarfFile;
  Options.MCOptions.MCRelaxAll = CodeGenOpts.RelaxAll;
  Options.MCOptions.MCSaveTempLabels = CodeGenOpts.SaveTempLabels;
  Options.MCOptions.MCUseDwarfDirectory = !CodeGenOpts.NoDwarfDirectoryAsm;
  Options.MCOptions.MCNoExecStack = CodeGenOpts.NoExecStack;
  Options.MCOptions.MCIncrementalLinkerCompatible =
      CodeGenOpts.IncrementalLinkerCompatible;
  Options.MCOptions.MCFatalWarnings = CodeGenOpts.FatalWarnings;
  Options.MCOptions.MCNoWarn = CodeGenOpts.NoWarn;
  Options.MCOptions.AsmVerbose = CodeGenOpts.AsmVerbose;
  Options.MCOptions.PreserveAsmComments = CodeGenOpts.PreserveAsmComments;
  Options.MCOptions.ABIName = TargetOpts.ABI;
  for (const auto &Entry : HSOpts.UserEntries)
    if (!Entry.IsFramework &&
        (Entry.Group == frontend::IncludeDirGroup::Quoted ||
         Entry.Group == frontend::IncludeDirGroup::Angled ||
         Entry.Group == frontend::IncludeDirGroup::System))
      Options.MCOptions.IASSearchPaths.push_back(
          Entry.IgnoreSysRoot ? Entry.Path : HSOpts.Sysroot + Entry.Path);
}
static Optional<GCOVOptions> getGCOVOptions(const CodeGenOptions &CodeGenOpts) {
  if (CodeGenOpts.DisableGCov)
    return None;
  if (!CodeGenOpts.EmitGcovArcs && !CodeGenOpts.EmitGcovNotes)
    return None;
  // Not using 'GCOVOptions::getDefault' allows us to avoid exiting if
  // LLVM's -default-gcov-version flag is set to something invalid.
  GCOVOptions Options;
  Options.EmitNotes = CodeGenOpts.EmitGcovNotes;
  Options.EmitData = CodeGenOpts.EmitGcovArcs;
  llvm::copy(CodeGenOpts.CoverageVersion, std::begin(Options.Version));
  Options.UseCfgChecksum = CodeGenOpts.CoverageExtraChecksum;
  Options.NoRedZone = CodeGenOpts.DisableRedZone;
  Options.FunctionNamesInData = !CodeGenOpts.CoverageNoFunctionNamesInData;
  Options.Filter = CodeGenOpts.ProfileFilterFiles;
  Options.Exclude = CodeGenOpts.ProfileExcludeFiles;
  Options.ExitBlockBeforeBody = CodeGenOpts.CoverageExitBlockBeforeBody;
  return Options;
}

static Optional<InstrProfOptions>
getInstrProfOptions(const CodeGenOptions &CodeGenOpts,
                    const LangOptions &LangOpts) {
  if (!CodeGenOpts.hasProfileClangInstr())
    return None;
  InstrProfOptions Options;
  Options.NoRedZone = CodeGenOpts.DisableRedZone;
  Options.InstrProfileOutput = CodeGenOpts.InstrProfileOutput;

  // TODO: Surface the option to emit atomic profile counter increments at
  // the driver level.
  Options.Atomic = LangOpts.Sanitize.has(SanitizerKind::Thread);
  return Options;
}

void EmitAssemblyHelper::CreatePasses(legacy::PassManager &MPM,
                                      legacy::FunctionPassManager &FPM) {
  // Handle disabling of all LLVM passes, where we want to preserve the
  // internal module before any optimization.
  if (CodeGenOpts.DisableLLVMPasses)
    return;

  // Figure out TargetLibraryInfo.  This needs to be added to MPM and FPM
  // manually (and not via PMBuilder), since some passes (eg. InstrProfiling)
  // are inserted before PMBuilder ones - they'd get the default-constructed
  // TLI with an unknown target otherwise.
  Triple TargetTriple(TheModule->getTargetTriple());
  std::unique_ptr<TargetLibraryInfoImpl> TLII(
      createTLII(TargetTriple, CodeGenOpts));

  // If we reached here with a non-empty index file name, then the index file
  // was empty and we are not performing ThinLTO backend compilation (used in
  // testing in a distributed build environment). Drop any the type test
  // assume sequences inserted for whole program vtables so that codegen doesn't
  // complain.
  if (!CodeGenOpts.ThinLTOIndexFile.empty())
    MPM.add(createLowerTypeTestsPass(/*ExportSummary=*/nullptr,
                                     /*ImportSummary=*/nullptr,
                                     /*DropTypeTests=*/true));

  PassManagerBuilderWrapper PMBuilder(TargetTriple, CodeGenOpts, LangOpts);

  // At O0 and O1 we only run the always inliner which is more efficient. At
  // higher optimization levels we run the normal inliner.
  if (CodeGenOpts.OptimizationLevel <= 1) {
    bool InsertLifetimeIntrinsics = ((CodeGenOpts.OptimizationLevel != 0 &&
                                      !CodeGenOpts.DisableLifetimeMarkers) ||
                                     LangOpts.Coroutines);
    PMBuilder.Inliner = createAlwaysInlinerLegacyPass(InsertLifetimeIntrinsics);
  } else {
    // We do not want to inline hot callsites for SamplePGO module-summary build
    // because profile annotation will happen again in ThinLTO backend, and we
    // want the IR of the hot path to match the profile.
    PMBuilder.Inliner = createFunctionInliningPass(
        CodeGenOpts.OptimizationLevel, CodeGenOpts.OptimizeSize,
        (!CodeGenOpts.SampleProfileFile.empty() &&
         CodeGenOpts.PrepareForThinLTO));
  }

  PMBuilder.OptLevel = CodeGenOpts.OptimizationLevel;
  PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
  PMBuilder.SLPVectorize = CodeGenOpts.VectorizeSLP;
  PMBuilder.LoopVectorize = CodeGenOpts.VectorizeLoop;

  PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
  // Loop interleaving in the loop vectorizer has historically been set to be
  // enabled when loop unrolling is enabled.
  PMBuilder.LoopsInterleaved = CodeGenOpts.UnrollLoops;
  PMBuilder.MergeFunctions = CodeGenOpts.MergeFunctions;
  PMBuilder.SplitColdCode = CodeGenOpts.SplitColdCode;
  PMBuilder.PrepareForThinLTO = CodeGenOpts.PrepareForThinLTO;
  PMBuilder.PrepareForLTO = CodeGenOpts.PrepareForLTO;
  PMBuilder.RerollLoops = CodeGenOpts.RerollLoops;

  MPM.add(new TargetLibraryInfoWrapperPass(*TLII));

  if (TM)
    TM->adjustPassManager(PMBuilder);

  if (CodeGenOpts.DebugInfoForProfiling ||
      !CodeGenOpts.SampleProfileFile.empty())
    PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
                           addAddDiscriminatorsPass);

  // In ObjC ARC mode, add the main ARC optimization passes.
  if (LangOpts.ObjCAutoRefCount) {
    PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
                           addObjCARCExpandPass);
    PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
                           addObjCARCAPElimPass);
    PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
                           addObjCARCOptPass);
  }

  if (LangOpts.Coroutines)
    addCoroutinePassesToExtensionPoints(PMBuilder);

  if (LangOpts.Sanitize.has(SanitizerKind::LocalBounds)) {
    PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
                           addBoundsCheckingPass);
    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
                           addBoundsCheckingPass);
  }

  if (CodeGenOpts.SanitizeCoverageType ||
      CodeGenOpts.SanitizeCoverageIndirectCalls ||
      CodeGenOpts.SanitizeCoverageTraceCmp) {
    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
                           addSanitizerCoveragePass);
    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
                           addSanitizerCoveragePass);
  }

  if (LangOpts.Sanitize.has(SanitizerKind::Address)) {
    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
                           addAddressSanitizerPasses);
    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
                           addAddressSanitizerPasses);
  }

  if (LangOpts.Sanitize.has(SanitizerKind::KernelAddress)) {
    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
                           addKernelAddressSanitizerPasses);
    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
                           addKernelAddressSanitizerPasses);
  }

  if (LangOpts.Sanitize.has(SanitizerKind::HWAddress)) {
    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
                           addHWAddressSanitizerPasses);
    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
                           addHWAddressSanitizerPasses);
  }

  if (LangOpts.Sanitize.has(SanitizerKind::KernelHWAddress)) {
    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
                           addKernelHWAddressSanitizerPasses);
    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
                           addKernelHWAddressSanitizerPasses);
  }

  if (LangOpts.Sanitize.has(SanitizerKind::Memory)) {
    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
                           addMemorySanitizerPass);
    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
                           addMemorySanitizerPass);
  }

  if (LangOpts.Sanitize.has(SanitizerKind::KernelMemory)) {
    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
                           addKernelMemorySanitizerPass);
    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
                           addKernelMemorySanitizerPass);
  }

  if (LangOpts.Sanitize.has(SanitizerKind::Thread)) {
    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
                           addThreadSanitizerPass);
    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
                           addThreadSanitizerPass);
  }

  if (LangOpts.Sanitize.has(SanitizerKind::DataFlow)) {
    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
                           addDataFlowSanitizerPass);
    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
                           addDataFlowSanitizerPass);
  }

  if (LangOpts.Sanitize.has(SanitizerKind::MemTag)) {
    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
                           addMemTagOptimizationPasses);
  }

  if (LangOpts.SoftPointerAuth) {
    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
                           addSoftPointerAuthPass);
    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
                           addSoftPointerAuthPass);
  }

  // Set up the per-function pass manager.
  FPM.add(new TargetLibraryInfoWrapperPass(*TLII));
  if (CodeGenOpts.VerifyModule)
    FPM.add(createVerifierPass());

  // Set up the per-module pass manager.
  if (!CodeGenOpts.RewriteMapFiles.empty())
    addSymbolRewriterPass(CodeGenOpts, &MPM);

  if (Optional<GCOVOptions> Options = getGCOVOptions(CodeGenOpts)) {
    MPM.add(createGCOVProfilerPass(*Options));
    if (CodeGenOpts.getDebugInfo() == codegenoptions::NoDebugInfo)
      MPM.add(createStripSymbolsPass(true));
  }

  if (Optional<InstrProfOptions> Options =
          getInstrProfOptions(CodeGenOpts, LangOpts))
    MPM.add(createInstrProfilingLegacyPass(*Options, false));

  bool hasIRInstr = false;
  if (CodeGenOpts.hasProfileIRInstr()) {
    PMBuilder.EnablePGOInstrGen = true;
    hasIRInstr = true;
  }
  if (CodeGenOpts.hasProfileCSIRInstr()) {
    assert(!CodeGenOpts.hasProfileCSIRUse() &&
           ""Cannot have both CSProfileUse pass and CSProfileGen pass at the ""
           ""same time"");
    assert(!hasIRInstr &&
           ""Cannot have both ProfileGen pass and CSProfileGen pass at the ""
           ""same time"");
    PMBuilder.EnablePGOCSInstrGen = true;
    hasIRInstr = true;
  }
  if (hasIRInstr) {
    if (!CodeGenOpts.InstrProfileOutput.empty())
      PMBuilder.PGOInstrGen = CodeGenOpts.InstrProfileOutput;
    else
      PMBuilder.PGOInstrGen = std::string(DefaultProfileGenName);
  }
  if (CodeGenOpts.hasProfileIRUse()) {
    PMBuilder.PGOInstrUse = CodeGenOpts.ProfileInstrumentUsePath;
    PMBuilder.EnablePGOCSInstrUse = CodeGenOpts.hasProfileCSIRUse();
  }

  if (!CodeGenOpts.SampleProfileFile.empty())
    PMBuilder.PGOSampleUse = CodeGenOpts.SampleProfileFile;

  PMBuilder.populateFunctionPassManager(FPM);
  PMBuilder.populateModulePassManager(MPM);
}

static void setCommandLineOpts(const CodeGenOptions &CodeGenOpts) {
  SmallVector<const char *, 16> BackendArgs;
  BackendArgs.push_back(""clang""); // Fake program name.
  if (!CodeGenOpts.DebugPass.empty()) {
    BackendArgs.push_back(""-debug-pass"");
    BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
  }
  if (!CodeGenOpts.LimitFloatPrecision.empty()) {
    BackendArgs.push_back(""-limit-float-precision"");
    BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
  }
  BackendArgs.push_back(nullptr);
  llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
                                    BackendArgs.data());
}

void EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
  // Create the TargetMachine for generating code.
  std::string Error;
  std::string Triple = TheModule->getTargetTriple();
  const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
  if (!TheTarget) {
    if (MustCreateTM)
      Diags.Report(diag::err_fe_unable_to_create_target) << Error;
    return;
  }

  Optional<llvm::CodeModel::Model> CM = getCodeModel(CodeGenOpts);
  std::string FeaturesStr =
      llvm::join(TargetOpts.Features.begin(), TargetOpts.Features.end(), "","");
  llvm::Reloc::Model RM = CodeGenOpts.RelocationModel;
  CodeGenOpt::Level OptLevel = getCGOptLevel(CodeGenOpts);

  llvm::TargetOptions Options;
  initTargetOptions(Options, CodeGenOpts, TargetOpts, LangOpts, HSOpts);
  TM.reset(TheTarget->createTargetMachine(Triple, TargetOpts.CPU, FeaturesStr,
                                          Options, RM, CM, OptLevel));
}

bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,
                                       BackendAction Action,
                                       raw_pwrite_stream &OS,
                                       raw_pwrite_stream *DwoOS) {
  // Add LibraryInfo.
  llvm::Triple TargetTriple(TheModule->getTargetTriple());
  std::unique_ptr<TargetLibraryInfoImpl> TLII(
      createTLII(TargetTriple, CodeGenOpts));
  CodeGenPasses.add(new TargetLibraryInfoWrapperPass(*TLII));

  // Normal mode, emit a .s or .o file by running the code generator. Note,
  // this also adds codegenerator level optimization passes.
  CodeGenFileType CGFT = getCodeGenFileType(Action);

  // Add ObjC ARC final-cleanup optimizations. This is done as part of the
  // ""codegen"" passes so that it isn't run multiple times when there is
  // inlining happening.
  if (CodeGenOpts.OptimizationLevel > 0)
    CodeGenPasses.add(createObjCARCContractPass());

  if (TM->addPassesToEmitFile(CodeGenPasses, OS, DwoOS, CGFT,
                              /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
    Diags.Report(diag::err_fe_unable_to_interface_with_target);
    return false;
  }

  return true;
}

void EmitAssemblyHelper::EmitAssembly(BackendAction Action,
                                      std::unique_ptr<raw_pwrite_stream> OS) {
  TimeRegion Region(FrontendTimesIsEnabled ? &CodeGenerationTime : nullptr);

  setCommandLineOpts(CodeGenOpts);

  bool UsesCodeGen = (Action != Backend_EmitNothing &&
                      Action != Backend_EmitBC &&
                      Action != Backend_EmitLL);
  CreateTargetMachine(UsesCodeGen);

  if (UsesCodeGen && !TM)
    return;
  if (TM)
    TheModule->setDataLayout(TM->createDataLayout());

  legacy::PassManager PerModulePasses;
  PerModulePasses.add(
      createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));

  legacy::FunctionPassManager PerFunctionPasses(TheModule);
  PerFunctionPasses.add(
      createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));

  CreatePasses(PerModulePasses, PerFunctionPasses);

  legacy::PassManager CodeGenPasses;
  CodeGenPasses.add(
      createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));

  std::unique_ptr<llvm::ToolOutputFile> ThinLinkOS, DwoOS;

  switch (Action) {
  case Backend_EmitNothing:
    break;

  case Backend_EmitBC:
    if (CodeGenOpts.PrepareForThinLTO && !CodeGenOpts.DisableLLVMPasses) {
      if (!CodeGenOpts.ThinLinkBitcodeFile.empty()) {
        ThinLinkOS = openOutputFile(CodeGenOpts.ThinLinkBitcodeFile);
        if (!ThinLinkOS)
          return;
      }
      TheModule->addModuleFlag(Module::Error, ""EnableSplitLTOUnit"",
                               CodeGenOpts.EnableSplitLTOUnit);
      PerModulePasses.add(createWriteThinLTOBitcodePass(
          *OS, ThinLinkOS ? &ThinLinkOS->os() : nullptr));
    } else {
      // Emit a module summary by default for Regular LTO except for ld64
      // targets
      bool EmitLTOSummary =
          (CodeGenOpts.PrepareForLTO &&
           !CodeGenOpts.DisableLLVMPasses &&
           llvm::Triple(TheModule->getTargetTriple()).getVendor() !=
               llvm::Triple::Apple);
      if (EmitLTOSummary) {
        if (!TheModule->getModuleFlag(""ThinLTO""))
          TheModule->addModuleFlag(Module::Error, ""ThinLTO"", uint32_t(0));
        TheModule->addModuleFlag(Module::Error, ""EnableSplitLTOUnit"",
                                 uint32_t(1));
      }

      PerModulePasses.add(createBitcodeWriterPass(
          *OS, CodeGenOpts.EmitLLVMUseLists, EmitLTOSummary));
    }
    break;

  case Backend_EmitLL:
    PerModulePasses.add(
        createPrintModulePass(*OS, """", CodeGenOpts.EmitLLVMUseLists));
    break;

  default:
    if (!CodeGenOpts.SplitDwarfOutput.empty()) {
      DwoOS = openOutputFile(CodeGenOpts.SplitDwarfOutput);
      if (!DwoOS)
        return;
    }
    if (!AddEmitPasses(CodeGenPasses, Action, *OS,
                       DwoOS ? &DwoOS->os() : nullptr))
      return;
  }

  // Before executing passes, print the final values of the LLVM options.
  cl::PrintOptionValues();

  // Run passes. For now we do all passes at once, but eventually we
  // would like to have the option of streaming code generation.

  {
    PrettyStackTraceString CrashInfo(""Per-function optimization"");
    llvm::TimeTraceScope TimeScope(""PerFunctionPasses"");

    PerFunctionPasses.doInitialization();
    for (Function &F : *TheModule)
      if (!F.isDeclaration())
        PerFunctionPasses.run(F);
    PerFunctionPasses.doFinalization();
  }

  {
    PrettyStackTraceString CrashInfo(""Per-module optimization passes"");
    llvm::TimeTraceScope TimeScope(""PerModulePasses"");
    PerModulePasses.run(*TheModule);
  }

  {
    PrettyStackTraceString CrashInfo(""Code generation"");
    llvm::TimeTraceScope TimeScope(""CodeGenPasses"");
    CodeGenPasses.run(*TheModule);
  }

  if (ThinLinkOS)
    ThinLinkOS->keep();
  if (DwoOS)
    DwoOS->keep();
}

static PassBuilder::OptimizationLevel mapToLevel(const CodeGenOptions &Opts) {
  switch (Opts.OptimizationLevel) {
  default:
    llvm_unreachable(""Invalid optimization level!"");

  case 1:
    return PassBuilder::OptimizationLevel::O1;

  case 2:
    switch (Opts.OptimizeSize) {
    default:
      llvm_unreachable(""Invalid optimization level for size!"");

    case 0:
      return PassBuilder::OptimizationLevel::O2;

    case 1:
      return PassBuilder::OptimizationLevel::Os;

    case 2:
      return PassBuilder::OptimizationLevel::Oz;
    }

  case 3:
    return PassBuilder::OptimizationLevel::O3;
  }
}

static void addCoroutinePassesAtO0(ModulePassManager &MPM,
                                   const LangOptions &LangOpts,
                                   const CodeGenOptions &CodeGenOpts) {
  if (!LangOpts.Coroutines)
    return;

  MPM.addPass(createModuleToFunctionPassAdaptor(CoroEarlyPass()));

  CGSCCPassManager CGPM(CodeGenOpts.DebugPassManager);
  CGPM.addPass(CoroSplitPass());
  CGPM.addPass(createCGSCCToFunctionPassAdaptor(CoroElidePass()));
  MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));

  MPM.addPass(createModuleToFunctionPassAdaptor(CoroCleanupPass()));
}

static void addSanitizersAtO0(ModulePassManager &MPM,
                              const Triple &TargetTriple,
                              const LangOptions &LangOpts,
                              const CodeGenOptions &CodeGenOpts) {
  auto ASanPass = [&](SanitizerMask Mask, bool CompileKernel) {
    MPM.addPass(RequireAnalysisPass<ASanGlobalsMetadataAnalysis, Module>());
    bool Recover = CodeGenOpts.SanitizeRecover.has(Mask);
    MPM.addPass(createModuleToFunctionPassAdaptor(AddressSanitizerPass(
        CompileKernel, Recover, CodeGenOpts.SanitizeAddressUseAfterScope)));
    bool ModuleUseAfterScope = asanUseGlobalsGC(TargetTriple, CodeGenOpts);
    MPM.addPass(
        ModuleAddressSanitizerPass(CompileKernel, Recover, ModuleUseAfterScope,
                                   CodeGenOpts.SanitizeAddressUseOdrIndicator));
  };

  if (LangOpts.Sanitize.has(SanitizerKind::Address)) {
    ASanPass(SanitizerKind::Address, /*CompileKernel=*/false);
  }

  if (LangOpts.Sanitize.has(SanitizerKind::KernelAddress)) {
    ASanPass(SanitizerKind::KernelAddress, /*CompileKernel=*/true);
  }

  if (LangOpts.Sanitize.has(SanitizerKind::Memory)) {
    MPM.addPass(MemorySanitizerPass({}));
    MPM.addPass(createModuleToFunctionPassAdaptor(MemorySanitizerPass({})));
  }

  if (LangOpts.Sanitize.has(SanitizerKind::KernelMemory)) {
    MPM.addPass(createModuleToFunctionPassAdaptor(
        MemorySanitizerPass({0, false, /*Kernel=*/true})));
  }

  if (LangOpts.Sanitize.has(SanitizerKind::Thread)) {
    MPM.addPass(ThreadSanitizerPass());
    MPM.addPass(createModuleToFunctionPassAdaptor(ThreadSanitizerPass()));
  }
}

/// A clean version of `EmitAssembly` that uses the new pass manager.
///
/// Not all features are currently supported in this system, but where
/// necessary it falls back to the legacy pass manager to at least provide
/// basic functionality.
///
/// This API is planned to have its functionality finished and then to replace
/// `EmitAssembly` at some point in the future when the default switches.
void EmitAssemblyHelper::EmitAssemblyWithNewPassManager(
    BackendAction Action, std::unique_ptr<raw_pwrite_stream> OS) {
  TimeRegion Region(FrontendTimesIsEnabled ? &CodeGenerationTime : nullptr);
  setCommandLineOpts(CodeGenOpts);

  bool RequiresCodeGen = (Action != Backend_EmitNothing &&
                          Action != Backend_EmitBC &&
                          Action != Backend_EmitLL);
  CreateTargetMachine(RequiresCodeGen);

  if (RequiresCodeGen && !TM)
    return;
  if (TM)
    TheModule->setDataLayout(TM->createDataLayout());

  Optional<PGOOptions> PGOOpt;

  if (CodeGenOpts.hasProfileIRInstr())
    // -fprofile-generate.
    PGOOpt = PGOOptions(CodeGenOpts.InstrProfileOutput.empty()
                            ? std::string(DefaultProfileGenName)
                            : CodeGenOpts.InstrProfileOutput,
                        """", """", PGOOptions::IRInstr, PGOOptions::NoCSAction,
                        CodeGenOpts.DebugInfoForProfiling);
  else if (CodeGenOpts.hasProfileIRUse()) {
    // -fprofile-use.
    auto CSAction = CodeGenOpts.hasProfileCSIRUse() ? PGOOptions::CSIRUse
                                                    : PGOOptions::NoCSAction;
    PGOOpt = PGOOptions(CodeGenOpts.ProfileInstrumentUsePath, """",
                        CodeGenOpts.ProfileRemappingFile, PGOOptions::IRUse,
                        CSAction, CodeGenOpts.DebugInfoForProfiling);
  } else if (!CodeGenOpts.SampleProfileFile.empty())
    // -fprofile-sample-use
    PGOOpt =
        PGOOptions(CodeGenOpts.SampleProfileFile, """",
                   CodeGenOpts.ProfileRemappingFile, PGOOptions::SampleUse,
                   PGOOptions::NoCSAction, CodeGenOpts.DebugInfoForProfiling);
  else if (CodeGenOpts.DebugInfoForProfiling)
    // -fdebug-info-for-profiling
    PGOOpt = PGOOptions("""", """", """", PGOOptions::NoAction,
                        PGOOptions::NoCSAction, true);

  // Check to see if we want to generate a CS profile.
  if (CodeGenOpts.hasProfileCSIRInstr()) {
    assert(!CodeGenOpts.hasProfileCSIRUse() &&
           ""Cannot have both CSProfileUse pass and CSProfileGen pass at ""
           ""the same time"");
    if (PGOOpt.hasValue()) {
      assert(PGOOpt->Action != PGOOptions::IRInstr &&
             PGOOpt->Action != PGOOptions::SampleUse &&
             ""Cannot run CSProfileGen pass with ProfileGen or SampleUse ""
             "" pass"");
      PGOOpt->CSProfileGenFile = CodeGenOpts.InstrProfileOutput.empty()
                                     ? std::string(DefaultProfileGenName)
                                     : CodeGenOpts.InstrProfileOutput;
      PGOOpt->CSAction = PGOOptions::CSIRInstr;
    } else
      PGOOpt = PGOOptions("""",
                          CodeGenOpts.InstrProfileOutput.empty()
                              ? std::string(DefaultProfileGenName)
                              : CodeGenOpts.InstrProfileOutput,
                          """", PGOOptions::NoAction, PGOOptions::CSIRInstr,
                          CodeGenOpts.DebugInfoForProfiling);
  }

  PipelineTuningOptions PTO;
  PTO.LoopUnrolling = CodeGenOpts.UnrollLoops;
  // For historical reasons, loop interleaving is set to mirror setting for loop
  // unrolling.
  PTO.LoopInterleaving = CodeGenOpts.UnrollLoops;
  PTO.LoopVectorization = CodeGenOpts.VectorizeLoop;
  PTO.SLPVectorization = CodeGenOpts.VectorizeSLP;
  PTO.Coroutines = LangOpts.Coroutines;

  PassInstrumentationCallbacks PIC;
  StandardInstrumentations SI;
  SI.registerCallbacks(PIC);
  PassBuilder PB(TM.get(), PTO, PGOOpt, &PIC);

  // Attempt to load pass plugins and register their callbacks with PB.
  for (auto &PluginFN : CodeGenOpts.PassPlugins) {
    auto PassPlugin = PassPlugin::Load(PluginFN);
    if (PassPlugin) {
      PassPlugin->registerPassBuilderCallbacks(PB);
    } else {
      Diags.Report(diag::err_fe_unable_to_load_plugin)
          << PluginFN << toString(PassPlugin.takeError());
    }
  }
#define HANDLE_EXTENSION(Ext)                                                  \\
  get##Ext##PluginInfo().RegisterPassBuilderCallbacks(PB);
#include ""llvm/Support/Extension.def""

  LoopAnalysisManager LAM(CodeGenOpts.DebugPassManager);
  FunctionAnalysisManager FAM(CodeGenOpts.DebugPassManager);
  CGSCCAnalysisManager CGAM(CodeGenOpts.DebugPassManager);
  ModuleAnalysisManager MAM(CodeGenOpts.DebugPassManager);

  // Register the AA manager first so that our version is the one used.
  FAM.registerPass([&] { return PB.buildDefaultAAPipeline(); });

  // Register the target library analysis directly and give it a customized
  // preset TLI.
  Triple TargetTriple(TheModule->getTargetTriple());
  std::unique_ptr<TargetLibraryInfoImpl> TLII(
      createTLII(TargetTriple, CodeGenOpts));
  FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });

  // Register all the basic analyses with the managers.
  PB.registerModuleAnalyses(MAM);
  PB.registerCGSCCAnalyses(CGAM);
  PB.registerFunctionAnalyses(FAM);
  PB.registerLoopAnalyses(LAM);
  PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);

  ModulePassManager MPM(CodeGenOpts.DebugPassManager);

  if (!CodeGenOpts.DisableLLVMPasses) {
    bool IsThinLTO = CodeGenOpts.PrepareForThinLTO;
    bool IsLTO = CodeGenOpts.PrepareForLTO;

    if (CodeGenOpts.OptimizationLevel == 0) {
      // If we reached here with a non-empty index file name, then the index
      // file was empty and we are not performing ThinLTO backend compilation
      // (used in testing in a distributed build environment). Drop any the type
      // test assume sequences inserted for whole program vtables so that
      // codegen doesn't complain.
      if (!CodeGenOpts.ThinLTOIndexFile.empty())
        MPM.addPass(LowerTypeTestsPass(/*ExportSummary=*/nullptr,
                                       /*ImportSummary=*/nullptr,
                                       /*DropTypeTests=*/true));
      if (Optional<GCOVOptions> Options = getGCOVOptions(CodeGenOpts))
        MPM.addPass(GCOVProfilerPass(*Options));
      if (Optional<InstrProfOptions> Options =
              getInstrProfOptions(CodeGenOpts, LangOpts))
        MPM.addPass(InstrProfiling(*Options, false));

      // Build a minimal pipeline based on the semantics required by Clang,
      // which is just that always inlining occurs. Further, disable generating
      // lifetime intrinsics to avoid enabling further optimizations during
      // code generation.
      // However, we need to insert lifetime intrinsics to avoid invalid access
      // caused by multithreaded coroutines.
      MPM.addPass(
          AlwaysInlinerPass(/*InsertLifetimeIntrinsics=*/LangOpts.Coroutines));

      // At -O0, we can still do PGO. Add all the requested passes for
      // instrumentation PGO, if requested.
      if (PGOOpt && (PGOOpt->Action == PGOOptions::IRInstr ||
                     PGOOpt->Action == PGOOptions::IRUse))
        PB.addPGOInstrPassesForO0(
            MPM, CodeGenOpts.DebugPassManager,
            /* RunProfileGen */ (PGOOpt->Action == PGOOptions::IRInstr),
            /* IsCS */ false, PGOOpt->ProfileFile,
            PGOOpt->ProfileRemappingFile);

      // At -O0 we directly run necessary sanitizer passes.
      if (LangOpts.Sanitize.has(SanitizerKind::LocalBounds))
        MPM.addPass(createModuleToFunctionPassAdaptor(BoundsCheckingPass()));

      // Lastly, add semantically necessary passes for LTO.
      if (IsLTO || IsThinLTO) {
        MPM.addPass(CanonicalizeAliasesPass());
        MPM.addPass(NameAnonGlobalPass());
      }
    } else {
      // Map our optimization levels into one of the distinct levels used to
      // configure the pipeline.
      PassBuilder::OptimizationLevel Level = mapToLevel(CodeGenOpts);

      // -f[no-]split-cold-code
      PB.setEnableHotColdSplitting(CodeGenOpts.SplitColdCode);

      // If we reached here with a non-empty index file name, then the index
      // file was empty and we are not performing ThinLTO backend compilation
      // (used in testing in a distributed build environment). Drop any the type
      // test assume sequences inserted for whole program vtables so that
      // codegen doesn't complain.
      if (!CodeGenOpts.ThinLTOIndexFile.empty())
        PB.registerPipelineStartEPCallback([](ModulePassManager &MPM) {
          MPM.addPass(LowerTypeTestsPass(/*ExportSummary=*/nullptr,
                                         /*ImportSummary=*/nullptr,
                                         /*DropTypeTests=*/true));
        });

      PB.registerPipelineStartEPCallback([](ModulePassManager &MPM) {
        MPM.addPass(createModuleToFunctionPassAdaptor(
            EntryExitInstrumenterPass(/*PostInlining=*/false)));
      });

      // Register callbacks to schedule sanitizer passes at the appropriate part of
      // the pipeline.
      // FIXME: either handle asan/the remaining sanitizers or error out
      if (LangOpts.Sanitize.has(SanitizerKind::LocalBounds))
        PB.registerScalarOptimizerLateEPCallback(
            [](FunctionPassManager &FPM, PassBuilder::OptimizationLevel Level) {
              FPM.addPass(BoundsCheckingPass());
            });
      if (LangOpts.Sanitize.has(SanitizerKind::Memory)) {
        PB.registerPipelineStartEPCallback([](ModulePassManager &MPM) {
          MPM.addPass(MemorySanitizerPass({}));
        });
        PB.registerOptimizerLastEPCallback(
            [](FunctionPassManager &FPM, PassBuilder::OptimizationLevel Level) {
              FPM.addPass(MemorySanitizerPass({}));
            });
      }
      if (LangOpts.Sanitize.has(SanitizerKind::Thread)) {
        PB.registerPipelineStartEPCallback(
            [](ModulePassManager &MPM) { MPM.addPass(ThreadSanitizerPass()); });
        PB.registerOptimizerLastEPCallback(
            [](FunctionPassManager &FPM, PassBuilder::OptimizationLevel Level) {
              FPM.addPass(ThreadSanitizerPass());
            });
      }
      if (LangOpts.Sanitize.has(SanitizerKind::Address)) {
        PB.registerPipelineStartEPCallback([&](ModulePassManager &MPM) {
          MPM.addPass(
              RequireAnalysisPass<ASanGlobalsMetadataAnalysis, Module>());
        });
        bool Recover = CodeGenOpts.SanitizeRecover.has(SanitizerKind::Address);
        bool UseAfterScope = CodeGenOpts.SanitizeAddressUseAfterScope;
        PB.registerOptimizerLastEPCallback(
            [Recover, UseAfterScope](FunctionPassManager &FPM,
                                     PassBuilder::OptimizationLevel Level) {
              FPM.addPass(AddressSanitizerPass(
                  /*CompileKernel=*/false, Recover, UseAfterScope));
            });
        bool ModuleUseAfterScope = asanUseGlobalsGC(TargetTriple, CodeGenOpts);
        bool UseOdrIndicator = CodeGenOpts.SanitizeAddressUseOdrIndicator;
        PB.registerPipelineStartEPCallback(
            [Recover, ModuleUseAfterScope,
             UseOdrIndicator](ModulePassManager &MPM) {
              MPM.addPass(ModuleAddressSanitizerPass(
                  /*CompileKernel=*/false, Recover, ModuleUseAfterScope,
                  UseOdrIndicator));
            });
      }
      if (Optional<GCOVOptions> Options = getGCOVOptions(CodeGenOpts))
        PB.registerPipelineStartEPCallback([Options](ModulePassManager &MPM) {
          MPM.addPass(GCOVProfilerPass(*Options));
        });
      if (Optional<InstrProfOptions> Options =
              getInstrProfOptions(CodeGenOpts, LangOpts))
        PB.registerPipelineStartEPCallback([Options](ModulePassManager &MPM) {
          MPM.addPass(InstrProfiling(*Options, false));
        });

      if (IsThinLTO) {
        MPM = PB.buildThinLTOPreLinkDefaultPipeline(
            Level, CodeGenOpts.DebugPassManager);
        MPM.addPass(CanonicalizeAliasesPass());
        MPM.addPass(NameAnonGlobalPass());
      } else if (IsLTO) {
        MPM = PB.buildLTOPreLinkDefaultPipeline(Level,
                                                CodeGenOpts.DebugPassManager);
        MPM.addPass(CanonicalizeAliasesPass());
        MPM.addPass(NameAnonGlobalPass());
      } else {
        MPM = PB.buildPerModuleDefaultPipeline(Level,
                                               CodeGenOpts.DebugPassManager);
      }
    }

    if (CodeGenOpts.SanitizeCoverageType ||
        CodeGenOpts.SanitizeCoverageIndirectCalls ||
        CodeGenOpts.SanitizeCoverageTraceCmp) {
      auto SancovOpts = getSancovOptsFromCGOpts(CodeGenOpts);
      MPM.addPass(ModuleSanitizerCoveragePass(SancovOpts));
    }

    if (LangOpts.Sanitize.has(SanitizerKind::HWAddress)) {
      bool Recover = CodeGenOpts.SanitizeRecover.has(SanitizerKind::HWAddress);
      MPM.addPass(HWAddressSanitizerPass(
          /*CompileKernel=*/false, Recover));
    }
    if (LangOpts.Sanitize.has(SanitizerKind::KernelHWAddress)) {
      MPM.addPass(HWAddressSanitizerPass(
          /*CompileKernel=*/true, /*Recover=*/true));
    }

    if (CodeGenOpts.OptimizationLevel > 0 &&
        LangOpts.Sanitize.has(SanitizerKind::MemTag)) {
      MPM.addPass(StackSafetyGlobalAnnotatorPass());
    }

    if (CodeGenOpts.OptimizationLevel == 0) {
      addCoroutinePassesAtO0(MPM, LangOpts, CodeGenOpts);
      addSanitizersAtO0(MPM, TargetTriple, LangOpts, CodeGenOpts);
    }
  }

  // FIXME: We still use the legacy pass manager to do code generation. We
  // create that pass manager here and use it as needed below.
  legacy::PassManager CodeGenPasses;
  bool NeedCodeGen = false;
  std::unique_ptr<llvm::ToolOutputFile> ThinLinkOS, DwoOS;

  // Append any output we need to the pass manager.
  switch (Action) {
  case Backend_EmitNothing:
    break;

  case Backend_EmitBC:
    if (CodeGenOpts.PrepareForThinLTO && !CodeGenOpts.DisableLLVMPasses) {
      if (!CodeGenOpts.ThinLinkBitcodeFile.empty()) {
        ThinLinkOS = openOutputFile(CodeGenOpts.ThinLinkBitcodeFile);
        if (!ThinLinkOS)
          return;
      }
      TheModule->addModuleFlag(Module::Error, ""EnableSplitLTOUnit"",
                               CodeGenOpts.EnableSplitLTOUnit);
      MPM.addPass(ThinLTOBitcodeWriterPass(*OS, ThinLinkOS ? &ThinLinkOS->os()
                                                           : nullptr));
    } else {
      // Emit a module summary by default for Regular LTO except for ld64
      // targets
      bool EmitLTOSummary =
          (CodeGenOpts.PrepareForLTO &&
           !CodeGenOpts.DisableLLVMPasses &&
           llvm::Triple(TheModule->getTargetTriple()).getVendor() !=
               llvm::Triple::Apple);
      if (EmitLTOSummary) {
        if (!TheModule->getModuleFlag(""ThinLTO""))
          TheModule->addModuleFlag(Module::Error, ""ThinLTO"", uint32_t(0));
        TheModule->addModuleFlag(Module::Error, ""EnableSplitLTOUnit"",
                                 uint32_t(1));
      }
      MPM.addPass(
          BitcodeWriterPass(*OS, CodeGenOpts.EmitLLVMUseLists, EmitLTOSummary));
    }
    break;

  case Backend_EmitLL:
    MPM.addPass(PrintModulePass(*OS, """", CodeGenOpts.EmitLLVMUseLists));
    break;

  case Backend_EmitAssembly:
  case Backend_EmitMCNull:
  case Backend_EmitObj:
    NeedCodeGen = true;
    CodeGenPasses.add(
        createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
    if (!CodeGenOpts.SplitDwarfOutput.empty()) {
      DwoOS = openOutputFile(CodeGenOpts.SplitDwarfOutput);
      if (!DwoOS)
        return;
    }
    if (!AddEmitPasses(CodeGenPasses, Action, *OS,
                       DwoOS ? &DwoOS->os() : nullptr))
      // FIXME: Should we handle this error differently?
      return;
    break;
  }

  // Before executing passes, print the final values of the LLVM options.
  cl::PrintOptionValues();

  // Now that we have all of the passes ready, run them.
  {
    PrettyStackTraceString CrashInfo(""Optimizer"");
    MPM.run(*TheModule, MAM);
  }

  // Now if needed, run the legacy PM for codegen.
  if (NeedCodeGen) {
    PrettyStackTraceString CrashInfo(""Code generation"");
    CodeGenPasses.run(*TheModule);
  }

  if (ThinLinkOS)
    ThinLinkOS->keep();
  if (DwoOS)
    DwoOS->keep();
}

Expected<BitcodeModule> clang::FindThinLTOModule(MemoryBufferRef MBRef) {
  Expected<std::vector<BitcodeModule>> BMsOrErr = getBitcodeModuleList(MBRef);
  if (!BMsOrErr)
    return BMsOrErr.takeError();

  // The bitcode file may contain multiple modules, we want the one that is
  // marked as being the ThinLTO module.
  if (const BitcodeModule *Bm = FindThinLTOModule(*BMsOrErr))
    return *Bm;

  return make_error<StringError>(""Could not find module summary"",
                                 inconvertibleErrorCode());
}

BitcodeModule *clang::FindThinLTOModule(MutableArrayRef<BitcodeModule> BMs) {
  for (BitcodeModule &BM : BMs) {
    Expected<BitcodeLTOInfo> LTOInfo = BM.getLTOInfo();
    if (LTOInfo && LTOInfo->IsThinLTO)
      return &BM;
  }
  return nullptr;
}

static void runThinLTOBackend(ModuleSummaryIndex *CombinedIndex, Module *M,
                              const HeaderSearchOptions &HeaderOpts,
                              const CodeGenOptions &CGOpts,
                              const clang::TargetOptions &TOpts,
                              const LangOptions &LOpts,
                              std::unique_ptr<raw_pwrite_stream> OS,
                              std::string SampleProfile,
                              std::string ProfileRemapping,
                              BackendAction Action) {
  StringMap<DenseMap<GlobalValue::GUID, GlobalValueSummary *>>
      ModuleToDefinedGVSummaries;
  CombinedIndex->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);

  setCommandLineOpts(CGOpts);

  // We can simply import the values mentioned in the combined index, since
  // we should only invoke this using the individual indexes written out
  // via a WriteIndexesThinBackend.
  FunctionImporter::ImportMapTy ImportList;
  for (auto &GlobalList : *CombinedIndex) {
    // Ignore entries for undefined references.
    if (GlobalList.second.SummaryList.empty())
      continue;

    auto GUID = GlobalList.first;
    for (auto &Summary : GlobalList.second.SummaryList) {
      // Skip the summaries for the importing module. These are included to
      // e.g. record required linkage changes.
      if (Summary->modulePath() == M->getModuleIdentifier())
        continue;
      // Add an entry to provoke importing by thinBackend.
      ImportList[Summary->modulePath()].insert(GUID);
    }
  }

  std::vector<std::unique_ptr<llvm::MemoryBuffer>> OwnedImports;
  MapVector<llvm::StringRef, llvm::BitcodeModule> ModuleMap;

  for (auto &I : ImportList) {
    ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MBOrErr =
        llvm::MemoryBuffer::getFile(I.first());
    if (!MBOrErr) {
      errs() << ""Error loading imported file '"" << I.first()
             << ""': "" << MBOrErr.getError().message() << ""\\n"";
      return;
    }

    Expected<BitcodeModule> BMOrErr = FindThinLTOModule(**MBOrErr);
    if (!BMOrErr) {
      handleAllErrors(BMOrErr.takeError(), [&](ErrorInfoBase &EIB) {
        errs() << ""Error loading imported file '"" << I.first()
               << ""': "" << EIB.message() << '\\n';
      });
      return;
    }
    ModuleMap.insert({I.first(), *BMOrErr});

    OwnedImports.push_back(std::move(*MBOrErr));
  }
  auto AddStream = [&](size_t Task) {
    return std::make_unique<lto::NativeObjectStream>(std::move(OS));
  };
  lto::Config Conf;
  if (CGOpts.SaveTempsFilePrefix != """") {
    if (Error E = Conf.addSaveTemps(CGOpts.SaveTempsFilePrefix + ""."",
                                    /* UseInputModulePath */ false)) {
      handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
        errs() << ""Error setting up ThinLTO save-temps: "" << EIB.message()
               << '\\n';
      });
    }
  }
  Conf.CPU = TOpts.CPU;
  Conf.CodeModel = getCodeModel(CGOpts);
  Conf.MAttrs = TOpts.Features;
  Conf.RelocModel = CGOpts.RelocationModel;
  Conf.CGOptLevel = getCGOptLevel(CGOpts);
  Conf.OptLevel = CGOpts.OptimizationLevel;
  initTargetOptions(Conf.Options, CGOpts, TOpts, LOpts, HeaderOpts);
  Conf.SampleProfile = std::move(SampleProfile);
  Conf.PTO.LoopUnrolling = CGOpts.UnrollLoops;
  // For historical reasons, loop interleaving is set to mirror setting for loop
  // unrolling.
  Conf.PTO.LoopInterleaving = CGOpts.UnrollLoops;
  Conf.PTO.LoopVectorization = CGOpts.VectorizeLoop;
  Conf.PTO.SLPVectorization = CGOpts.VectorizeSLP;

  // Context sensitive profile.
  if (CGOpts.hasProfileCSIRInstr()) {
    Conf.RunCSIRInstr = true;
    Conf.CSIRProfile = std::move(CGOpts.InstrProfileOutput);
  } else if (CGOpts.hasProfileCSIRUse()) {
    Conf.RunCSIRInstr = false;
    Conf.CSIRProfile = std::move(CGOpts.ProfileInstrumentUsePath);
  }

  Conf.ProfileRemapping = std::move(ProfileRemapping);
  Conf.UseNewPM = CGOpts.ExperimentalNewPassManager;
  Conf.DebugPassManager = CGOpts.DebugPassManager;
  Conf.RemarksWithHotness = CGOpts.DiagnosticsWithHotness;
  Conf.RemarksFilename = CGOpts.OptRecordFile;
  Conf.RemarksPasses = CGOpts.OptRecordPasses;
  Conf.RemarksFormat = CGOpts.OptRecordFormat;
  Conf.SplitDwarfFile = CGOpts.SplitDwarfFile;
  Conf.SplitDwarfOutput = CGOpts.SplitDwarfOutput;
  switch (Action) {
  case Backend_EmitNothing:
    Conf.PreCodeGenModuleHook = [](size_t Task, const Module &Mod) {
      return false;
    };
    break;
  case Backend_EmitLL:
    Conf.PreCodeGenModuleHook = [&](size_t Task, const Module &Mod) {
      M->print(*OS, nullptr, CGOpts.EmitLLVMUseLists);
      return false;
    };
    break;
  case Backend_EmitBC:
    Conf.PreCodeGenModuleHook = [&](size_t Task, const Module &Mod) {
      WriteBitcodeToFile(*M, *OS, CGOpts.EmitLLVMUseLists);
      return false;
    };
    break;
  default:
    Conf.CGFileType = getCodeGenFileType(Action);
    break;
  }
  if (Error E = thinBackend(
          Conf, -1, AddStream, *M, *CombinedIndex, ImportList,
          ModuleToDefinedGVSummaries[M->getModuleIdentifier()], ModuleMap)) {
    handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
      errs() << ""Error running ThinLTO backend: "" << EIB.message() << '\\n';
    });
  }
}

void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
                              const HeaderSearchOptions &HeaderOpts,
                              const CodeGenOptions &CGOpts,
                              const clang::TargetOptions &TOpts,
                              const LangOptions &LOpts,
                              const llvm::DataLayout &TDesc, Module *M,
                              BackendAction Action,
                              std::unique_ptr<raw_pwrite_stream> OS) {

  llvm::TimeTraceScope TimeScope(""Backend"");

  std::unique_ptr<llvm::Module> EmptyModule;
  if (!CGOpts.ThinLTOIndexFile.empty()) {
    // If we are performing a ThinLTO importing compile, load the function index
    // into memory and pass it into runThinLTOBackend, which will run the
    // function importer and invoke LTO passes.
    Expected<std::unique_ptr<ModuleSummaryIndex>> IndexOrErr =
        llvm::getModuleSummaryIndexForFile(CGOpts.ThinLTOIndexFile,
                                           /*IgnoreEmptyThinLTOIndexFile*/true);
    if (!IndexOrErr) {
      logAllUnhandledErrors(IndexOrErr.takeError(), errs(),
                            ""Error loading index file '"" +
                            CGOpts.ThinLTOIndexFile + ""': "");
      return;
    }
    std::unique_ptr<ModuleSummaryIndex> CombinedIndex = std::move(*IndexOrErr);
    // A null CombinedIndex means we should skip ThinLTO compilation
    // (LLVM will optionally ignore empty index files, returning null instead
    // of an error).
    if (CombinedIndex) {
      if (!CombinedIndex->skipModuleByDistributedBackend()) {
        runThinLTOBackend(CombinedIndex.get(), M, HeaderOpts, CGOpts, TOpts,
                          LOpts, std::move(OS), CGOpts.SampleProfileFile,
                          CGOpts.ProfileRemappingFile, Action);
        return;
      }
      // Distributed indexing detected that nothing from the module is needed
      // for the final linking. So we can skip the compilation. We sill need to
      // output an empty object file to make sure that a linker does not fail
      // trying to read it. Also for some features, like CFI, we must skip
      // the compilation as CombinedIndex does not contain all required
      // information.
      EmptyModule = std::make_unique<llvm::Module>(""empty"", M->getContext());
      EmptyModule->setTargetTriple(M->getTargetTriple());
      M = EmptyModule.get();
    }
  }

  EmitAssemblyHelper AsmHelper(Diags, HeaderOpts, CGOpts, TOpts, LOpts, M);

  if (CGOpts.ExperimentalNewPassManager)
    AsmHelper.EmitAssemblyWithNewPassManager(Action, std::move(OS));
  else
    AsmHelper.EmitAssembly(Action, std::move(OS));

  // Verify clang's TargetInfo DataLayout against the LLVM TargetMachine's
  // DataLayout.
  if (AsmHelper.TM) {
    std::string DLDesc = M->getDataLayout().getStringRepresentation();
    if (DLDesc != TDesc.getStringRepresentation()) {
      unsigned DiagID = Diags.getCustomDiagID(
          DiagnosticsEngine::Error, ""backend data layout '%0' does not match ""
                                    ""expected target description '%1'"");
      Diags.Report(DiagID) << DLDesc << TDesc.getStringRepresentation();
    }
  }
}

// With -fembed-bitcode, save a copy of the llvm IR as data in the
// __LLVM,__bitcode section.
void clang::EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts,
                         llvm::MemoryBufferRef Buf) {
  if (CGOpts.getEmbedBitcode() == CodeGenOptions::Embed_Off)
    return;
  llvm::EmbedBitcodeInModule(
      *M, Buf, CGOpts.getEmbedBitcode() != CodeGenOptions::Embed_Marker,
      CGOpts.getEmbedBitcode() != CodeGenOptions::Embed_Bitcode,
      &CGOpts.CmdArgs);
}
",16247,True,3107.549991728815,median
"[[FTPComponent]]
FTP/SFTP/FTPS Component
~~~~~~~~~~~~~~~~~~~~~~~

This component provides access to remote file systems over the FTP and
SFTP protocols.

Maven users will need to add the following dependency to their `pom.xml`
for this component:

[source,xml]
-----------------------------------------------------------------------
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-ftp</artifactId>
    <version>x.x.x</version>See the documentation of the Apache Commons
    <!-- use the same version as your Camel core version -->
</dependency>
-----------------------------------------------------------------------

[Info]
====
More options

See link:file2.html[File] for more options as all the options from
link:file2.html[File] is inherited.

====

[Info]
====
Absolute paths

Absolute path is *not* supported.

*Camel 2.16* will translate absolute path to relative by trimming all
leading slashes from `directoryname`. There'll be WARN message printed
in the logs.

====

[Tip]
====
Consuming from remote FTP server

Make sure you read the section titled _Default when consuming files_
further below for details related to consuming files.

====

[[FTP2-URIformat]]
URI format
^^^^^^^^^^

[source,java]
---------------------------------------------------------
ftp://[username@]hostname[:port]/directoryname[?options]
sftp://[username@]hostname[:port]/directoryname[?options]
ftps://[username@]hostname[:port]/directoryname[?options]
---------------------------------------------------------

Where *directoryname* represents the underlying directory. The directory
name is a relative path. Absolute path's is *not* supported. The
relative path can contain nested folders, such as /inbox/us.

For Camel versions before *Camel 2.16*, the directoryName *must* exist
already as this component does not support the `autoCreate` option
(which the file component does). The reason is that its the FTP
administrator (FTP server) task to properly setup user accounts, and
home directories with the right file permissions etc.

For *Camel 2.16*, `autoCreate` option is supported. When consumer
starts, before polling is scheduled, there's additional FTP operation
performed to create the directory configured for endpoint. The default
value for `autoCreate` is `true`.

If no *username* is provided, then `anonymous` login is attempted using
no password. +
 If no *port* number is provided, Camel will provide default values
according to the protocol (ftp = 21, sftp = 22, ftps = 2222).

You can append query options to the URI in the following format,
`?option=value&option=value&...`

This component uses two different libraries for the actual FTP work. FTP
and FTPS uses http://commons.apache.org/net/[Apache Commons Net] while
SFTP uses http://www.jcraft.com/jsch/[JCraft JSCH].

The FTPS component is only available in Camel 2.2 or newer. +
 FTPS (also known as FTP Secure) is an extension to FTP that adds
support for the Transport Layer Security (TLS) and the Secure Sockets
Layer (SSL) cryptographic protocols.

[[FTP2-URIOptions]]
URI Options
^^^^^^^^^^^

The options below are exclusive for the FTP component.

[Info]
====
More options

See link:file2.html[File] for more options as all the options from
link:file2.html[File] is inherited.

====

// component options: START
The FTP component has no options.
// component options: END









// endpoint options: START
The FTP component supports 105 endpoint options which are listed below:

{% raw %}
[width=""100%"",cols=""2,1,1m,1m,5"",options=""header""]
|=======================================================================
| Name | Group | Default | Java Type | Description
| host | common |  | String | *Required* Hostname of the FTP server
| port | common |  | int | Port of the FTP server
| directoryName | common |  | String | The starting directory
| binary | common | false | boolean | Specifies the file transfer mode BINARY or ASCII. Default is ASCII (false).
| charset | common |  | String | This option is used to specify the encoding of the file. You can use this on the consumer to specify the encodings of the files which allow Camel to know the charset it should load the file content in case the file content is being accessed. Likewise when writing a file you can use this option to specify which charset to write the file as well.
| disconnect | common | false | boolean | Whether or not to disconnect from remote FTP server right after use. Disconnect will only disconnect the current connection to the FTP server. If you have a consumer which you want to stop then you need to stop the consumer/route instead.
| doneFileName | common |  | String | Producer: If provided then Camel will write a 2nd done file when the original file has been written. The done file will be empty. This option configures what file name to use. Either you can specify a fixed name. Or you can use dynamic placeholders. The done file will always be written in the same folder as the original file. Consumer: If provided Camel will only consume files if a done file exists. This option configures what file name to use. Either you can specify a fixed name. Or you can use dynamic placeholders.The done file is always expected in the same folder as the original file. Only $file.name and $file.name.noext is supported as dynamic placeholders.
| fileName | common |  | String | Use Expression such as File Language to dynamically set the filename. For consumers it's used as a filename filter. For producers it's used to evaluate the filename to write. If an expression is set it take precedence over the CamelFileName header. (Note: The header itself can also be an Expression). The expression options support both String and Expression types. If the expression is a String type it is always evaluated using the File Language. If the expression is an Expression type the specified Expression type is used - this allows you for instance to use OGNL expressions. For the consumer you can use it to filter filenames so you can for instance consume today's file using the File Language syntax: mydata-$date:now:yyyyMMdd.txt. The producers support the CamelOverruleFileName header which takes precedence over any existing CamelFileName header; the CamelOverruleFileName is a header that is used only once and makes it easier as this avoids to temporary store CamelFileName and have to restore it afterwards.
| passiveMode | common | false | boolean | Sets passive mode connections. Default is active mode connections.
| separator | common | UNIX | PathSeparator | Sets the path separator to be used. UNIX = Uses unix style path separator Windows = Uses windows style path separator Auto = (is default) Use existing path separator in file name
| fastExistsCheck | common (advanced) | false | boolean | If set this option to be true camel-ftp will use the list file directly to check if the file exists. Since some FTP server may not support to list the file directly if the option is false camel-ftp will use the old way to list the directory and check if the file exists. This option also influences readLock=changed to control whether it performs a fast check to update file information or not. This can be used to speed up the process if the FTP server has a lot of files.
| bridgeErrorHandler | consumer | false | boolean | Allows for bridging the consumer to the Camel routing Error Handler which mean any exceptions occurred while the consumer is trying to pickup incoming messages or the likes will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions that will be logged at WARN/ERROR level and ignored.
| delete | consumer | false | boolean | If true the file will be deleted after it is processed successfully.
| moveFailed | consumer |  | String | Sets the move failure expression based on Simple language. For example to move files into a .error subdirectory use: .error. Note: When moving the files to the fail location Camel will handle the error and will not pick up the file again.
| noop | consumer | false | boolean | If true the file is not moved or deleted in any way. This option is good for readonly data or for ETL type requirements. If noop=true Camel will set idempotent=true as well to avoid consuming the same files over and over again.
| preMove | consumer |  | String | Expression (such as File Language) used to dynamically set the filename when moving it before processing. For example to move in-progress files into the order directory set this value to order.
| recursive | consumer | false | boolean | If a directory will look for files in all the sub-directories as well.
| sendEmptyMessageWhenIdle | consumer | false | boolean | If the polling consumer did not poll any files you can enable this option to send an empty message (no body) instead.
| streamDownload | consumer | false | boolean | Sets the download method to use when not using a local working directory. If set to true the remote files are streamed to the route as they are read. When set to false the remote files are loaded into memory before being sent into the route.
| directoryMustExist | consumer (advanced) | false | boolean | Similar to startingDirectoryMustExist but this applies during polling recursive sub directories.
| download | consumer (advanced) | false | boolean | Whether the FTP consumer should download the file. If this option is set to false then the message body will be null but the consumer will still trigger a Camel Exchange that has details about the file such as file name file size etc. It's just that the file will not be downloaded.
| exceptionHandler | consumer (advanced) |  | ExceptionHandler | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this options is not in use. By default the consumer will deal with exceptions that will be logged at WARN/ERROR level and ignored.
| exchangePattern | consumer (advanced) |  | ExchangePattern | Sets the exchange pattern when the consumer creates an exchange.
| ignoreFileNotFoundOrPermissionError | consumer (advanced) | false | boolean | Whether to ignore when trying to download a file which does not exist or due to permission error. By default when a file does not exists or insufficient permission then an exception is thrown. Setting this option to true allows to ignore that instead.
| inProgressRepository | consumer (advanced) |  | String> | A pluggable in-progress repository org.apache.camel.spi.IdempotentRepository. The in-progress repository is used to account the current in progress files being consumed. By default a memory based repository is used.
| localWorkDirectory | consumer (advanced) |  | String | When consuming a local work directory can be used to store the remote file content directly in local files to avoid loading the content into memory. This is beneficial if you consume a very big remote file and thus can conserve memory.
| onCompletionExceptionHandler | consumer (advanced) |  | ExceptionHandler | To use a custom org.apache.camel.spi.ExceptionHandler to handle any thrown exceptions that happens during the file on completion process where the consumer does either a commit or rollback. The default implementation will log any exception at WARN level and ignore.
| pollStrategy | consumer (advanced) |  | PollingConsumerPollStrategy | A pluggable org.apache.camel.PollingConsumerPollingStrategy allowing you to provide your custom implementation to control error handling usually occurred during the poll operation before an Exchange have been created and being routed in Camel.
| processStrategy | consumer (advanced) |  | GenericFileProcessStrategy<T> | A pluggable org.apache.camel.component.file.GenericFileProcessStrategy allowing you to implement your own readLock option or similar. Can also be used when special conditions must be met before a file can be consumed such as a special ready file exists. If this option is set then the readLock option does not apply.
| receiveBufferSize | consumer (advanced) | 32768 | int | The receive (download) buffer size Used only by FTPClient
| startingDirectoryMustExist | consumer (advanced) | false | boolean | Whether the starting directory must exist. Mind that the autoCreate option is default enabled which means the starting directory is normally auto created if it doesn't exist. You can disable autoCreate and enable this to ensure the starting directory must exist. Will thrown an exception if the directory doesn't exist.
| useList | consumer (advanced) | true | boolean | Whether to allow using LIST command when downloading a file. Default is true. In some use cases you may want to download a specific file and are not allowed to use the LIST command and therefore you can set this option to false.
| fileExist | producer | Override | GenericFileExist | What to do if a file already exists with the same name. Override which is the default replaces the existing file. Append - adds content to the existing file. Fail - throws a GenericFileOperationException indicating that there is already an existing file. Ignore - silently ignores the problem and does not override the existing file but assumes everything is okay. Move - option requires to use the moveExisting option to be configured as well. The option eagerDeleteTargetFile can be used to control what to do if an moving the file and there exists already an existing file otherwise causing the move operation to fail. The Move option will move any existing files before writing the target file. TryRename Camel is only applicable if tempFileName option is in use. This allows to try renaming the file from the temporary name to the actual name without doing any exists check.This check may be faster on some file systems and especially FTP servers.
| flatten | producer | false | boolean | Flatten is used to flatten the file name path to strip any leading paths so it's just the file name. This allows you to consume recursively into sub-directories but when you eg write the files to another directory they will be written in a single directory. Setting this to true on the producer enforces that any file name in CamelFileName header will be stripped for any leading paths.
| moveExisting | producer |  | String | Expression (such as File Language) used to compute file name to use when fileExist=Move is configured. To move files into a backup subdirectory just enter backup. This option only supports the following File Language tokens: file:name file:name.ext file:name.noext file:onlyname file:onlyname.noext file:ext and file:parent. Notice the file:parent is not supported by the FTP component as the FTP component can only move any existing files to a relative directory based on current dir as base.
| tempFileName | producer |  | String | The same as tempPrefix option but offering a more fine grained control on the naming of the temporary filename as it uses the File Language.
| tempPrefix | producer |  | String | This option is used to write the file using a temporary name and then after the write is complete rename it to the real name. Can be used to identify files being written and also avoid consumers (not using exclusive read locks) reading in progress files. Is often used by FTP when uploading big files.
| allowNullBody | producer (advanced) | false | boolean | Used to specify if a null body is allowed during file writing. If set to true then an empty file will be created when set to false and attempting to send a null body to the file component a GenericFileWriteException of 'Cannot write null body to file.' will be thrown. If the fileExist option is set to 'Override' then the file will be truncated and if set to append the file will remain unchanged.
| chmod | producer (advanced) |  | String | Allows you to set chmod on the stored file. For example chmod=640.
| disconnectOnBatchComplete | producer (advanced) | false | boolean | Whether or not to disconnect from remote FTP server right after a Batch upload is complete. disconnectOnBatchComplete will only disconnect the current connection to the FTP server.
| eagerDeleteTargetFile | producer (advanced) | true | boolean | Whether or not to eagerly delete any existing target file. This option only applies when you use fileExists=Override and the tempFileName option as well. You can use this to disable (set it to false) deleting the target file before the temp file is written. For example you may write big files and want the target file to exists during the temp file is being written. This ensure the target file is only deleted until the very last moment just before the temp file is being renamed to the target filename. This option is also used to control whether to delete any existing files when fileExist=Move is enabled and an existing file exists. If this option copyAndDeleteOnRenameFails false then an exception will be thrown if an existing file existed if its true then the existing file is deleted before the move operation.
| keepLastModified | producer (advanced) | false | boolean | Will keep the last modified timestamp from the source file (if any). Will use the Exchange.FILE_LAST_MODIFIED header to located the timestamp. This header can contain either a java.util.Date or long with the timestamp. If the timestamp exists and the option is enabled it will set this timestamp on the written file. Note: This option only applies to the file producer. You cannot use this option with any of the ftp producers.
| sendNoop | producer (advanced) | true | boolean | Whether to send a noop command as a pre-write check before uploading files to the FTP server. This is enabled by default as a validation of the connection is still valid which allows to silently re-connect to be able to upload the file. However if this causes problems you can turn this option off.
| activePortRange | advanced |  | String | Set the client side port range in active mode. The syntax is: minPort-maxPort Both port numbers are inclusive eg 10000-19999 to include all 1xxxx ports.
| autoCreate | advanced | true | boolean | Automatically create missing directories in the file's pathname. For the file consumer that means creating the starting directory. For the file producer it means the directory the files should be written to.
| bufferSize | advanced | 131072 | int | Write buffer sized in bytes.
| connectTimeout | advanced | 10000 | int | Sets the connect timeout for waiting for a connection to be established Used by both FTPClient and JSCH
| ftpClient | advanced |  | FTPClient | To use a custom instance of FTPClient
| ftpClientConfig | advanced |  | FTPClientConfig | To use a custom instance of FTPClientConfig to configure the FTP client the endpoint should use.
| ftpClientConfigParameters | advanced |  | Map | Used by FtpComponent to provide additional parameters for the FTPClientConfig
| ftpClientParameters | advanced |  | Map | Used by FtpComponent to provide additional parameters for the FTPClient
| maximumReconnectAttempts | advanced |  | int | Specifies the maximum reconnect attempts Camel performs when it tries to connect to the remote FTP server. Use 0 to disable this behavior.
| reconnectDelay | advanced |  | long | Delay in millis Camel will wait before performing a reconnect attempt.
| siteCommand | advanced |  | String | Sets optional site command(s) to be executed after successful login. Multiple site commands can be separated using a new line character (\\n).
| soTimeout | advanced | 300000 | int | Sets the so timeout Used only by FTPClient
| stepwise | advanced | true | boolean | Sets whether we should stepwise change directories while traversing file structures when downloading files or as well when uploading a file to a directory. You can disable this if you for example are in a situation where you cannot change directory on the FTP server due security reasons.
| synchronous | advanced | false | boolean | Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported).
| throwExceptionOnConnectFailed | advanced | false | boolean | Should an exception be thrown if connection failed (exhausted) By default exception is not thrown and a WARN is logged. You can use this to enable exception being thrown and handle the thrown exception from the org.apache.camel.spi.PollingConsumerPollStrategy rollback method.
| timeout | advanced | 30000 | int | Sets the data timeout for waiting for reply Used only by FTPClient
| antExclude | filter |  | String | Ant style filter exclusion. If both antInclude and antExclude are used antExclude takes precedence over antInclude. Multiple exclusions may be specified in comma-delimited format.
| antFilterCaseSensitive | filter | true | boolean | Sets case sensitive flag on ant fiter
| antInclude | filter |  | String | Ant style filter inclusion. Multiple inclusions may be specified in comma-delimited format.
| eagerMaxMessagesPerPoll | filter | true | boolean | Allows for controlling whether the limit from maxMessagesPerPoll is eager or not. If eager then the limit is during the scanning of files. Where as false would scan all files and then perform sorting. Setting this option to false allows for sorting all files first and then limit the poll. Mind that this requires a higher memory usage as all file details are in memory to perform the sorting.
| exclude | filter |  | String | Is used to exclude files if filename matches the regex pattern (matching is case in-senstive). Notice if you use symbols such as plus sign and others you would need to configure this using the RAW() syntax if configuring this as an endpoint uri. See more details at configuring endpoint uris
| filter | filter |  | GenericFileFilter<T> | Pluggable filter as a org.apache.camel.component.file.GenericFileFilter class. Will skip files if filter returns false in its accept() method.
| filterDirectory | filter |  | String | Filters the directory based on Simple language. For example to filter on current date you can use a simple date pattern such as $date:now:yyyMMdd
| filterFile | filter |  | String | Filters the file based on Simple language. For example to filter on file size you can use $file:size 5000
| idempotent | filter | false | Boolean | Option to use the Idempotent Consumer EIP pattern to let Camel skip already processed files. Will by default use a memory based LRUCache that holds 1000 entries. If noop=true then idempotent will be enabled as well to avoid consuming the same files over and over again.
| idempotentKey | filter |  | String | To use a custom idempotent key. By default the absolute path of the file is used. You can use the File Language for example to use the file name and file size you can do: idempotentKey=$file:name-$file:size
| idempotentRepository | filter |  | String> | A pluggable repository org.apache.camel.spi.IdempotentRepository which by default use MemoryMessageIdRepository if none is specified and idempotent is true.
| include | filter |  | String | Is used to include files if filename matches the regex pattern (matching is case in-senstive). Notice if you use symbols such as plus sign and others you would need to configure this using the RAW() syntax if configuring this as an endpoint uri. See more details at configuring endpoint uris
| maxDepth | filter | 2147483647 | int | The maximum depth to traverse when recursively processing a directory.
| maxMessagesPerPoll | filter |  | int | To define a maximum messages to gather per poll. By default no maximum is set. Can be used to set a limit of e.g. 1000 to avoid when starting up the server that there are thousands of files. Set a value of 0 or negative to disabled it. Notice: If this option is in use then the File and FTP components will limit before any sorting. For example if you have 100000 files and use maxMessagesPerPoll=500 then only the first 500 files will be picked up and then sorted. You can use the eagerMaxMessagesPerPoll option and set this to false to allow to scan all files first and then sort afterwards.
| minDepth | filter |  | int | The minimum depth to start processing when recursively processing a directory. Using minDepth=1 means the base directory. Using minDepth=2 means the first sub directory.
| move | filter |  | String | Expression (such as Simple Language) used to dynamically set the filename when moving it after processing. To move files into a .done subdirectory just enter .done.
| exclusiveReadLockStrategy | lock |  | GenericFileExclusiveReadLockStrategy<T> | Pluggable read-lock as a org.apache.camel.component.file.GenericFileExclusiveReadLockStrategy implementation.
| readLock | lock |  | String | Used by consumer to only poll the files if it has exclusive read-lock on the file (i.e. the file is not in-progress or being written). Camel will wait until the file lock is granted. This option provides the build in strategies: none - No read lock is in use markerFile - Camel creates a marker file (fileName.camelLock) and then holds a lock on it. This option is not available for the FTP component changed - Changed is using file length/modification timestamp to detect whether the file is currently being copied or not. Will at least use 1 sec to determine this so this option cannot consume files as fast as the others but can be more reliable as the JDK IO API cannot always determine whether a file is currently being used by another process. The option readLockCheckInterval can be used to set the check frequency. fileLock - is for using java.nio.channels.FileLock. This option is not avail for the FTP component. This approach should be avoided when accessing a remote file system via a mount/share unless that file system supports distributed file locks. rename - rename is for using a try to rename the file as a test if we can get exclusive read-lock. idempotent - (only for file component) idempotent is for using a idempotentRepository as the read-lock. This allows to use read locks that supports clustering if the idempotent repository implementation supports that. Notice: The various read locks is not all suited to work in clustered mode where concurrent consumers on different nodes is competing for the same files on a shared file system. The markerFile using a close to atomic operation to create the empty marker file but its not guaranteed to work in a cluster. The fileLock may work better but then the file system need to support distributed file locks and so on. Using the idempotent read lock can support clustering if the idempotent repository supports clustering such as Hazelcast Component or Infinispan.
| readLockCheckInterval | lock | 1000 | long | Interval in millis for the read-lock if supported by the read lock. This interval is used for sleeping between attempts to acquire the read lock. For example when using the changed read lock you can set a higher interval period to cater for slow writes. The default of 1 sec. may be too fast if the producer is very slow writing the file. Notice: For FTP the default readLockCheckInterval is 5000. The readLockTimeout value must be higher than readLockCheckInterval but a rule of thumb is to have a timeout that is at least 2 or more times higher than the readLockCheckInterval. This is needed to ensure that amble time is allowed for the read lock process to try to grab the lock before the timeout was hit.
| readLockDeleteOrphanLockFiles | lock | true | boolean | Whether or not read lock with marker files should upon startup delete any orphan read lock files which may have been left on the file system if Camel was not properly shutdown (such as a JVM crash). If turning this option to false then any orphaned lock file will cause Camel to not attempt to pickup that file this could also be due another node is concurrently reading files from the same shared directory.
| readLockLoggingLevel | lock | WARN | LoggingLevel | Logging level used when a read lock could not be acquired. By default a WARN is logged. You can change this level for example to OFF to not have any logging. This option is only applicable for readLock of types: changed fileLock rename.
| readLockMarkerFile | lock | true | boolean | Whether to use marker file with the changed rename or exclusive read lock types. By default a marker file is used as well to guard against other processes picking up the same files. This behavior can be turned off by setting this option to false. For example if you do not want to write marker files to the file systems by the Camel application.
| readLockMinAge | lock | 0 | long | This option applied only for readLock=change. This option allows to specify a minimum age the file must be before attempting to acquire the read lock. For example use readLockMinAge=300s to require the file is at last 5 minutes old. This can speedup the changed read lock as it will only attempt to acquire files which are at least that given age.
| readLockMinLength | lock | 1 | long | This option applied only for readLock=changed. This option allows you to configure a minimum file length. By default Camel expects the file to contain data and thus the default value is 1. You can set this option to zero to allow consuming zero-length files.
| readLockRemoveOnCommit | lock | false | boolean | This option applied only for readLock=idempotent. This option allows to specify whether to remove the file name entry from the idempotent repository when processing the file is succeeded and a commit happens. By default the file is not removed which ensures that any race-condition do not occur so another active node may attempt to grab the file. Instead the idempotent repository may support eviction strategies that you can configure to evict the file name entry after X minutes - this ensures no problems with race conditions.
| readLockRemoveOnRollback | lock | true | boolean | This option applied only for readLock=idempotent. This option allows to specify whether to remove the file name entry from the idempotent repository when processing the file failed and a rollback happens. If this option is false then the file name entry is confirmed (as if the file did a commit).
| readLockTimeout | lock | 10000 | long | Optional timeout in millis for the read-lock if supported by the read-lock. If the read-lock could not be granted and the timeout triggered then Camel will skip the file. At next poll Camel will try the file again and this time maybe the read-lock could be granted. Use a value of 0 or lower to indicate forever. Currently fileLock changed and rename support the timeout. Notice: For FTP the default readLockTimeout value is 20000 instead of 10000. The readLockTimeout value must be higher than readLockCheckInterval but a rule of thumb is to have a timeout that is at least 2 or more times higher than the readLockCheckInterval. This is needed to ensure that amble time is allowed for the read lock process to try to grab the lock before the timeout was hit.
| backoffErrorThreshold | scheduler |  | int | The number of subsequent error polls (failed due some error) that should happen before the backoffMultipler should kick-in.
| backoffIdleThreshold | scheduler |  | int | The number of subsequent idle polls that should happen before the backoffMultipler should kick-in.
| backoffMultiplier | scheduler |  | int | To let the scheduled polling consumer backoff if there has been a number of subsequent idles/errors in a row. The multiplier is then the number of polls that will be skipped before the next actual attempt is happening again. When this option is in use then backoffIdleThreshold and/or backoffErrorThreshold must also be configured.
| delay | scheduler | 500 | long | Milliseconds before the next poll. You can also specify time values using units such as 60s (60 seconds) 5m30s (5 minutes and 30 seconds) and 1h (1 hour).
| greedy | scheduler | false | boolean | If greedy is enabled then the ScheduledPollConsumer will run immediately again if the previous run polled 1 or more messages.
| initialDelay | scheduler | 1000 | long | Milliseconds before the first poll starts. You can also specify time values using units such as 60s (60 seconds) 5m30s (5 minutes and 30 seconds) and 1h (1 hour).
| runLoggingLevel | scheduler | TRACE | LoggingLevel | The consumer logs a start/complete log line when it polls. This option allows you to configure the logging level for that.
| scheduledExecutorService | scheduler |  | ScheduledExecutorService | Allows for configuring a custom/shared thread pool to use for the consumer. By default each consumer has its own single threaded thread pool.
| scheduler | scheduler | none | ScheduledPollConsumerScheduler | To use a cron scheduler from either camel-spring or camel-quartz2 component
| schedulerProperties | scheduler |  | Map | To configure additional properties when using a custom scheduler or any of the Quartz2 Spring based scheduler.
| startScheduler | scheduler | true | boolean | Whether the scheduler should be auto started.
| timeUnit | scheduler | MILLISECONDS | TimeUnit | Time unit for initialDelay and delay options.
| useFixedDelay | scheduler | true | boolean | Controls if fixed delay or fixed rate is used. See ScheduledExecutorService in JDK for details.
| shuffle | sort | false | boolean | To shuffle the list of files (sort in random order)
| sortBy | sort |  | String | Built-in sort by using the File Language. Supports nested sorts so you can have a sort by file name and as a 2nd group sort by modified date.
| sorter | sort |  | GenericFile<T>> | Pluggable sorter as a java.util.Comparator class.
| account | security |  | String | Account to use for login
| password | security |  | String | Password to use for login
| username | security |  | String | Username to use for login
|=======================================================================
{% endraw %}
// endpoint options: END










[Info]
====
FTPS component default trust store

When using the `ftpClient.` properties related to SSL with the FTPS
component, the trust store accept all certificates. If you only want
trust selective certificates, you have to configure the trust store with
the `ftpClient.trustStore.xxx` options or by configuring a custom
`ftpClient`.

When using `sslContextParameters`, the trust store is managed by the
configuration of the provided SSLContextParameters instance.

====

You can configure additional options on the `ftpClient` and
`ftpClientConfig` from the URI directly by using the `ftpClient.` or
`ftpClientConfig.` prefix.

For example to set the `setDataTimeout` on the `FTPClient` to 30 seconds
you can do:

[source,java]
--------------------------------------------------------------------------------------
from(""ftp://foo@myserver?password=secret&ftpClient.dataTimeout=30000"").to(""bean:foo"");
--------------------------------------------------------------------------------------

You can mix and match and have use both prefixes, for example to
configure date format or timezones.

[source,java]
----------------------------------------------------------------------------------------------------------------------------
from(""ftp://foo@myserver?password=secret&ftpClient.dataTimeout=30000&ftpClientConfig.serverLanguageCode=fr"").to(""bean:foo"");
----------------------------------------------------------------------------------------------------------------------------

You can have as many of these options as you like.

See the documentation of the Apache Commons FTP FTPClientConfig for
possible options and more details. And as well for Apache Commons FTP
FTPClient.

If you do not like having many and long configuration in the url you can
refer to the `ftpClient` or `ftpClientConfig` to use by letting Camel
lookup in the link:registry.html[Registry] for it.

For example:

[source,java]
--------------------------------------------------------------------------
   <bean id=""myConfig"" class=""org.apache.commons.net.ftp.FTPClientConfig"">
       <property name=""lenientFutureDates"" value=""true""/>
       <property name=""serverLanguageCode"" value=""fr""/>
   </bean>
--------------------------------------------------------------------------

And then let Camel lookup this bean when you use the # notation in the
url.

[source,java]
------------------------------------------------------------------------------------
from(""ftp://foo@myserver?password=secret&ftpClientConfig=#myConfig"").to(""bean:foo"");
------------------------------------------------------------------------------------

[[FTP2-MoreURIoptions]]
More URI options
^^^^^^^^^^^^^^^^

[Info]
====


See link:file2.html[File2] as all the options there also applies for
this component.

====

[[FTP2-Examples]]
Examples
^^^^^^^^

`ftp://someone@someftpserver.com/public/upload/images/holiday2008?password=secret&binary=true` +

`ftp://someoneelse@someotherftpserver.co.uk:12049/reports/2008/password=secret&binary=false` +
 `ftp://publicftpserver.com/download`

[Warning]
====
FTP Consumer does not support concurrency

The FTP consumer (with the same endpoint) does not support concurrency
(the backing FTP client is not thread safe). +
 You can use multiple FTP consumers to poll from different endpoints. It
is only a single endpoint that does not support concurrent consumers.

The FTP producer does *not* have this issue, it supports concurrency.

====

[Tip]
====
More information

This component is an extension of the link:file2.html[File] component.
So there are more samples and details on the link:file2.html[File]
component page.

====

[[FTP2-Defaultwhenconsumingfiles]]
Default when consuming files
^^^^^^^^^^^^^^^^^^^^^^^^^^^^

The link:ftp2.html[FTP] consumer will by default leave the consumed
files untouched on the remote FTP server. You have to configure it
explicitly if you want it to delete the files or move them to another
location. For example you can use `delete=true` to delete the files, or
use `move=.done` to move the files into a hidden done sub directory.

The regular link:file2.html[File] consumer is different as it will by
default move files to a `.camel` sub directory. The reason Camel does
*not* do this by default for the FTP consumer is that it may lack
permissions by default to be able to move or delete files.

[[FTP2-limitations]]
limitations
+++++++++++

The option *readLock* can be used to force Camel *not* to consume files
that is currently in the progress of being written. However, this option
is turned off by default, as it requires that the user has write access.
See the options table at link:file2.html[File2] for more details about
read locks. +
 There are other solutions to avoid consuming files that are currently
being written over FTP; for instance, you can write to a temporary
destination and move the file after it has been written.

When moving files using `move` or `preMove` option the files are
restricted to the FTP_ROOT folder. That prevents you from moving files
outside the FTP area. If you want to move files to another area you can
use soft links and move files into a soft linked folder.

[[FTP2-MessageHeaders]]
Message Headers
^^^^^^^^^^^^^^^

The following message headers can be used to affect the behavior of the
component

[width=""100%"",cols=""50%,50%"",options=""header"",]
|=======================================================================
|Header |Description

|`CamelFileName` |Specifies the output file name (relative to the endpoint directory) to
be used for the output message when sending to the endpoint. If this is
not present and no expression either, then a generated message ID is
used as the filename instead.

|`CamelFileNameProduced` |The actual filepath (path + name) for the output file that was written.
This header is set by Camel and its purpose is providing end-users the
name of the file that was written.

|`CamelFileIndex` |Current index out of total number of files being consumed in this batch.

|`CamelFileSize` |Total number of files being consumed in this batch.

|`CamelFileHost` |The remote hostname.

|`CamelFileLocalWorkPath` |Path to the local work file, if local work directory is used.
|=======================================================================

In addition the FTP/FTPS consumer and producer will enrich the Camel
`Message` with the following headers

[width=""100%"",cols=""50%,50%"",options=""header"",]
|=======================================================================
|Header |Description

|`CamelFtpReplyCode` |*Camel 2.11.1:* The FTP client reply code (the type is a integer)

|`CamelFtpReplyString` | *Camel 2.11.1:* The FTP client reply string
|=======================================================================

[[FTP2-Abouttimeouts]]
About timeouts
^^^^^^^^^^^^^^

The two set of libraries (see top) has different API for setting
timeout. You can use the `connectTimeout` option for both of them to set
a timeout in millis to establish a network connection. An individual
`soTimeout` can also be set on the FTP/FTPS, which corresponds to using
`ftpClient.soTimeout`. Notice SFTP will automatically use
`connectTimeout` as its `soTimeout`. The `timeout` option only applies
for FTP/FTSP as the data timeout, which corresponds to the
`ftpClient.dataTimeout` value. All timeout values are in millis.

[[FTP2-UsingLocalWorkDirectory]]
Using Local Work Directory
^^^^^^^^^^^^^^^^^^^^^^^^^^

Camel supports consuming from remote FTP servers and downloading the
files directly into a local work directory. This avoids reading the
entire remote file content into memory as it is streamed directly into
the local file using `FileOutputStream`.

Camel will store to a local file with the same name as the remote file,
though with `.inprogress` as extension while the file is being
downloaded. Afterwards, the file is renamed to remove the `.inprogress`
suffix. And finally, when the link:exchange.html[Exchange] is complete
the local file is deleted.

So if you want to download files from a remote FTP server and store it
as files then you need to route to a file endpoint such as:

[source,java]
------------------------------------------------------------------------------------------------
from(""ftp://someone@someserver.com?password=secret&localWorkDirectory=/tmp"").to(""file://inbox"");
------------------------------------------------------------------------------------------------

[Tip]
====
 *Optimization by renaming work file*

The route above is ultra efficient as it avoids reading the entire file
content into memory. It will download the remote file directly to a
local file stream. The `java.io.File` handle is then used as the
link:exchange.html[Exchange] body. The file producer leverages this fact
and can work directly on the work file `java.io.File` handle and perform
a `java.io.File.rename` to the target filename. As Camel knows it's a
local work file, it can optimize and use a rename instead of a file
copy, as the work file is meant to be deleted anyway.

====

[[FTP2-Stepwisechangingdirectories]]
Stepwise changing directories
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Camel link:ftp2.html[FTP] can operate in two modes in terms of
traversing directories when consuming files (eg downloading) or
producing files (eg uploading)

* stepwise
* not stepwise

You may want to pick either one depending on your situation and security
issues. Some Camel end users can only download files if they use
stepwise, while others can only download if they do not. At least you
have the choice to pick (from Camel 2.6 onwards).

In Camel 2.0 - 2.5 there is only one mode and it is:

* before 2.5 not stepwise
* 2.5 stepwise

From Camel 2.6 onwards there is now an option `stepwise` you can use to
control the behavior.

Note that stepwise changing of directory will in most cases only work
when the user is confined to it's home directory and when the home
directory is reported as `""/""`.

The difference between the two of them is best illustrated with an
example. Suppose we have the following directory structure on the remote
FTP server we need to traverse and download files:

[source,java]
--------------
/
/one
/one/two
/one/two/sub-a
/one/two/sub-b
--------------

And that we have a file in each of sub-a (a.txt) and sub-b (b.txt)
folder.

[[FTP2-Usingstepwise]]
Using stepwise=true (default mode)
++++++++++++++++++++++++++++++++++

[source,java]
----------------------------------------------------------
TYPE A
200 Type set to A
PWD
257 ""/"" is current directory.
CWD one
250 CWD successful. ""/one"" is current directory.
CWD two
250 CWD successful. ""/one/two"" is current directory.
SYST
215 UNIX emulated by FileZilla
PORT 127,0,0,1,17,94
200 Port command successful
LIST
150 Opening data channel for directory list.
226 Transfer OK
CWD sub-a
250 CWD successful. ""/one/two/sub-a"" is current directory.
PORT 127,0,0,1,17,95
200 Port command successful
LIST
150 Opening data channel for directory list.
226 Transfer OK
CDUP
200 CDUP successful. ""/one/two"" is current directory.
CWD sub-b
250 CWD successful. ""/one/two/sub-b"" is current directory.
PORT 127,0,0,1,17,96
200 Port command successful
LIST
150 Opening data channel for directory list.
226 Transfer OK
CDUP
200 CDUP successful. ""/one/two"" is current directory.
CWD /
250 CWD successful. ""/"" is current directory.
PWD
257 ""/"" is current directory.
CWD one
250 CWD successful. ""/one"" is current directory.
CWD two
250 CWD successful. ""/one/two"" is current directory.
PORT 127,0,0,1,17,97
200 Port command successful
RETR foo.txt
150 Opening data channel for file transfer.
226 Transfer OK
CWD /
250 CWD successful. ""/"" is current directory.
PWD
257 ""/"" is current directory.
CWD one
250 CWD successful. ""/one"" is current directory.
CWD two
250 CWD successful. ""/one/two"" is current directory.
CWD sub-a
250 CWD successful. ""/one/two/sub-a"" is current directory.
PORT 127,0,0,1,17,98
200 Port command successful
RETR a.txt
150 Opening data channel for file transfer.
226 Transfer OK
CWD /
250 CWD successful. ""/"" is current directory.
PWD
257 ""/"" is current directory.
CWD one
250 CWD successful. ""/one"" is current directory.
CWD two
250 CWD successful. ""/one/two"" is current directory.
CWD sub-b
250 CWD successful. ""/one/two/sub-b"" is current directory.
PORT 127,0,0,1,17,99
200 Port command successful
RETR b.txt
150 Opening data channel for file transfer.
226 Transfer OK
CWD /
250 CWD successful. ""/"" is current directory.
QUIT
221 Goodbye
disconnected.
----------------------------------------------------------

As you can see when stepwise is enabled, it will traverse the directory
structure using CD xxx.

[[FTP2-Notusingstepwise]]
Using stepwise=false
++++++++++++++++++++

[source,java]
-------------------------------------------
230 Logged on
TYPE A
200 Type set to A
SYST
215 UNIX emulated by FileZilla
PORT 127,0,0,1,4,122
200 Port command successful
LIST one/two
150 Opening data channel for directory list
226 Transfer OK
PORT 127,0,0,1,4,123
200 Port command successful
LIST one/two/sub-a
150 Opening data channel for directory list
226 Transfer OK
PORT 127,0,0,1,4,124
200 Port command successful
LIST one/two/sub-b
150 Opening data channel for directory list
226 Transfer OK
PORT 127,0,0,1,4,125
200 Port command successful
RETR one/two/foo.txt
150 Opening data channel for file transfer.
226 Transfer OK
PORT 127,0,0,1,4,126
200 Port command successful
RETR one/two/sub-a/a.txt
150 Opening data channel for file transfer.
226 Transfer OK
PORT 127,0,0,1,4,127
200 Port command successful
RETR one/two/sub-b/b.txt
150 Opening data channel for file transfer.
226 Transfer OK
QUIT
221 Goodbye
disconnected.
-------------------------------------------

As you can see when not using stepwise, there are no CD operation
invoked at all.

[[FTP2-Samples]]
Samples
^^^^^^^

In the sample below we set up Camel to download all the reports from the
FTP server once every hour (60 min) as BINARY content and store it as
files on the local file system.

And the route using Spring DSL:

[source,xml]
------------------------------------------------------------------------------------------------------
  <route>
     <from uri=""ftp://scott@localhost/public/reports?password=tiger&amp;binary=true&amp;delay=60000""/>
     <to uri=""file://target/test-reports""/>
  </route>
------------------------------------------------------------------------------------------------------

[[FTP2-ConsumingaremoteFTPSserverimplicitSSLandclientauthentication]]
Consuming a remote FTPS server (implicit SSL) and client authentication
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

[source,java]
--------------------------------------------------------------------------------------------------
from(""ftps://admin@localhost:2222/public/camel?password=admin&securityProtocol=SSL&isImplicit=true
      &ftpClient.keyStore.file=./src/test/resources/server.jks
      &ftpClient.keyStore.password=password&ftpClient.keyStore.keyPassword=password"")
  .to(""bean:foo"");
--------------------------------------------------------------------------------------------------

[[FTP2-ConsumingaremoteFTPSserverexplicitTLSandacustomtruststoreconfiguration]]
Consuming a remote FTPS server (explicit TLS) and a custom trust store configuration
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

[source,java]
----------------------------------------------------------------------------------------------------------------------------------------------------------------
from(""ftps://admin@localhost:2222/public/camel?password=admin&ftpClient.trustStore.file=./src/test/resources/server.jks&ftpClient.trustStore.password=password"")
  .to(""bean:foo"");
----------------------------------------------------------------------------------------------------------------------------------------------------------------

[[FTP2-Filterusingorg.apache.camel.component.file.GenericFileFilter]]
Filter using `org.apache.camel.component.file.GenericFileFilter`
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Camel supports pluggable filtering strategies. This strategy it to use
the build in `org.apache.camel.component.file.GenericFileFilter` in
Java. You can then configure the endpoint with such a filter to skip
certain filters before being processed.

In the sample we have built our own filter that only accepts files
starting with report in the filename.

And then we can configure our route using the *filter* attribute to
reference our filter (using `#` notation) that we have defined in the
spring XML file:

[source,xml]
---------------------------------------------------------------------------------------
   <!-- define our sorter as a plain spring bean -->
   <bean id=""myFilter"" class=""com.mycompany.MyFileFilter""/>

  <route>
    <from uri=""ftp://someuser@someftpserver.com?password=secret&amp;filter=#myFilter""/>
    <to uri=""bean:processInbox""/>
  </route>
---------------------------------------------------------------------------------------

[[FTP2-FilteringusingANTpathmatcher]]
Filtering using ANT path matcher
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

The ANT path matcher is a filter that is shipped out-of-the-box in the
*camel-spring* jar. So you need to depend on *camel-spring* if you are
using Maven. +
 The reason is that we leverage Spring's
http://static.springsource.org/spring/docs/3.0.x/api/org/springframework/util/AntPathMatcher.html[AntPathMatcher]
to do the actual matching.

The file paths are matched with the following rules:

* `?` matches one character
* `*` matches zero or more characters
* `**` matches zero or more directories in a path

The sample below demonstrates how to use it:

[[FTP2-UsingaproxywithSFTP]]
Using a proxy with SFTP
^^^^^^^^^^^^^^^^^^^^^^^

To use an HTTP proxy to connect to your remote host, you can configure
your route in the following way:

[source,xml]
-------------------------------------------------------------------------------------
<!-- define our sorter as a plain spring bean -->
<bean id=""proxy"" class=""com.jcraft.jsch.ProxyHTTP"">
  <constructor-arg value=""localhost""/>
  <constructor-arg value=""7777""/>
</bean>

<route>
  <from uri=""sftp://localhost:9999/root?username=admin&password=admin&proxy=#proxy""/>
  <to uri=""bean:processFile""/>
</route>
-------------------------------------------------------------------------------------

You can also assign a user name and password to the proxy, if necessary.
Please consult the documentation for `com.jcraft.jsch.Proxy` to discover
all options.

[[FTP2-SettingpreferredSFTPauthenticationmethod]]
Setting preferred SFTP authentication method
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

If you want to explicitly specify the list of authentication methods
that should be used by `sftp` component, use `preferredAuthentications`
option. If for example you would like Camel to attempt to authenticate
with private/public SSH key and fallback to user/password authentication
in the case when no public key is available, use the following route
configuration:

[source,java]
-------------------------------------------------------------------------------------------------------------
from(""sftp://localhost:9999/root?username=admin&password=admin&preferredAuthentications=publickey,password"").
  to(""bean:processFile"");
-------------------------------------------------------------------------------------------------------------

[[FTP2-Consumingasinglefileusingafixedname]]
Consuming a single file using a fixed name
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

When you want to download a single file and knows the file name, you can
use `fileName=myFileName.txt` to tell Camel the name of the file to
download. By default the consumer will still do a FTP LIST command to do
a directory listing and then filter these files based on the `fileName`
option. Though in this use-case it may be desirable to turn off the
directory listing by setting `useList=false`. For example the user
account used to login to the FTP server may not have permission to do a
FTP LIST command. So you can turn off this with `useList=false`, and
then provide the fixed name of the file to download with
`fileName=myFileName.txt`, then the FTP consumer can still download the
file. If the file for some reason does not exist, then Camel will by
default throw an exception, you can turn this off and ignore this by
setting `ignoreFileNotFoundOrPermissionError=true`.

For example to have a Camel route that pickup a single file, and delete
it after use you can do

[source,java]
-------------------------------------------------------------------------------------------------------------------------------------------------------------
from(""ftp://admin@localhost:21/nolist/?password=admin&stepwise=false&useList=false&ignoreFileNotFoundOrPermissionError=true&fileName=report.txt&delete=true"")
  .to(""activemq:queue:report"");
-------------------------------------------------------------------------------------------------------------------------------------------------------------

Notice that we have use all the options we talked above above.

You can also use this with `ConsumerTemplate`. For example to download a
single file (if it exists) and grab the file content as a String type:

[source,java]
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
String data = template.retrieveBodyNoWait(""ftp://admin@localhost:21/nolist/?password=admin&stepwise=false&useList=false&ignoreFileNotFoundOrPermissionError=true&fileName=report.txt&delete=true"", String.class);
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

[[FTP2-Debuglogging]]
Debug logging
^^^^^^^^^^^^^

This component has log level *TRACE* that can be helpful if you have
problems.

[[FTP2-SeeAlso]]
See Also
^^^^^^^^

* link:configuring-camel.html[Configuring Camel]
* link:component.html[Component]
* link:endpoint.html[Endpoint]
* link:getting-started.html[Getting Started]

* link:file2.html[File2]

",12160,False,2046.0979399783132,median
"/*++

Copyright (c) 1998-2000  Microsoft Corporation

Module Name:

    rdpdr.cpp

Abstract:

    This module implements the driver initialization for the RDP redirector,
    and the dispatch routines for the master device object. The master
    device object mostly ignores real I/O operations

Environment:

    Kernel mode

--*/
#include ""precomp.hxx""
#define TRC_FILE ""rdpdr""
#include ""trc.h""
#include ""ntddmup.h""
#include ""TSQPublic.h""

HANDLE DrSystemProcessId;
PSECURITY_DESCRIPTOR DrAdminSecurityDescriptor = NULL;
ULONG DrSecurityDescriptorLength = 0;
extern ULONG DebugBreakOnEntry;

//
//  Default USBMON Port Write Size.  Need to keep it under 64k for 
//  16-bit clients ... otherwise, the go off the end of a segment.
//
ULONG PrintPortWriteSize;
ULONG PrintPortWriteSizeDefault = 63000; // bytes
//
// Maximum numer of TS worker threads
//
#define MAX_WORKER_THREADS_COUNT     5
ULONG MaxWorkerThreadsDefault = MAX_WORKER_THREADS_COUNT;
ULONG MaxWorkerThreads = MAX_WORKER_THREADS_COUNT;

// The TS Worker Queue pointer
PVOID RDPDR_TsQueue = NULL;


//
//  Configure Devices to send IO packets to client at low priority.
//
ULONG DeviceLowPrioSendFlags;   
ULONG DeviceLowPrioSendFlagsDefault = DEVICE_LOWPRIOSEND_PRINTERS;

extern ""C"" BOOLEAN RxForceQFIPassThrough;

NTSTATUS DrCreateSCardDevice(SmartPtr<DrSession> &Session, PV_NET_ROOT pVNetRoot,
               SmartPtr<DrDevice> &Device);

//
//  This is the minirdr dispatch table. It is initialized by DrInitializeTables.
//  This table will be used by the wrapper to call into this minirdr
//

struct _MINIRDR_DISPATCH  DrDispatch;

#if DBG
UCHAR IrpNames[IRP_MJ_MAXIMUM_FUNCTION + 1][40] = {
    ""IRP_MJ_CREATE                  "",
    ""IRP_MJ_CREATE_NAMED_PIPE       "",
    ""IRP_MJ_CLOSE                   "",
    ""IRP_MJ_READ                    "",
    ""IRP_MJ_WRITE                   "",
    ""IRP_MJ_QUERY_INFORMATION       "",
    ""IRP_MJ_SET_INFORMATION         "",
    ""IRP_MJ_QUERY_EA                "",
    ""IRP_MJ_SET_EA                  "",
    ""IRP_MJ_FLUSH_BUFFERS           "",
    ""IRP_MJ_QUERY_VOLUME_INFORMATION"",
    ""IRP_MJ_SET_VOLUME_INFORMATION  "",
    ""IRP_MJ_DIRECTORY_CONTROL       "",
    ""IRP_MJ_FILE_SYSTEM_CONTROL     "",
    ""IRP_MJ_DEVICE_CONTROL          "",
    ""IRP_MJ_INTERNAL_DEVICE_CONTROL "",
    ""IRP_MJ_SHUTDOWN                "",
    ""IRP_MJ_LOCK_CONTROL            "",
    ""IRP_MJ_CLEANUP                 "",
    ""IRP_MJ_CREATE_MAILSLOT         "",
    ""IRP_MJ_QUERY_SECURITY          "",
    ""IRP_MJ_SET_SECURITY            "",
    ""IRP_MJ_POWER                   "",
    ""IRP_MJ_SYSTEM_CONTROL          "",
    ""IRP_MJ_DEVICE_CHANGE           "",
    ""IRP_MJ_QUERY_QUOTA             "",
    ""IRP_MJ_SET_QUOTA               "",
    ""IRP_MJ_PNP                     ""
};
#endif // DBG

//
// Pointer to the device Object for this minirdr. Since the device object is created
// by the wrapper when this minirdr registers, this pointer is initialized in the
// DriverEntry routine below (see RxRegisterMinirdr)
//

PRDBSS_DEVICE_OBJECT      DrDeviceObject = NULL;
PRDBSS_DEVICE_OBJECT      DrPortDeviceObject = NULL;
DrSessionManager *Sessions = NULL;

//
// A global spinlock
//
KSPIN_LOCK DrSpinLock;
KIRQL DrOldIrql;

//
// A global mutex
//
FAST_MUTEX DrMutex;

//
//  Global Registry Path for RDPDR.SYS
//
UNICODE_STRING            DrRegistryPath;

//
// The following enumerated values signify the current state of the minirdr
// initialization. With the aid of this state information, it is possible
// to determine which resources to deallocate, whether deallocation comes
// as a result of a normal stop/unload, or as the result of an exception
//

typedef enum tagDrInitStates {
    DrUninitialized,
    DrRegistered,
    DrInitialized
} DrInitStates;

//
// function prototypes
//

extern ""C"" {
NTSTATUS
DrInitializeTables(
    void
    );
NTSTATUS
CreateAdminSecurityDescriptor(
    VOID
    );
    
NTSTATUS
BuildDeviceAcl(
    OUT PACL *DeviceAcl
    );

NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT  DriverObject,
    IN PUNICODE_STRING RegistryPath
    );

NTSTATUS
DrPeekDispatch (
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

VOID
DrUninitialize(
    IN PDRIVER_OBJECT DriverObject,
    IN DrInitStates DrInitState
    );

NTSTATUS
DrLoadRegistrySettings (
    IN PCWSTR   RegistryPath
    );

NTSTATUS
DrStart(
    PRX_CONTEXT RxContext,
    IN OUT PRDBSS_DEVICE_OBJECT RxDeviceObject
    );

NTSTATUS
DrStop(
    PRX_CONTEXT RxContext,
    IN OUT PRDBSS_DEVICE_OBJECT RxDeviceObject
    );

NTSTATUS
DrDeallocateForFcb(
    IN OUT PMRX_FCB pFcb
    );

NTSTATUS
ObGetObjectSecurity(
    IN PVOID Object,
    OUT PSECURITY_DESCRIPTOR *SecurityDescriptor,
    OUT PBOOLEAN MemoryAllocated
    );

VOID
ObReleaseObjectSecurity(
    IN PSECURITY_DESCRIPTOR SecurityDescriptor,
    IN BOOLEAN MemoryAllocated
    );

NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT  DriverObject,
    IN PUNICODE_STRING RegistryPath
    );

};

BOOL GetDeviceFromRxContext(PRX_CONTEXT RxContext, SmartPtr<DrDevice> &Device);

#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT, DriverEntry)
#endif

WCHAR DrDriverName[] = RDPDR_DEVICE_NAME_U;
WCHAR DrPortDriverName[] = RDPDR_PORT_DEVICE_NAME_U;

NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT  DriverObject,
    IN PUNICODE_STRING RegistryPath
    )
/*++

Routine Description:

    This is the initialization routine for the RDP mini redirector

Arguments:

    DriverObject - Pointer to driver object created by the system.

Return Value:

    RXSTATUS - The function value is the final status from the initialization
        operation.

--*/
{
    NTSTATUS       Status;
    UNICODE_STRING RdpDrName;
    UNICODE_STRING RdpDrPortName;
    PDEVICE_OBJECT  RdpDrDevice;
    DrInitStates DrInitState = DrUninitialized;
    PRX_CONTEXT RxContext;
    PWCHAR  path;

    BEGIN_FN(""DriverEntry"");

#ifdef MONOLITHIC_MINIRDR
    Status =  RxDriverEntry(DriverObject, RegistryPath);
    TRC_NRM((TB, ""BackFromInitWrapper %08lx"", Status));
    if (!NT_SUCCESS(Status)) {
        TRC_ERR((TB, ""Wrapper failed to initialize. "" 
                ""Status = %08lx"", Status));

        DbgPrint(""rdpdr.sys erroring out (#1)\\n"");
        DbgBreakPoint();

        return Status;
    }
#endif

    //
    //  Copy the registry path for RDPDR.SYS.
    //
    path = (PWCHAR)new(NonPagedPool) WCHAR[RegistryPath->Length + 1];
    if (!path) {
        TRC_ERR((TB, ""DR:Failed to allocate registry path %Wz"",
                RegistryPath));

        DbgPrint(""rdpdr.sys erroring out (#2)\\n"");
        DbgBreakPoint();

        Status = STATUS_INSUFFICIENT_RESOURCES;
        return (Status);
    }
    RtlZeroMemory(path, RegistryPath->Length+sizeof(WCHAR));
    RtlMoveMemory(path, RegistryPath->Buffer, RegistryPath->Length);
    DrRegistryPath.Length           = RegistryPath->Length;
    DrRegistryPath.MaximumLength    = RegistryPath->Length+sizeof(WCHAR);
    DrRegistryPath.Buffer           = path;

    //
    //  Load registry settings.
    //
    DrLoadRegistrySettings(path);

#if DBG
    if (DebugBreakOnEntry) {
        DbgBreakPoint();
    }
#endif 


    CodePageConversionInitialize();

    // Initialize the client list
    KeInitializeSpinLock(&DrSpinLock);

    // Initialize the mutex object for device I/O transaction exchange
    ExInitializeFastMutex(&DrMutex);

    if (InitializeKernelUtilities()) {
        Status = STATUS_SUCCESS;
    } else {
        Status = STATUS_INSUFFICIENT_RESOURCES;

        DbgPrint(""rdpdr.sys erroring out (#3)\\n"");
        DbgBreakPoint();
    }

    if (NT_SUCCESS(Status)) {
        Sessions = new(NonPagedPool) DrSessionManager;

        if (Sessions != NULL) {
            Status = STATUS_SUCCESS;
            TRC_NRM((TB, ""Created DrSessionManager""));
        } else {
            TRC_ERR((TB, ""Unable to create DrSessionManager""));
            Status = STATUS_INSUFFICIENT_RESOURCES;

            DbgPrint(""rdpdr.sys erroring out (#4)\\n"");
            DbgBreakPoint();
        }
    }

    if (NT_SUCCESS(Status)) {
        RtlInitUnicodeString(&RdpDrPortName, DrPortDriverName);

        // Create the port device object.
        Status = IoCreateDevice(DriverObject,
                    0,
                    &RdpDrPortName,
                    FILE_DEVICE_NETWORK_REDIRECTOR,
                    0,
                    FALSE,
                    (PDEVICE_OBJECT *)(&DrPortDeviceObject));
    }
    else {
        TRC_ERR((TB, ""IoCreateDevice failed: %08lx"", Status ));

        DbgPrint(""rdpdr.sys erroring out (#5)\\n"");
        DbgBreakPoint();

        return Status;
    }

    if (NT_SUCCESS(Status)) {
        //
        //  Register the RdpDr with the connection engine. Registration 
        //  makes the connection engine aware of the device name, driver 
        //  object, and other characteristics. If registration is successful, 
        //  a new device object is returned
        //
        //  The name of the device is L""\\\\Device\\\\RdpDr""
        //
                                       
        RtlInitUnicodeString(&RdpDrName, DrDriverName);
        
        TRC_DBG((TB, ""Registering minirdr""));

        Status = RxRegisterMinirdr(
                     &DrDeviceObject,   // where the new device object goes
                     DriverObject,      // the Driver Object to register
                     &DrDispatch,       // the dispatch table for this driver
                     RX_REGISTERMINI_FLAG_DONT_PROVIDE_MAILSLOTS,
                     &RdpDrName,        // the device name for this minirdr
                     0,                 // IN ULONG DeviceExtensionSize,
                     FILE_DEVICE_NETWORK_FILE_SYSTEM, // In DEVICE_TYPE DeviceType
                     0                  // IN ULONG DeviceCharacteristics
                     );        
    }
    
    if (NT_SUCCESS(Status)) {
        PSECURITY_DESCRIPTOR RdpDrSD = NULL;
        BOOLEAN memoryAllocated = FALSE;
        
        TRC_NRM((TB, ""RxRegisterMinirdr succeeded.""));
        //
        // Get the SD for the rdpdr device object.
        // Apply the same SD to the rdp port device object.
        //
        if (NT_SUCCESS(ObGetObjectSecurity(DrDeviceObject, 
                       &RdpDrSD, 
                       &memoryAllocated))) {
            if (!NT_SUCCESS(ObSetSecurityObjectByPointer((PDEVICE_OBJECT)DrPortDeviceObject, 
                                                          DACL_SECURITY_INFORMATION, 
                                                          RdpDrSD
                                                         ))) {
                //
                // We will ignore the error.
                //
                TRC_ERR((TB, ""ObSetSecurityObjectByPointer failed: 0x%08lx"", Status ));
            }
            ObReleaseObjectSecurity(RdpDrSD, memoryAllocated);
        }
        else {
            //
            // We will ignore the error. Just log the error
            //
            TRC_ERR((TB, ""ObGetObjectSecurity failed: 0x%08lx"", Status ));
        }

        //
        // After this we can't just return, some uninitialization is 
        // needed if we fail or unload
        //

        DrInitState = DrRegistered;

        Status = CreateAdminSecurityDescriptor();
    } else {
        TRC_ERR((TB, ""RxRegisterMinirdr failed: %08lx"", Status ));

        DbgPrint(""rdpdr.sys erroring out (#6)\\n"");
        DbgBreakPoint();

        if (DrPortDeviceObject) {
            IoDeleteDevice((PDEVICE_OBJECT) DrPortDeviceObject);
            DrPortDeviceObject = NULL;
        }

        return Status;
    }

    if (NT_SUCCESS(Status)) {
        //
        // Build the dispatch tables for the minirdr
        //

        Status = DrInitializeTables();

    } else {
        TRC_ERR((TB, ""CreateAdminSecurityDescriptor failed: 0x%08lx"", Status ));

        DbgPrint(""rdpdr.sys erroring out (#7)\\n"");
        DbgBreakPoint();
    }
    //
    // Initialize our TS worker queue module.
    //
    TRC_NRM((TB, ""RDPDR: Initialize TS Worker Queue""));
    RDPDR_TsQueue = TSInitQueue( TSQUEUE_OWN_THREAD, 
                                 MaxWorkerThreads, 
                                 (PDEVICE_OBJECT)DrDeviceObject );

    if ( RDPDR_TsQueue == NULL) {
        TRC_ERR((TB, ""RDPDR: Failed to initialize the TS Queue""));
        DbgPrint(""rdpdr.sys erroring out (#8)\\n"");
        Status = STATUS_INSUFFICIENT_RESOURCES;
    } 


    if (NT_SUCCESS(Status)) {
        //
        //  Setup Unload Routine
        //

        DriverObject->DriverUnload = DrUnload;

        //
        //  Set up the PnP AddDevice entry point.
        //

        DriverObject->DriverExtension->AddDevice = RDPDRPNP_PnPAddDevice;

        //
        // setup the DriverDispatch for people who come in here directly
        // ....like the browser
        //

        {
            ULONG i;

            for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
            {
                DriverObject->MajorFunction[i] = (PDRIVER_DISPATCH)DrPeekDispatch;
            }
        }
        DrSystemProcessId = PsGetCurrentProcessId();
    } else {

        DbgPrint(""rdpdr.sys erroring out (#9)\\n"");
        DbgBreakPoint();

        DrUninitialize(DriverObject, DrInitState);
    }

    return Status;
}

VOID
DrUninitialize(
    IN PDRIVER_OBJECT DriverObject,
    IN DrInitStates DrInitState
    )
/*++

Routine Description:

     This routine does the common uninit work 

Arguments:

     DrInitState - tells how far we got into the intialization

Return Value:

     None

--*/

{
    PRX_CONTEXT RxContext;
    NTSTATUS    Status;

    BEGIN_FN(""DrUninitialize"");

    PAGED_CODE();
    RxContext = RxCreateRxContext(
                    NULL,
                    DrDeviceObject,
                    RX_CONTEXT_FLAG_IN_FSP);

    if (RxContext != NULL) {
        Status = RxStopMinirdr(
                     RxContext,
                     &RxContext->PostRequest);

        RxDereferenceAndDeleteRxContext(RxContext);
    } else {
        Status = STATUS_INSUFFICIENT_RESOURCES;
    }

    CodePageConversionCleanup();

    if (DrAdminSecurityDescriptor) {
        delete DrAdminSecurityDescriptor;
        DrAdminSecurityDescriptor = NULL;
        DrSecurityDescriptorLength = 0;
    }

    if (Sessions != NULL) {
        delete Sessions;
        Sessions = NULL;
    }

    if (DrRegistryPath.Buffer != NULL) {
        delete DrRegistryPath.Buffer;
        DrRegistryPath.Buffer = NULL;
    }

    //
    // Delete the TS Queue
    //
    if ( RDPDR_TsQueue != NULL) {
        if (TSDeleteQueue( RDPDR_TsQueue ) != STATUS_SUCCESS) {
            TRC_ERR((TB, ""RDPDR: TsDeleteQueue Failed""));
        }
    }


    UninitializeKernelUtilities();

    switch (DrInitState) {
    case DrInitialized:

#ifdef MONOLITHIC_MINIRDR
    RxUnload(DriverObject);
#endif

    case DrRegistered:
        RxUnregisterMinirdr(DrDeviceObject);
    }

    if (DrPortDeviceObject) {
        IoDeleteDevice((PDEVICE_OBJECT) DrPortDeviceObject);
        DrPortDeviceObject = NULL;
    }
}

VOID
DrUnload(
    IN PDRIVER_OBJECT DriverObject
    )
/*++

Routine Description:

    This is the dispatch routine for Unload.

Arguments:

    DriverObject - Pointer to the driver object controling all of the
                   devices.

Return Value:

    None.

--*/

{
    BEGIN_FN(""DrUnload"");
    PAGED_CODE();
    TRC_NRM((TB, ""DriverObject =%p"", DriverObject));

    DrUninitialize(DriverObject, DrInitialized);


    TRC_NRM((TB, ""MRxIfsUnload exit: DriverObject =%p"", 
            DriverObject));
}

NTSTATUS
DrFlush(
    IN OUT PRX_CONTEXT RxContext
    )
/*++

Routine Description:

    This is the dispatch routine for flush operations.

Arguments:

    RxContext - RDBSS context structure for our mini-redir

Return Value:

    Could return status success, cancelled, or pending.

--*/

{
    BEGIN_FN(""DrFlush"");
    return STATUS_SUCCESS;
}

NTSTATUS
DrWrite(
    IN OUT PRX_CONTEXT RxContext
    )
/*++

Routine Description:

    This is the dispatch routine for write operations.

Arguments:

    RxContext - RDBSS context structure for our mini-redir

Return Value:

    Could return status success, cancelled, or pending.

--*/

{
    SmartPtr<DrDevice> Device;

    BEGIN_FN(""DrWrite"");
    
    TRC_NRM((TB, ""DrWrite""));

    GetDeviceFromRxContext(RxContext, Device);

    return Device->Write(RxContext);
}

NTSTATUS
DrRead(
    IN OUT PRX_CONTEXT RxContext
    )
/*++

Routine Description:

    This is the dispatch routine for read operations.

Arguments:

    RxContext - RDBSS context structure for our mini-redir

Return Value:

    Could return status success, cancelled, or pending.

--*/

{
    SmartPtr<DrDevice> Device;

    BEGIN_FN(""DrRead"");
    
    TRC_NRM((TB, ""DrRead""));

    GetDeviceFromRxContext(RxContext, Device);

    return Device->Read(RxContext);
}

NTSTATUS
DrIoControl(
    IN OUT PRX_CONTEXT RxContext
    )
/*++

Routine Description:

    This is the dispatch routine for IoControl operations.

Arguments:

    RxContext - RDBSS context structure for our mini-redir

Return Value:

    Could return status success, cancelled, or pending.

--*/

{
    SmartPtr<DrDevice> Device;

    BEGIN_FN(""DrIoControl"");
    
    TRC_NRM((TB, ""DrIoControl""));

    if (GetDeviceFromRxContext(RxContext, Device))
        return Device->IoControl(RxContext);
    else
        return STATUS_UNSUCCESSFUL;
}

NTSTATUS
DrShouldTryToCollapseThisOpen(
    IN OUT PRX_CONTEXT RxContext
    )
/*++

Routine Description:

   This routine determines if the mini knows of a good reason not
   to try collapsing on this open. 

Arguments:

    RxContext - Context for the operation

Return Value:

    NTSTATUS - The return status for the operation
        SUCCESS --> okay to try collapse
        other (MORE_PROCESSING_REQUIRED) --> dont collapse

--*/
{
    NTSTATUS Status = STATUS_SUCCESS;
    RxCaptureFcb;

    BEGIN_FN(""DrShouldTryToCollapseThisOpen"");

    PAGED_CODE();

    TRC_NRM((TB, ""DrShouldTryToCollapseThisOpen not implemented""));
    return STATUS_NOT_IMPLEMENTED;
}

ULONG
DrExtendForNonCache(
    IN OUT struct _RX_CONTEXT * RxContext,
    IN     PLARGE_INTEGER   pNewFileSize,
       OUT PLARGE_INTEGER   pNewAllocationSize
    )
/*++

Routine Description:

   This routine handles network requests to extend the file for noncached IO. since the write
   itself will extend the file, we can pretty much just get out quickly.

Arguments:

    RxContext - the RDBSS context

Return Value:

    RXSTATUS - The return status for the operation

--*/
{
    NTSTATUS Status = STATUS_SUCCESS;
    
    pNewAllocationSize->QuadPart = pNewFileSize->QuadPart;

    return (ULONG)Status;
}

NTSTATUS
DrTruncate(
    IN OUT PRX_CONTEXT RxContext
    )
/*++

Routine Description:

   This routine determines Truncate operation 

Arguments:

    RxContext - Context for the operation

Return Value:

    NTSTATUS - The return status for the operation        

--*/
{
    BEGIN_FN(""DrTruncate"");

    TRC_ERR((TB, ""DrTruncate not implemented""));
    return STATUS_NOT_IMPLEMENTED;
}


NTSTATUS DrCreate(IN OUT PRX_CONTEXT RxContext)
/*++

Routine Description:

    Opens a file (or device) across the network

Arguments:

    RxContext - Context for the operation

Return Value:

    Could return status success, cancelled, or pending.

--*/

{
    NTSTATUS Status;
    RxCaptureFcb;
    PMRX_SRV_CALL SrvCall = RxContext->Create.pSrvCall;
    PMRX_NET_ROOT NetRoot = RxContext->Create.pNetRoot;
    PMRX_V_NET_ROOT VNetRoot = RxContext->Create.pVNetRoot;
    SmartPtr<DrSession> Session;
    DrDevice *pDevice;
    SmartPtr<DrDevice> Device, DeviceNew;

    BEGIN_FN(""DrCreate"");

    TRC_NRM((TB, ""DrCreate""));

    //
    // Make sure the device is still enabled, Protect the
    // VNetRoot Context (the DeviceEntry) with the device list 
    // SpinLock because we may change it
    //
    
    DrAcquireSpinLock();
    Device = (DrDevice *)VNetRoot->Context;
    ASSERT(Device != NULL);
    DrReleaseSpinLock();

    //
    // Make sure it's okay to access the Client at this time
    // This is an optimization, we don't need to acquire the spin lock,
    // because it is okay if we're not, we'll just catch it later
    //
    Session = Device->GetSession();

    ASSERT(Session != NULL);

    if (!Session->IsConnected() && (Device->GetDeviceType() != RDPDR_DTYP_SMARTCARD)) {
        TRC_ALT((TB, ""Tried to open client device while not ""
            ""connected. State: %ld"", Session->GetState()));
        return STATUS_DEVICE_NOT_CONNECTED;
    }
    
    //
    // We leave the SpinLock after we get our reference to the device. It could
    // change while we're gone, but since everything is reference counted it
    // is safe to put the correct pointer in later
    //

    if (!Device->IsAvailable()) {
        TRC_ALT((TB, ""Tried to open client device which is not ""
            ""available. ""));
    
        if (Device->GetDeviceType() == RDPDR_DTYP_SMARTCARD &&
                !Session->FindDeviceByDosName((UCHAR *)DR_SMARTCARD_SUBSYSTEM, 
                                              DeviceNew, TRUE)) {
            Status = DrCreateSCardDevice(Session, NULL, DeviceNew);

            if (Status != STATUS_SUCCESS) {
                return STATUS_DEVICE_NOT_CONNECTED;
            }            
        }

        if (Device->GetDeviceType() == RDPDR_DTYP_SMARTCARD ||
                Session->FindDeviceById(Device->GetDeviceId(), DeviceNew, TRUE)) {

            //
            // There's a new DeviceEntry for this device. Replace the old
            // one in the VNetRoot with this one. We also need an extra 
            // reference to stick in the fobx so we can track whether
            // this particular open is using an old DeviceEntry or a new
            // one
            //

            // Put it in the netroot, safely swapping in and manually
            // bumping the reference count up going in and down going out

            DeviceNew->AddRef();
            DrAcquireSpinLock();

            pDevice = (DrDevice *)VNetRoot->Context;
            VNetRoot->Context = (DrDevice *)DeviceNew;
            DrReleaseSpinLock();

#if DBG
            pDevice->_VNetRoot = NULL;
#endif

            pDevice->Release();
            pDevice = NULL;
            Device = DeviceNew;
        } else {

            //
            // The device is disabled, but we didn't find a shiny new
            // version with which to replace it. Leave the icky old disabled
            // one there so we know what to look for later, and return the
            // device not connected error.
            // 

            return STATUS_DEVICE_NOT_CONNECTED;
        }
    }

    return Device->Create(RxContext);
}

BOOL GetDeviceFromRxContext(PRX_CONTEXT RxContext, SmartPtr<DrDevice> &Device)
{
    BOOL rc = FALSE;
    PMRX_SRV_OPEN SrvOpen = RxContext->pRelevantSrvOpen;
    PMRX_V_NET_ROOT VNetRoot;
     
    BEGIN_FN(""GetDeviceFromRxContext"");
    if (SrvOpen == NULL) {
        goto Exit;
    }
    VNetRoot= SrvOpen->pVNetRoot;
    if (VNetRoot == NULL) {
        goto Exit;
    }

    DrAcquireSpinLock();
    Device = (DrDevice *)VNetRoot->Context;
    DrReleaseSpinLock();
    ASSERT(Device != NULL);

    rc = TRUE;
Exit:
    return rc;
}

NTSTATUS DrCloseSrvOpen(IN OUT PRX_CONTEXT RxContext)
/*++

Routine Description:

    This is the dispatch routine for close operations.

Arguments:

    RxContext - RDBSS context structure for our mini-redir

Return Value:

    Could return status success, cancelled, or pending.

--*/

{
    SmartPtr<DrDevice> Device;

    BEGIN_FN(""DrCloseSrvOpen"");
    
    TRC_NRM((TB, ""DrCloseSrvOpen""));

    GetDeviceFromRxContext(RxContext, Device);

    return Device->Close(RxContext);
}

NTSTATUS DrCleanupFobx(IN OUT PRX_CONTEXT RxContext)
/*++

Routine Description:

    This is the dispatch routine for cleaning up Fobx.

Arguments:

    RxContext - RDBSS context structure for our mini-redir

Return Value:

    Could return status success, cancelled, or pending.

--*/

{
    RxCaptureFobx;
    
    BEGIN_FN(""DrCleanupFobx"");
    
    TRC_NRM((TB, ""DrCleanupFobx""));
    
    return STATUS_SUCCESS;
}

NTSTATUS DrCleanup(IN OUT PRX_CONTEXT RxContext)
/*++

Routine Description:

    This is the dispatch routine for cleanup operations.

Arguments:

    RxContext - RDBSS context structure for our mini-redir

Return Value:

    Could return status success, cancelled, or pending.

--*/

{
    SmartPtr<DrDevice> Device;

    BEGIN_FN(""DrCleanup"");
    
    TRC_NRM((TB, ""DrCleanup""));

    GetDeviceFromRxContext(RxContext, Device);

    return Device->Cleanup(RxContext);
}


NTSTATUS
DrQueryDirectory(
    IN OUT PRX_CONTEXT RxContext
    )
/*++

Routine Description:

    This is the dispatch routine for Query Direcotry information.

Arguments:

    RxContext - RDBSS context structure for our mini-redir

Return Value:

    Could return status success, cancelled, or pending.

--*/

{   
    SmartPtr<DrDevice> Device;

    BEGIN_FN(""DrQueryDirecotry"");

    TRC_NRM((TB, ""DrQueryDirectory""));

    GetDeviceFromRxContext(RxContext, Device);

    return Device->QueryDirectory(RxContext);
}


NTSTATUS
DrQueryVolumeInfo(
    IN OUT PRX_CONTEXT RxContext
    )
/*++

Routine Description:

    This is the dispatch routine for Query Volume Information.

Arguments:

    RxContext - RDBSS context structure for our mini-redir
                                              
Return Value:

    Could return status success, cancelled, or pending.

--*/

{
    SmartPtr<DrDevice> Device;
    
    BEGIN_FN(""DrQueryVolumeInfo"");
    
    TRC_NRM((TB, ""DrQueryVolumeInfo""));

    GetDeviceFromRxContext(RxContext, Device);

    return Device->QueryVolumeInfo(RxContext);
}

NTSTATUS
DrSetVolumeInfo(
    IN OUT PRX_CONTEXT RxContext
    )
/*++

Routine Description:

    This is the dispatch routine for Set Volume Information.

Arguments:

    RxContext - RDBSS context structure for our mini-redir

Return Value:

    Could return status success, cancelled, or pending.

--*/

{
    SmartPtr<DrDevice> Device;
    
    BEGIN_FN(""DrSetVolumeInfo"");
    
    TRC_NRM((TB, ""DrSetVolumeInfo""));

    GetDeviceFromRxContext(RxContext, Device);

    return Device->SetVolumeInfo(RxContext);
}

NTSTATUS
DrQuerySdInfo(
    IN OUT PRX_CONTEXT RxContext
    )
/*++

Routine Description:

    This is the dispatch routine for Query Security Information.

Arguments:

    RxContext - RDBSS context structure for our mini-redir

Return Value:

    Could return status success, cancelled, or pending.

--*/

{
    SmartPtr<DrDevice> Device;

    BEGIN_FN(""DrQuerySdInfo"");
    
    TRC_NRM((TB, ""DrQuerySdInfo""));

    GetDeviceFromRxContext(RxContext, Device);

    return Device->QuerySdInfo(RxContext);
}

NTSTATUS
DrSetSdInfo(
    IN OUT PRX_CONTEXT RxContext
    )
/*++

Routine Description:

    This is the dispatch routine for Set Security Information.

Arguments:

    RxContext - RDBSS context structure for our mini-redir
                                            
Return Value:

    Could return status success, cancelled, or pending.

--*/

{
    SmartPtr<DrDevice> Device;

    BEGIN_FN(""DrSetSdInfo"");
    
    TRC_NRM((TB, ""DrSetSdInfo""));

    GetDeviceFromRxContext(RxContext, Device);

    return Device->SetSdInfo(RxContext);
}


NTSTATUS
DrQueryFileInfo(
    IN OUT PRX_CONTEXT RxContext
    )
/*++

Routine Description:

    This is the dispatch routine for Query File Information.

Arguments:

    RxContext - RDBSS context structure for our mini-redir
                                           
Return Value:

    Could return status success, cancelled, or pending.

--*/

{
    SmartPtr<DrDevice> Device;

    BEGIN_FN(""DrQueryFileInfo"");
    
    TRC_NRM((TB, ""DrQueryFileInfo""));

    GetDeviceFromRxContext(RxContext, Device);

    return Device->QueryFileInfo(RxContext);
}

NTSTATUS
DrSetFileInfo(
    IN OUT PRX_CONTEXT RxContext
    )
/*++

Routine Description:

    This is the dispatch routine for SetFileInformation.

Arguments:

    RxContext - RDBSS context structure for our mini-redir

Return Value:

    Could return status success, cancelled, or pending.

--*/

{    
    SmartPtr<DrDevice> Device;
    
    BEGIN_FN(""DrSetFileInfo"");

    TRC_NRM((TB, ""DrSetFileInfo""));
    
    GetDeviceFromRxContext(RxContext, Device);

    return Device->SetFileInfo(RxContext);
}

NTSTATUS
DrSetFileInfoAtCleanUp(
    IN OUT PRX_CONTEXT RxContext
    )
/*++

Routine Description:

    This is the dispatch routine for SetFileInformationAtCleanUp.

Arguments:

    DeviceObject - Pointer to the device object for this device

    Irp - Pointer to the IRP for the current request

Return Value:

    Could return status success, cancelled, or pending.

--*/

{
    BEGIN_FN(""DrSetFileInfoAtCleanUp"");
    
    TRC_NRM((TB, ""DrSetFileInfoAtCleanUp""));

    return STATUS_SUCCESS;
}

NTSTATUS
DrLocks(
    IN OUT PRX_CONTEXT RxContext
    )
/*++

Routine Description:

    This is the dispatch routine for file locking.

Arguments:

    RxContext - RDBSS context structure for our mini-redir

Return Value:

    Could return status success, cancelled, or pending.

--*/

{
    SmartPtr<DrDevice> Device;

    BEGIN_FN(""DrLocks"");
    
    TRC_NRM((TB, ""DrLocks""));

    GetDeviceFromRxContext(RxContext, Device);

    return Device->Locks(RxContext);
}

NTSTATUS
DrIsLockRealizable(
    IN OUT PMRX_FCB pFcb,
    IN PLARGE_INTEGER  ByteOffset,
    IN PLARGE_INTEGER  Length,
    IN ULONG  LowIoLockFlags
    )
/*++

Routine Description:

    This is the dispatch routine for IsLockRealizable.

Arguments:

Return Value:

    Could return status success, cancelled, or pending.

--*/

{

    BEGIN_FN(""DrIsLockRealizable"");
    
    TRC_NRM((TB, ""DrIsLockRealizable""));

    //
    //  TODO: We do not support share locks for win9x clients
    //  Can we just return success here and then fail on the 
    //  client share lock function?
    //  
#if 0
    if (!FlagOn(LowIoLockFlags,LOWIO_LOCKSFLAG_EXCLUSIVELOCK)) {
        return STATUS_NOT_SUPPORTED;
    }
#endif

    return STATUS_SUCCESS;
}

NTSTATUS
DrIsValidDirectory(
    IN OUT PRX_CONTEXT    RxContext,
    IN PUNICODE_STRING    DirectoryName
    )
/*++

Routine Description:

    This is the dispatch routine for IsValidDirectory.

Arguments:

    RxContext - RDBSS context structure for our mini-redir
    DirectoryName - name of directory to verify its validity
    
Return Value:

    Could return status success, cancelled, or pending.

--*/

{

    BEGIN_FN(""DrIsValidDirectory"");
    
    TRC_NRM((TB, ""DrIsValidDirectory""));

    //
    //  TODO: Always return success for now.  Need to verify later
    //
    return STATUS_SUCCESS;
}


NTSTATUS
DrNotifyChangeDirectory(
    IN OUT PRX_CONTEXT RxContext
    )
/*++

Routine Description:

    This is the dispatch routine for DrNotifyChangeDirectory.

Arguments:

    RxContext - RDBSS context structure for our mini-redir
    
Return Value:

    Could return status success, cancelled, or pending.

--*/

{
    SmartPtr<DrDevice> Device;

    BEGIN_FN(""DrNotifyChangeDirectory"");
    
    TRC_NRM((TB, ""DrNotifyChangeDirectory""));

    GetDeviceFromRxContext(RxContext, Device);

    return Device->NotifyChangeDirectory(RxContext);    
}


NTSTATUS
DrInitializeTables(
          void
    )
/*++

Routine Description:

     This routine sets up the rdp redirector dispatch vector and also calls
     to initialize any other tables needed.

Return Value:

    NTSTATUS - The return status for the operation

--*/
{
    BEGIN_FN(""DrInitializeTables"");

    //
    // Build the local minirdr dispatch table and initialize
    //

    ZeroAndInitializeNodeType(&DrDispatch, RDBSS_NTC_MINIRDR_DISPATCH, 
            sizeof(MINIRDR_DISPATCH));

    //
    // redirector extension sizes and allocation policies.
    //

    // REVIEW: wtf?
    DrDispatch.MRxFlags = (RDBSS_MANAGE_FCB_EXTENSION |
                               RDBSS_MANAGE_SRV_OPEN_EXTENSION |
                               RDBSS_MANAGE_FOBX_EXTENSION);

    DrDispatch.MRxSrvCallSize  = 0;
    DrDispatch.MRxNetRootSize  = 0;
    DrDispatch.MRxVNetRootSize = 0;
    DrDispatch.MRxFcbSize      = 0; // sizeof(MRX_SMB_FCB);
    DrDispatch.MRxSrvOpenSize  = 0; // sizeof(MRX_SMB_SRV_OPEN);
    DrDispatch.MRxFobxSize     = 0; // sizeof(MRX_SMB_FOBX);

    // Transport update handler

    // REVIEW: How do we indicate we have our own dedicated transport?
    //MRxIfsDispatch.MRxTransportUpdateHandler = MRxIfsTransportUpdateHandler;

    // Mini redirector cancel routine ..

    DrDispatch.MRxCancel = NULL;

    //
    // Mini redirector Start/Stop. Each mini-rdr can be started or stopped
    // while the others continue to operate.
    //

    DrDispatch.MRxStart                = DrStart;
    DrDispatch.MRxStop                 = DrStop;
    DrDispatch.MRxDevFcbXXXControlFile = DrDevFcbXXXControlFile;

    //
    // Mini redirector name resolution.
    //

    DrDispatch.MRxCreateSrvCall       = DrCreateSrvCall;
    DrDispatch.MRxSrvCallWinnerNotify = DrSrvCallWinnerNotify;
    DrDispatch.MRxCreateVNetRoot      = DrCreateVNetRoot;
    DrDispatch.MRxUpdateNetRootState  = DrUpdateNetRootState;
    DrDispatch.MRxExtractNetRootName  = DrExtractNetRootName;
    DrDispatch.MRxFinalizeSrvCall     = DrFinalizeSrvCall;
    DrDispatch.MRxFinalizeNetRoot     = DrFinalizeNetRoot;
    DrDispatch.MRxFinalizeVNetRoot    = DrFinalizeVNetRoot;

    //
    // File System Object Creation/Deletion.
    //

    DrDispatch.MRxCreate            = DrCreate;

    //
    // TODO: Need to implement this for file system redirect caching
    //
    DrDispatch.MRxShouldTryToCollapseThisOpen = DrShouldTryToCollapseThisOpen;
    //DrDispatch.MRxCollapseOpen      = MRxIfsCollapseOpen;
    //DrDispatch.MRxExtendForCache    = MRxIfsExtendFile;
    DrDispatch.MRxExtendForNonCache = DrExtendForNonCache;
    DrDispatch.MRxTruncate          = DrTruncate;   //MRxIfsTruncate;
    
    DrDispatch.MRxCleanupFobx       = DrCleanupFobx;
    
    DrDispatch.MRxCloseSrvOpen      = DrCloseSrvOpen;
    DrDispatch.MRxFlush             = DrFlush;
    DrDispatch.MRxForceClosed       = DrForceClosed;
    DrDispatch.MRxDeallocateForFcb  = DrDeallocateForFcb;
    DrDispatch.MRxDeallocateForFobx = DrDeallocateForFobx;
    DrDispatch.MRxIsLockRealizable  = DrIsLockRealizable;

    //
    // File System Objects query/Set
    //

    DrDispatch.MRxQueryDirectory       = DrQueryDirectory;  //MRxIfsQueryDirectory;
    DrDispatch.MRxQueryVolumeInfo      = DrQueryVolumeInfo; //MRxIfsQueryVolumeInformation;
    DrDispatch.MRxSetVolumeInfo        = DrSetVolumeInfo;   //MRxSmbSetVolumeInformation;
    //DrDispatch.MRxQueryEaInfo        = MRxIfsQueryEaInformation;
    //DrDispatch.MRxSetEaInfo          = MRxIfsSetEaInformation;
    DrDispatch.MRxQuerySdInfo          = DrQuerySdInfo;     //MRxIfsQuerySecurityInformation;
    DrDispatch.MRxSetSdInfo            = DrSetSdInfo;       //MRxIfsSetSecurityInformation;
    //MRxSmbDispatch.MRxQueryQuotaInfo  = MRxSmbQueryQuotaInformation;
    //MRxSmbDispatch.MRxSetQuotaInfo    = MRxSmbSetQuotaInformation;
    DrDispatch.MRxQueryFileInfo        = DrQueryFileInfo;   //MRxIfsQueryFileInformation;
    DrDispatch.MRxSetFileInfo          = DrSetFileInfo;     //MRxIfsSetFileInformation;
    DrDispatch.MRxSetFileInfoAtCleanup = DrSetFileInfoAtCleanUp;  //MRxIfsSetFileInformationAtCleanup;
    DrDispatch.MRxIsValidDirectory     = DrIsValidDirectory;

    //
    // Buffering state change
    //

    //DrDispatch.MRxComputeNewBufferingState = MRxIfsComputeNewBufferingState;

    //
    // File System Object I/O
    //

    DrDispatch.MRxLowIOSubmit[LOWIO_OP_READ]            = DrRead;
    DrDispatch.MRxLowIOSubmit[LOWIO_OP_WRITE]           = DrWrite;
    DrDispatch.MRxLowIOSubmit[LOWIO_OP_SHAREDLOCK]      = DrLocks;
    DrDispatch.MRxLowIOSubmit[LOWIO_OP_EXCLUSIVELOCK]   = DrLocks;
    DrDispatch.MRxLowIOSubmit[LOWIO_OP_UNLOCK]          = DrLocks;
    DrDispatch.MRxLowIOSubmit[LOWIO_OP_UNLOCK_MULTIPLE] = DrLocks;

    DrDispatch.MRxLowIOSubmit[LOWIO_OP_FSCTL]           = DrIoControl;  //MRxIfsFsCtl;

    DrDispatch.MRxLowIOSubmit[LOWIO_OP_IOCTL]           = DrIoControl;

    DrDispatch.MRxLowIOSubmit[LOWIO_OP_NOTIFY_CHANGE_DIRECTORY] = DrNotifyChangeDirectory;    //MRxIfsNotifyChangeDirectory;

    //
    // Miscellanous - buffering
    //

    //DrDispatch.MRxCompleteBufferingStateChangeRequest = MRxIfsCompleteBufferingStateChangeRequest;


    return STATUS_SUCCESS;
}

BOOLEAN
DrIsAdminIoRequest(
    PIRP                Irp,
    PIO_STACK_LOCATION  IrpSp
    )
/*++

Routine Description:

    (Lifted from AFD - AfdPerformSecurityCheck)
    Compares security context of the endpoint creator to that
    of the administrator and local system.

Arguments:

    Irp - Pointer to I/O request packet.

    IrpSp - pointer to the IO stack location to use for this request.

Return Value:

    TRUE    - the socket creator has admin or local system privilige
    FALSE    - the socket creator is just a plain user

--*/

{
    BOOLEAN               accessGranted;
    PACCESS_STATE         accessState;
    PIO_SECURITY_CONTEXT  securityContext;
    PPRIVILEGE_SET        privileges = NULL;
    ACCESS_MASK           grantedAccess;
    PGENERIC_MAPPING GenericMapping;
    ACCESS_MASK AccessMask = GENERIC_ALL;
    NTSTATUS              Status;

    BEGIN_FN(""DrIsAdminIoRequest"");
    ASSERT(Irp != NULL);
    ASSERT(IrpSp != NULL);
    ASSERT(IrpSp->MajorFunction == IRP_MJ_CREATE);

    //
    // Enable access to all the globally defined SIDs
    //

    GenericMapping = IoGetFileObjectGenericMapping();

    RtlMapGenericMask( &AccessMask, GenericMapping );

    securityContext = IrpSp->Parameters.Create.SecurityContext;

    ASSERT(securityContext != NULL);
    accessState = securityContext->AccessState;

    SeLockSubjectContext(&accessState->SubjectSecurityContext);

    TRC_ASSERT(DrAdminSecurityDescriptor != NULL, 
            (TB, ""DrAdminSecurityDescriptor != NULL""));

    accessGranted = SeAccessCheck(
                        DrAdminSecurityDescriptor,
                        &accessState->SubjectSecurityContext,
                        TRUE,
                        AccessMask,
                        0,
                        &privileges,
                        IoGetFileObjectGenericMapping(),
                        (KPROCESSOR_MODE)((IrpSp->Flags & SL_FORCE_ACCESS_CHECK)
                            ? UserMode
                            : Irp->RequestorMode),
                        &grantedAccess,
                        &Status
                        );

    if (privileges) {
        (VOID) SeAppendPrivileges(
                   accessState,
                   privileges
                   );
        SeFreePrivileges(privileges);
    }

    if (accessGranted) {
        accessState->PreviouslyGrantedAccess |= grantedAccess;
        accessState->RemainingDesiredAccess &= ~( grantedAccess | MAXIMUM_ALLOWED );
        ASSERT (NT_SUCCESS (Status));
    }
    else {
        ASSERT (!NT_SUCCESS (Status));
    }
    SeUnlockSubjectContext(&accessState->SubjectSecurityContext);

    return accessGranted;
}

BOOLEAN 
DrIsSystemProcessRequest(
    PIRP                Irp,
    PIO_STACK_LOCATION  IrpSp
)
/*++

Routine Description:

    Checks to see if the IRP originated from a system process.  

Arguments:

    Irp - Pointer to I/O request packet.
    IrpSp - pointer to the IO stack location to use for this request.

Return Value:

    TRUE if the IRP originated from a system process.  FALSE, otherwise.

--*/
{
    PACCESS_STATE accessState;
    PIO_SECURITY_CONTEXT  securityContext;
    PACCESS_TOKEN accessToken;
    PTOKEN_USER userId = NULL;
    BOOLEAN result = FALSE;
    NTSTATUS status = STATUS_SUCCESS;
    PSID systemSid;

    BEGIN_FN(""DrIsSystemProcessRequest"");
    TRC_NRM((TB, ""DrIsSystemProcessRequest called""));

    ASSERT(Irp != NULL);
    ASSERT(IrpSp != NULL);
    ASSERT(IrpSp->MajorFunction == IRP_MJ_CREATE);

    securityContext = IrpSp->Parameters.Create.SecurityContext;

    ASSERT(securityContext != NULL);

    //
    //  Get the well-known system SID.
    //
    systemSid = (PSID)new(PagedPool) BYTE[RtlLengthRequiredSid(1)];
    if (systemSid) {
        SID_IDENTIFIER_AUTHORITY identifierAuthority = SECURITY_NT_AUTHORITY;
        *(RtlSubAuthoritySid(systemSid, 0)) = SECURITY_LOCAL_SYSTEM_RID;
        status = RtlInitializeSid(systemSid, &identifierAuthority, (UCHAR)1);
    }
    else {
        TRC_ERR((TB, ""Can't allocate %ld bytes for system SID."", 
                RtlLengthRequiredSid(1)));
        status = STATUS_INSUFFICIENT_RESOURCES;
    }

    //
    //  Get the non-impersonated, primary token for the IRP request.
    //
    accessState = securityContext->AccessState;
    accessToken = accessState->SubjectSecurityContext.PrimaryToken;

    //
    // We got the system SID. Now compare the caller's SID.
    //
    if (NT_SUCCESS(status) && accessToken){
        //
        //  Get the user ID associated with the primary token for the process
        //  that generated the IRP.
        //
        status = SeQueryInformationToken(
            accessToken,
            TokenUser,
            (PVOID *)&userId
        );

        //
        //  Do the comparison.
        //  
        if (NT_SUCCESS(status)) {
            result = RtlEqualSid(systemSid, userId->User.Sid);
            ExFreePool(userId);
        }
        else {
            TRC_ERR((TB, ""SeQueryInformationToken failed with %08X"", 
                    status));
        }
    }
    else {
        TRC_ERR((TB, ""Failed to get system sid because of error %08X"", 
                status));
    }
    
    if (systemSid) {
        delete systemSid;
    }

    return result;
}

BOOL
DrQueryServerName(PUNICODE_STRING PathName)
/*++

Routine Description:

    This routine check if the pathname belongs to our minirdr. 

Arguments:

    PathName: path name to check
    
Return Value:

    TRUE - if the path is to our mini-rdr
    FALSE - if the path not our mini-rdr

--*/
{
    PWCHAR ServerName;
    PWCHAR ServerNameEnd;
    unsigned CompareLen;    // in characters
    unsigned PathNameLen;   // in characters

    BEGIN_FN(""DrQueryServerName"");

    TRC_NRM((TB, ""Got query path for file: %wZ"", PathName));
    
    //
    //  Make sure the server name we are comparing has at least length
    //  of the server name our rdpdr recongize
    //
    if (PathName->Length >= DRUNCSERVERNAME_U_LENGTH) {
        ServerName = PathName->Buffer;
        // bypass the first backslash
        ServerName++;
        PathNameLen = PathName->Length / sizeof(WCHAR) - 1;

        // Find the next backslash
        ServerNameEnd = ServerName;
        while ((unsigned)(ServerNameEnd - ServerName) < PathNameLen) {
            if (*ServerNameEnd == L'\\\\') {
                break;
            }
            ServerNameEnd++;
        }
        CompareLen = (unsigned)(ServerNameEnd - ServerName);

        //
        //  Determine if this is a server name belongs to our minirdr
        //
        if ( (CompareLen == DRUNCSERVERNAME_A_LENGTH - 1) &&
                 _wcsnicmp(ServerName, DRUNCSERVERNAME_U, CompareLen) == 0) {
            
            TRC_NRM((TB, ""Quick return that we know the name""));

            return TRUE;
        }
    }

    return FALSE;
}

NTSTATUS
DrPeekDispatch (
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

    This routine implements the driver dispatch for the rdpdr DRIVER object. 

Arguments:

    DeviceObject - Supplies the device object for the packet being processed.

    Irp - Supplies the Irp being processed

Return Value:

    NTSTATUS - The status for the Irp

--*/
{
    PIO_STACK_LOCATION IoStackLocation;
    NTSTATUS Status;
    ULONG  irpSessionId;
    BEGIN_FN(""DrPeekDispatch "");

    IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
#if DBG
    TRC_NRM((TB, ""Irp: %s"", IrpNames[IoStackLocation->MajorFunction]));

    switch (IoStackLocation->MajorFunction) {
    case IRP_MJ_CREATE:
        TRC_NRM((TB, ""CreateFile name: %wZ"", 
        &IoStackLocation->FileObject->FileName));
        break;

    case IRP_MJ_WRITE:
        TRC_NRM((TB, ""IRP_MJ_WRITE"")); 
        break;

    }
#endif // DBG

    //
    //  For Read and Write IRP, we disable caching because the client
    //  is an usermode app and can't synchronize with the server cache
    //  manager 
    //
    if (IoStackLocation->MajorFunction == IRP_MJ_READ ||
            IoStackLocation->MajorFunction == IRP_MJ_WRITE) {
        Irp->Flags |= IRP_NOCACHE;
    }

    //
    //  We need to return immediately for redir_query_path
    //
    if (IoStackLocation->MajorFunction == IRP_MJ_DEVICE_CONTROL &&
            IoStackLocation->Parameters.DeviceIoControl.IoControlCode == IOCTL_REDIR_QUERY_PATH &&
            Irp->RequestorMode == KernelMode) {
        
        QUERY_PATH_REQUEST *qpRequest = (QUERY_PATH_REQUEST *)
                IoStackLocation->Parameters.DeviceIoControl.Type3InputBuffer;

        if (qpRequest != NULL) {
            UNICODE_STRING PathName;

            PathName.Length = (USHORT)qpRequest->PathNameLength;
            PathName.Buffer= qpRequest->FilePathName;

            if (DrQueryServerName(&PathName)) {
                //
                // We must now complete the IRP
                //
                Irp->IoStatus.Status = STATUS_SUCCESS;
                Irp->IoStatus.Information = 0;
                IoCompleteRequest(Irp, IO_NO_INCREMENT);
            
                return STATUS_SUCCESS;        
            }
        }
    }        

    //
    // We want to bypass filesize caching
    //
    RxForceQFIPassThrough = TRUE;

    // If it's not the IFS DO, then let RDPDYN have a shot at it.  Eventually,
    // it would be nice to confirm that it is for RDPDYN.  We can work this
    // out later ...

    if (DeviceObject != (PDEVICE_OBJECT)DrDeviceObject && 
            DeviceObject != (PDEVICE_OBJECT) DrPortDeviceObject) {

        TRC_NRM((TB, ""Pass IRP on to RDPDYN_Dispatch""));
        return RDPDYN_Dispatch(DeviceObject, Irp);
    } else {

        // Only for port device, we deny driver attachment
        if (DeviceObject == (PDEVICE_OBJECT) DrPortDeviceObject) {
        
            if (DeviceObject->AttachedDevice != NULL ||
                    (IoStackLocation->FileObject != NULL &&
                    IoStackLocation->FileObject->DeviceObject != (PDEVICE_OBJECT)DrPortDeviceObject)) {
            
                //
                //  We don't accept another device attaches to us or 
                //  is passing irps to us
                //
                Irp->IoStatus.Status = STATUS_ACCESS_DENIED;
                Irp->IoStatus.Information = 0;
                IoCompleteRequest(Irp, IO_NO_INCREMENT);
                return STATUS_ACCESS_DENIED;        
            }
        
            // 
            // We swap back to the rdpdr device object for port device so it'll go through
            // the rdbss route
            //
            IoStackLocation->DeviceObject = (PDEVICE_OBJECT)DrDeviceObject; 

            // For Multi-User TS environment, we need to set the port carete share access
            // to be sharable, otherwise two users can't use com1 at the same time because
            // rdbss check for share access for NET_ROOT \\\\tsclient\\com1.
            if (IoStackLocation->MajorFunction == IRP_MJ_CREATE) {
                IoStackLocation->Parameters.Create.ShareAccess = FILE_SHARE_VALID_FLAGS;
            }
        }

        if ((IoStackLocation->MajorFunction == IRP_MJ_CREATE) &&
                (IoStackLocation->FileObject->FileName.Length == 0)  &&
                (IoStackLocation->FileObject->RelatedFileObject == NULL)) {
            //
            // This is a blank create, like rdpwsx uses to open us for
            // session connect disconnect notification. Only allowed
            // by the system because we trust rdpwsx to hold a kernel
            // pointer for us
            //

            //
            //  Security check the irp.
            //  
            Status = IoGetRequestorSessionId(Irp, &irpSessionId);
            if (NT_SUCCESS(Status)) {
                //
                //  If the request is from the console session, it needs to be from a system 
                //  process.
                //
                if (irpSessionId == CONSOLE_SESSIONID) {
                    TRC_NRM((TB, ""Create request from console process.""));

                    if (!DrIsSystemProcessRequest(Irp, IoStackLocation)) {
                        TRC_ALT((TB, ""Root Create request not from system process.""));

                        //
                        //  We may get called from a user process through the UNC
                        //  network provider.  e.g. when user does a net use
                        //  In this case, we have to allow root access.  We have to
                        //  do the security check on per IRP bases.
                        //
                        //Irp->IoStatus.Status = STATUS_ACCESS_DENIED;
                        //Irp->IoStatus.Information = 0;
                        //IoCompleteRequest(Irp, IO_NO_INCREMENT);
                        //return STATUS_ACCESS_DENIED;
                        return RxFsdDispatch((PRDBSS_DEVICE_OBJECT)DrDeviceObject, Irp);
                        
                    } else {
                        TRC_NRM((TB, ""Root Create request from system accepted.""));
                        return RxFsdDispatch((PRDBSS_DEVICE_OBJECT)DrDeviceObject, Irp);
                    }
                } else {
                    //
                    //  If not from the console then deny access.
                    //

                    TRC_ALT((TB, ""Root request from %ld"", irpSessionId));

                    //
                    //  We may get called from a user process through the UNC
                    //  network provider.  e.g. when user does a net use
                    //  In this case, we have to allow root access.  We have to
                    //  do the security check on per IRP bases.
                    //
                    //Irp->IoStatus.Status = STATUS_ACCESS_DENIED;
                    //Irp->IoStatus.Information = 0;
                    //IoCompleteRequest(Irp, IO_NO_INCREMENT);
                    //return STATUS_ACCESS_DENIED;
                    return RxFsdDispatch((PRDBSS_DEVICE_OBJECT)DrDeviceObject, Irp);
                }
            }
            else {
                TRC_ERR((TB, ""IoGetRequestorSessionId failed with %08X."", Status));
                Irp->IoStatus.Status = Status;
                Irp->IoStatus.Information = 0;
                IoCompleteRequest(Irp, IO_NO_INCREMENT);
                return Status;
            }
        } else {

            //
            // This is not a create, or at least not a create to just the root
            //

            TRC_NRM((TB, ""Pass IRP on to RxFsdDispatch = %d"", IoStackLocation->MajorFunction));
            
            return RxFsdDispatch((PRDBSS_DEVICE_OBJECT)DrDeviceObject, Irp);
        }
    }
}

NTSTATUS DrLoadRegistrySettings (
    IN PCWSTR   RegistryPath
    )
/*++

Routine Description:

    This routine reads the default configuration data from the
    registry for the device redirector driver.

Arguments:

    RegistryPath - points to the entry for this driver in the
                   current control set of the registry.

Return Value:

    STATUS_SUCCESS if we got the defaults, otherwise we failed.
    The only way to fail this call is if the  STATUS_INSUFFICIENT_RESOURCES.

--*/
{
    NTSTATUS Status = STATUS_SUCCESS;    // return value
    BEGIN_FN(""DrLoadRegistrySettings "");
#if DBG
    extern TRC_CONFIG TRC_Config;
    int i;
    //
    // We use this to query into the registry for defaults
    // paramTable needs to be one entry larger than the set we
    // need because a NULL entry indicates we're done
    //

    RTL_QUERY_REGISTRY_TABLE paramTable[9];
    TRC_CONFIG trcConfig;
    ULONG   DebugBreakOnEntryDefault = FALSE;

    PAGED_CODE();

    RtlZeroMemory(&trcConfig, sizeof(trcConfig));
    trcConfig.FunctionLength = TRC_FUNCNAME_LEN;
    trcConfig.TraceDebugger = FALSE;
    trcConfig.TraceLevel = TRC_LEVEL_ALT;
    trcConfig.TraceProfile = TRUE;

    RtlZeroMemory (&paramTable[0], sizeof(paramTable));

    paramTable[0].Flags         = RTL_QUERY_REGISTRY_DIRECT;
    paramTable[0].Name          = L""FunctionLength"";
    paramTable[0].EntryContext  = &TRC_Config.FunctionLength;
    paramTable[0].DefaultType   = REG_DWORD;
    paramTable[0].DefaultData   = &trcConfig.FunctionLength;
    paramTable[0].DefaultLength = sizeof(trcConfig.FunctionLength);
    
    paramTable[1].Flags         = RTL_QUERY_REGISTRY_DIRECT;
    paramTable[1].Name          = L""TraceLevel"";
    paramTable[1].EntryContext  = &TRC_Config.TraceLevel;
    paramTable[1].DefaultType   = REG_DWORD;
    paramTable[1].DefaultData   = &trcConfig.TraceLevel;
    paramTable[1].DefaultLength = sizeof(trcConfig.TraceLevel);
    
    paramTable[2].Flags         = RTL_QUERY_REGISTRY_DIRECT;
    paramTable[2].Name          = L""TraceProfile"";
    paramTable[2].EntryContext  = &TRC_Config.TraceProfile;
    paramTable[2].DefaultType   = REG_DWORD;
    paramTable[2].DefaultData   = &trcConfig.TraceProfile;
    paramTable[2].DefaultLength = sizeof(trcConfig.TraceProfile);
    
    paramTable[3].Flags         = RTL_QUERY_REGISTRY_DIRECT;
    paramTable[3].Name          = L""TraceDebugger"";
    paramTable[3].EntryContext  = &TRC_Config.TraceDebugger;
    paramTable[3].DefaultType   = REG_DWORD;
    paramTable[3].DefaultData   = &trcConfig.TraceDebugger;
    paramTable[3].DefaultLength = sizeof(trcConfig.TraceDebugger);
    
    paramTable[4].Flags         = RTL_QUERY_REGISTRY_DIRECT;
    paramTable[4].Name          = L""BreakOnEntry"";
    paramTable[4].EntryContext  = &DebugBreakOnEntry;
    paramTable[4].DefaultType   = REG_DWORD;
    paramTable[4].DefaultData   = &DebugBreakOnEntryDefault;
    paramTable[4].DefaultLength = sizeof(ULONG);

    paramTable[5].Flags         = RTL_QUERY_REGISTRY_DIRECT;
    paramTable[5].Name          = L""PrintPortWriteSize"";
    paramTable[5].EntryContext  = &PrintPortWriteSize;
    paramTable[5].DefaultType   = REG_DWORD;
    paramTable[5].DefaultData   = &PrintPortWriteSizeDefault;
    paramTable[5].DefaultLength = sizeof(ULONG);

    paramTable[6].Flags         = RTL_QUERY_REGISTRY_DIRECT;
    paramTable[6].Name          = L""DeviceLowPrioSendFlags"";
    paramTable[6].EntryContext  = &DeviceLowPrioSendFlags;
    paramTable[6].DefaultType   = REG_DWORD;
    paramTable[6].DefaultData   = &DeviceLowPrioSendFlagsDefault;
    paramTable[6].DefaultLength = sizeof(ULONG);

    paramTable[7].Flags         = RTL_QUERY_REGISTRY_DIRECT;
    paramTable[7].Name          = L""MaxWorkerThreads"";
    paramTable[7].EntryContext  = &MaxWorkerThreads;
    paramTable[7].DefaultType   = REG_DWORD;
    paramTable[7].DefaultData   = &MaxWorkerThreadsDefault;
    paramTable[7].DefaultLength = sizeof(ULONG);



    Status = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
                                     RegistryPath,
                                     &paramTable[0],
                                     NULL,
                                     NULL);
       
    if (!NT_SUCCESS(Status)) {
            DebugBreakOnEntry = DebugBreakOnEntryDefault;
    }

    RtlZeroMemory (&paramTable[0], sizeof(paramTable));

    WCHAR wcPrefix[10] = L""Prefix"";
    WCHAR wcStart[10] = L""Start"";
    WCHAR wcEnd[10] = L""End"";
    UNICODE_STRING usPrefix;
    UNICODE_STRING usStart;
    UNICODE_STRING usEnd;

    usPrefix.Buffer = &wcPrefix[6];             // Just past ""Prefix""
    usPrefix.MaximumLength = 3 * sizeof(WCHAR); // Remaining space, room for null term.

    usStart.Buffer = &wcStart[5];               // Just past ""Start""
    usStart.MaximumLength = 4 * sizeof(WCHAR);  // Remaining space, room for null term.

    usEnd.Buffer = &wcEnd[4];                   // Just past ""End""
    usEnd.MaximumLength = 5 * sizeof(WCHAR);    // Remaining space, room for null term.

    paramTable[0].Flags         = RTL_QUERY_REGISTRY_DIRECT;
    paramTable[0].Name          = wcPrefix;
    paramTable[0].DefaultType   = REG_BINARY;
    paramTable[0].DefaultData   = &trcConfig.Prefix[0].name[0];
    paramTable[0].DefaultLength = sizeof(trcConfig.Prefix[0].name);

    paramTable[1].Flags         = RTL_QUERY_REGISTRY_DIRECT;
    paramTable[1].Name          = wcStart;
    paramTable[1].DefaultType   = REG_DWORD;
    paramTable[1].DefaultData   = &trcConfig.Prefix[0].start;
    paramTable[1].DefaultLength = sizeof(trcConfig.Prefix[0].start);

    paramTable[2].Flags         = RTL_QUERY_REGISTRY_DIRECT;
    paramTable[2].Name          = wcEnd;
    paramTable[2].DefaultType   = REG_DWORD;
    paramTable[2].DefaultData   = &trcConfig.Prefix[0].end;
    paramTable[2].DefaultLength = sizeof(trcConfig.Prefix[0].end);

    //
    // So the registry can have values like:
    //  Prefix1 = ""rdpdr""
    //  Start1 = 400
    //  End1 = 425
    //
    //  Prefix1 = ""channel""
    //  Start1 = 765
    //  End1 = 765
    //
    // And that will restrict tracing output to rdpdr, lines 400-425
    //  and channel, line 765
    //

    for (i = 0; i < TRC_MAX_PREFIX; i ++) {

        RtlZeroMemory(&TRC_Config.Prefix[i].name[0], 
                sizeof(TRC_Config.Prefix[i].name[0]));

        // Clear out the end of the strings

        usPrefix.Length = 0;    // no length yet
        RtlZeroMemory(usPrefix.Buffer, usPrefix.MaximumLength);

        usStart.Length = 0;     // no length yet
        RtlZeroMemory(usStart.Buffer, usStart.MaximumLength);

        usEnd.Length = 0;       // no length yet
        RtlZeroMemory(usEnd.Buffer, usEnd.MaximumLength);

        // Append the integer

        RtlIntegerToUnicodeString(i + 1, 10, &usPrefix);
        RtlIntegerToUnicodeString(i + 1, 10, &usStart);
        RtlIntegerToUnicodeString(i + 1, 10, &usEnd);

        paramTable[0].EntryContext  = &TRC_Config.Prefix[i].name;
        paramTable[1].EntryContext  = &TRC_Config.Prefix[i].start;
        paramTable[2].EntryContext  = &TRC_Config.Prefix[i].end;

        Status = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
                                         RegistryPath,
                                         &paramTable[0],
                                         NULL,
                                         NULL);
    }


#endif // DBG
    return (Status);
}

NTSTATUS DrStart(PRX_CONTEXT RxContext, IN OUT PRDBSS_DEVICE_OBJECT RxDeviceObject)
/*++

Routine Description:

     This routine completes the initialization of the mini redirector fromn the
     RDBSS perspective. Note that this is different from the initialization done
     in DriverEntry. Any initialization that depends on RDBSS should be done as
     part of this routine while the initialization that is independent of RDBSS
     should be done in the DriverEntry routine.

Arguments:

    RxContext - Supplies the Irp that was used to startup the rdbss

Return Value:

    RXSTATUS - The return status for the operation

--*/
{
    NTSTATUS Status = STATUS_SUCCESS;

    BEGIN_FN(""DrStart"");
    return Status;
}

NTSTATUS DrStop(PRX_CONTEXT RxContext, IN OUT PRDBSS_DEVICE_OBJECT RxDeviceObject)
/*++

Routine Description:

    This routine is used to deactivate the mini redirector from the RDBSS perspective

Arguments:

    RxContext - the context that was used to start the mini redirector

    pContext  - the mini rdr context passed in at registration time.

Return Value:

    RXSTATUS - The return status for the operation

--*/
{
    NTSTATUS Status;

    BEGIN_FN(""DrStop"");

    return STATUS_SUCCESS;
}

NTSTATUS DrDeallocateForFcb(IN OUT PMRX_FCB pFcb)
{
    BEGIN_FN(""DrDeallocateForFcb"");

    return STATUS_SUCCESS;
}

NTSTATUS DrDeallocateForFobx(IN OUT PMRX_FOBX pFobx)
/*++

Routine Description:

   This routine is the last gasp of a Fobx. We remove the DeviceEntry ref

Arguments:

    pFobx - the instance to be closed

Return Value:

    RXSTATUS - The return status for the operation

Notes:

--*/
{
    DrDevice *Device;
    DrFile *FileObj;
    
    BEGIN_FN(""DrDeallocateForFobx"");

    //
    // Dereference the device object.
    //
    
    if (pFobx->Context != NULL) {
        Device = (DrDevice *)pFobx->Context;
        pFobx->Context = NULL;
        Device->Release();
    }

    //
    //  Cleanup the file object
    //
    if (pFobx->Context2 != NULL) {
        FileObj = (DrFile *)pFobx->Context2;
        FileObj->Release();
        pFobx->Context2 = NULL;
    }

    return STATUS_SUCCESS;
}

NTSTATUS DrForceClosed(IN PMRX_SRV_OPEN pSrvOpen)
/*++

Routine Description:

   This routine closes a file system object

Arguments:

    pSrvOpen - the instance to be closed

Return Value:

    RXSTATUS - The return status for the operation

Notes:



--*/
{
    BEGIN_FN(""DrForceClosed"");

    TRC_NRM((TB, ""DrForceClosed not implemented""));
    return STATUS_NOT_IMPLEMENTED;
}

NTSTATUS
BuildDeviceAcl(
    OUT PACL *DeviceAcl
    )

/*++

Routine Description:

    (Lifted from AFD - AfdBuildDeviceAcl)
    This routine builds an ACL which gives Administrators and LocalSystem
    principals full access. All other principals have no access.

Arguments:

    DeviceAcl - Output pointer to the new ACL.

Return Value:

    STATUS_SUCCESS or an appropriate error code.

--*/

{
    PGENERIC_MAPPING GenericMapping;
    PSID AdminsSid;
    PSID SystemSid;
    ULONG AclLength;
    NTSTATUS Status;
    ACCESS_MASK AccessMask = GENERIC_ALL;
    PACL NewAcl;

    BEGIN_FN(""BuildDeviceAcl"");
    //
    // Enable access to all the globally defined SIDs
    //

    GenericMapping = IoGetFileObjectGenericMapping();

    RtlMapGenericMask( &AccessMask, GenericMapping );

    AdminsSid = SeExports->SeAliasAdminsSid;
    SystemSid = SeExports->SeLocalSystemSid;

    AclLength = sizeof( ACL )                    +
                2 * sizeof( ACCESS_ALLOWED_ACE ) +
                RtlLengthSid( AdminsSid )         +
                RtlLengthSid( SystemSid )         -
                2 * sizeof( ULONG );

    NewAcl = (PACL)new(PagedPool) BYTE[AclLength];

    if (NewAcl == NULL) {
        return( STATUS_INSUFFICIENT_RESOURCES );
    }

    Status = RtlCreateAcl (NewAcl, AclLength, ACL_REVISION );

    if (!NT_SUCCESS( Status )) {
        delete NewAcl;
        return( Status );
    }

    Status = RtlAddAccessAllowedAce (
                 NewAcl,
                 ACL_REVISION2,
                 AccessMask,
                 AdminsSid
                 );

    ASSERT( NT_SUCCESS( Status ));

    Status = RtlAddAccessAllowedAce (
                 NewAcl,
                 ACL_REVISION2,
                 AccessMask,
                 SystemSid
                 );

    ASSERT( NT_SUCCESS( Status ));

    *DeviceAcl = NewAcl;

    return( STATUS_SUCCESS );

} // BuildDeviceAcl

NTSTATUS
CreateAdminSecurityDescriptor(
    VOID
    )
/*++

Routine Description:

    (Lifted from AFD - AfdCreateAdminSecurityDescriptor)
    This routine creates a security descriptor which gives access
    only to Administrtors and LocalSystem. This descriptor is used
    to access check raw endpoint opens and exclisive access to transport
    addresses.

Arguments:

    None.

Return Value:

    STATUS_SUCCESS or an appropriate error code.

--*/

{
    PACL                  rawAcl = NULL;
    NTSTATUS              status;
    BOOLEAN               memoryAllocated = FALSE;
    PSECURITY_DESCRIPTOR  drSecurityDescriptor;
    ULONG                 localDrSecurityDescriptorLength = 0;
    CHAR                  buffer[SECURITY_DESCRIPTOR_MIN_LENGTH];
    PSECURITY_DESCRIPTOR  localSecurityDescriptor =
                             (PSECURITY_DESCRIPTOR) &buffer;
    PSECURITY_DESCRIPTOR  localDrAdminSecurityDescriptor;
    SECURITY_INFORMATION  securityInformation = DACL_SECURITY_INFORMATION;

    BEGIN_FN(""CreateAdminSecurityDescriptor"");

    //
    // Get a pointer to the security descriptor from the Dr device object.
    //
    status = ObGetObjectSecurity(
                 DrDeviceObject,
                 &drSecurityDescriptor,
                 &memoryAllocated
                 );

    if (!NT_SUCCESS(status)) {
        TRC_ERR((TB, ""Unable to get security descriptor, error: %x"",
                status));
        ASSERT(memoryAllocated == FALSE);
        return(status);
    }
    else {
        if (drSecurityDescriptor == NULL) {
            TRC_ERR((TB, ""No security descriptor for DrDeviceObject""));
            status = STATUS_UNSUCCESSFUL;
            return(status);
        }
    }

    //
    // Build a local security descriptor with an ACL giving only
    // administrators and system access.
    //
    status = BuildDeviceAcl(&rawAcl);

    if (!NT_SUCCESS(status)) {
        TRC_ERR((TB, ""Unable to create Raw ACL, error: %x"", status));
        goto error_exit;
    }

    (VOID) RtlCreateSecurityDescriptor(
                localSecurityDescriptor,
                SECURITY_DESCRIPTOR_REVISION
                );

    (VOID) RtlSetDaclSecurityDescriptor(
                localSecurityDescriptor,
                TRUE,
                rawAcl,
                FALSE
                );

    //
    // Make a copy of the Dr descriptor. This copy will be the raw descriptor.
    //
    localDrSecurityDescriptorLength = RtlLengthSecurityDescriptor(
                                      drSecurityDescriptor
                                      );

    localDrAdminSecurityDescriptor = (PSECURITY_DESCRIPTOR)new(PagedPool) BYTE[localDrSecurityDescriptorLength];

    if (localDrAdminSecurityDescriptor == NULL) {
        TRC_ERR((TB, ""couldn't allocate security descriptor""));
        status = STATUS_NO_MEMORY;
        goto error_exit;
    }

    RtlMoveMemory(
        localDrAdminSecurityDescriptor,
        drSecurityDescriptor,
        localDrSecurityDescriptorLength
        );

    DrAdminSecurityDescriptor = localDrAdminSecurityDescriptor;
    DrSecurityDescriptorLength = localDrSecurityDescriptorLength;
    //
    // Now apply the local descriptor to the raw descriptor.
    //
    status = SeSetSecurityDescriptorInfo(
                 NULL,
                 &securityInformation,
                 localSecurityDescriptor,
                 &DrAdminSecurityDescriptor,
                 PagedPool,
                 IoGetFileObjectGenericMapping()
                 );

    if (!NT_SUCCESS(status)) {
        TRC_ERR((TB, ""SeSetSecurity failed, %lx"", status));
        ASSERT (DrAdminSecurityDescriptor==localDrAdminSecurityDescriptor);
        delete DrAdminSecurityDescriptor;
        DrAdminSecurityDescriptor = NULL;
        DrSecurityDescriptorLength = 0;
        goto error_exit;
    }

    if (DrAdminSecurityDescriptor != localDrAdminSecurityDescriptor) {
        delete localDrAdminSecurityDescriptor;
    }

    status = STATUS_SUCCESS;

error_exit:

    ObReleaseObjectSecurity(
        drSecurityDescriptor,
        memoryAllocated
        );

    if (rawAcl!=NULL) {
        delete rawAcl;
    }

    return(status);
}

",16142,True,2946.924636701016,median
"// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
//
// Copyright (C) 2018-2019 Intel Corporation


#ifndef OPENCV_GAPI_CORE_TESTS_INL_HPP
#define OPENCV_GAPI_CORE_TESTS_INL_HPP

#include <opencv2/gapi/core.hpp>
#include <opencv2/gapi/infer/parsers.hpp>
#include ""gapi_core_tests.hpp""

namespace opencv_test
{

TEST_P(MathOpTest, MatricesAccuracyTest)
{
    // G-API code & corresponding OpenCV code ////////////////////////////////
    cv::GMat in1, in2, out;
    if( testWithScalar )
    {
        cv::GScalar sc1;
        switch(opType)
        {
        case (ADD):
        {
            out = cv::gapi::addC(in1, sc1, dtype);
            cv::add(in_mat1, sc, out_mat_ocv, cv::noArray(), dtype);
            break;
        }
        case (SUB):
        {
            if( doReverseOp )
            {
                out = cv::gapi::subRC(sc1, in1, dtype);
                cv::subtract(sc, in_mat1, out_mat_ocv, cv::noArray(), dtype);
            }
            else
            {
                out = cv::gapi::subC(in1, sc1, dtype);
                cv::subtract(in_mat1, sc, out_mat_ocv, cv::noArray(), dtype);
            }
            break;
        }
        case (DIV):
        {
            if( doReverseOp )
            {
                in_mat1.setTo(1, in_mat1 == 0);  // avoiding zeros in divide input data
                out = cv::gapi::divRC(sc1, in1, scale, dtype);
                cv::divide(sc, in_mat1, out_mat_ocv, scale, dtype);
                break;
            }
            else
            {
                sc += Scalar(sc[0] == 0, sc[1] == 0, sc[2] == 0, sc[3] == 0);  // avoiding zeros in divide input data
                out = cv::gapi::divC(in1, sc1, scale, dtype);
                cv::divide(in_mat1, sc, out_mat_ocv, scale, dtype);
                break;
            }
        }
        case (MUL):
        {
            // FIXME: add `scale` parameter to mulC
            out = cv::gapi::mulC(in1, sc1, /* scale, */ dtype);
            cv::multiply(in_mat1, sc, out_mat_ocv, 1., dtype);
            break;
        }
        default:
        {
            FAIL() << ""no such math operation type for scalar and matrix!"";
        }
        }
        cv::GComputation c(GIn(in1, sc1), GOut(out));
        c.apply(gin(in_mat1, sc), gout(out_mat_gapi), getCompileArgs());
    }
    else
    {
        switch(opType)
        {
        case (ADD):
        {
            out = cv::gapi::add(in1, in2, dtype);
            cv::add(in_mat1, in_mat2, out_mat_ocv, cv::noArray(), dtype);
            break;
        }
        case (SUB):
        {
            out = cv::gapi::sub(in1, in2, dtype);
            cv::subtract(in_mat1, in_mat2, out_mat_ocv, cv::noArray(), dtype);
            break;
        }
        case (DIV):
        {
            in_mat2.setTo(1, in_mat2 == 0);  // avoiding zeros in divide input data
            out = cv::gapi::div(in1, in2, scale, dtype);
            cv::divide(in_mat1, in_mat2, out_mat_ocv, scale, dtype);
            break;
        }
        case (MUL):
        {
            out = cv::gapi::mul(in1, in2, scale, dtype);
            cv::multiply(in_mat1, in_mat2, out_mat_ocv, scale, dtype);
            break;
        }
        default:
        {
            FAIL() << ""no such math operation type for matrix and matrix!"";
        }}
        cv::GComputation c(GIn(in1, in2), GOut(out));
        c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());
    }

    // Comparison //////////////////////////////////////////////////////////////
    {
    // TODO: make threshold vs bit-exact criteria be driven by testing parameter
    #if 1
        if (CV_MAT_DEPTH(out_mat_ocv.type()) != CV_32F &&
            CV_MAT_DEPTH(out_mat_ocv.type()) != CV_64F)
        {
            // integral: allow 1% of differences, and no diffs by >1 unit
            EXPECT_LE(cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF), 1);  // check: abs(a[i] - b[i]) <= 1
            float tolerance = 0.01f;
#if defined(__arm__) || defined(__aarch64__)
            if (opType == DIV)
                tolerance = 0.05f;
#endif
            EXPECT_LE(cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_L1), tolerance*out_mat_ocv.total());
        }
        else
        {
            // floating-point: expect 6 decimal digits - best we expect of F32
            EXPECT_LE(cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF | NORM_RELATIVE), 1e-6);
        }
    #else
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
    #endif
        EXPECT_EQ(out_mat_gapi.size(), sz);
    }
}

TEST_P(MulDoubleTest, AccuracyTest)
{
    auto& rng = cv::theRNG();
    double d = rng.uniform(0.0, 10.0);

    // G-API code ////////////////////////////////////////////////////////////
    cv::GMat in1, out;
    out = cv::gapi::mulC(in1, d, dtype);
    cv::GComputation c(in1, out);
    c.apply(in_mat1, out_mat_gapi, getCompileArgs());

    // OpenCV code ///////////////////////////////////////////////////////////
    cv::multiply(in_mat1, d, out_mat_ocv, 1, dtype);

    // Comparison ////////////////////////////////////////////////////////////
#if 1
    if (CV_MAT_DEPTH(out_mat_ocv.type()) != CV_32F &&
        CV_MAT_DEPTH(out_mat_ocv.type()) != CV_64F)
    {
        // integral: allow 1% of differences, and no diffs by >1 unit
        EXPECT_LE(cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF), 1);
        EXPECT_LE(cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_L1 | NORM_RELATIVE), 0.01);
    }
    else
    {
        // floating-point: expect 6 decimal digits - best we expect of F32
        EXPECT_LE(cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF | NORM_RELATIVE), 1e-6);
    }
#else
    EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
#endif
    EXPECT_EQ(out_mat_gapi.size(), sz);
}

TEST_P(DivTest, DISABLED_DivByZeroTest)  // https://github.com/opencv/opencv/pull/12826
{
    in_mat2 = cv::Mat(sz, type);
    in_mat2.setTo(cv::Scalar::all(0));

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2;
    auto out = cv::gapi::div(in1, in2, 1.0, dtype);
    cv::GComputation c(GIn(in1, in2), GOut(out));
    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::divide(in_mat1, in_mat2, out_mat_ocv, 1.0, dtype);
    }

    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
        EXPECT_EQ(out_mat_gapi.size(), sz);
    }
}

TEST_P(DivCTest, DISABLED_DivByZeroTest)  // https://github.com/opencv/opencv/pull/12826
{
    sc = cv::Scalar::all(0);

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1;
    cv::GScalar sc1;
    auto out = cv::gapi::divC(in1, sc1, dtype);
    cv::GComputation c(GIn(in1, sc1), GOut(out));

    c.apply(gin(in_mat1, sc), gout(out_mat_gapi), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::divide(in_mat1, sc, out_mat_ocv, dtype);
    }

    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
        cv::Mat zeros = cv::Mat::zeros(sz, type);
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, zeros, NORM_INF));
    }
}

TEST_P(MeanTest, AccuracyTest)
{
    cv::Scalar out_norm;
    cv::Scalar out_norm_ocv;

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in;
    auto out = cv::gapi::mean(in);

    cv::GComputation c(cv::GIn(in), cv::GOut(out));
    c.apply(cv::gin(in_mat1), cv::gout(out_norm), getCompileArgs());
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        out_norm_ocv = cv::mean(in_mat1);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(out_norm[0], out_norm_ocv[0]);
    }
}

TEST_P(MaskTest, AccuracyTest)
{
    in_mat2 = cv::Mat(sz, CV_8UC1);
    cv::randu(in_mat2, cv::Scalar::all(0), cv::Scalar::all(255));
    in_mat2 = in_mat2 > 128;

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in, m;
    auto out = cv::gapi::mask(in, m);

    cv::GComputation c(cv::GIn(in, m), cv::GOut(out));
    c.apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat_gapi), getCompileArgs());
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        out_mat_ocv = cv::Mat::zeros(in_mat1.size(), in_mat1.type());
        in_mat1.copyTo(out_mat_ocv, in_mat2);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
    }
}

TEST_P(Polar2CartTest, AccuracyTest)
{
    cv::Mat out_mat2;
    cv::Mat out_mat_ocv2;
    if (dtype != -1)
    {
        out_mat2 = cv::Mat(sz, dtype);
        out_mat_ocv2 = cv::Mat(sz, dtype);
    }

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2, out1, out2;
    std::tie(out1, out2) = cv::gapi::polarToCart(in1, in2);

    cv::GComputation c(GIn(in1, in2), GOut(out1, out2));
    c.apply(gin(in_mat1,in_mat2), gout(out_mat_gapi, out_mat2), getCompileArgs());
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::polarToCart(in_mat1, in_mat2, out_mat_ocv, out_mat_ocv2);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        // Note that we cannot rely on bit-exact sin/cos functions used for this
        // transform, so we need a threshold for verifying results vs reference.
        //
        // Relative threshold like 1e-6 is very restrictive, nearly best we can
        // expect of single-precision elementary functions implementation.
        //
        // However, good idea is making such threshold configurable: parameter
        // of this test - which a specific test instantiation could setup.
        //
        // Note that test instantiation for the OpenCV back-end could even let
        // the threshold equal to zero, as CV back-end calls the same kernel.
        //
        // TODO: Make threshold a configurable parameter of this test (ADE-221)

        ASSERT_EQ(out_mat_gapi.size(), sz);

        cv::Mat &outx = out_mat_gapi,
                &outy = out_mat2;
        cv::Mat &refx = out_mat_ocv,
                &refy = out_mat_ocv2;

        EXPECT_LE(cvtest::norm(refx, outx, NORM_L1 | NORM_RELATIVE), 1e-6);
        EXPECT_LE(cvtest::norm(refy, outy, NORM_L1 | NORM_RELATIVE), 1e-6);
    }
}

TEST_P(Cart2PolarTest, AccuracyTest)
{
    cv::Mat out_mat2(sz, dtype);
    cv::Mat out_mat_ocv2(sz, dtype);

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2, out1, out2;
    std::tie(out1, out2) = cv::gapi::cartToPolar(in1, in2);

    cv::GComputation c(GIn(in1, in2), GOut(out1, out2));
    c.apply(gin(in_mat1,in_mat2), gout(out_mat_gapi, out_mat2));
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::cartToPolar(in_mat1, in_mat2, out_mat_ocv, out_mat_ocv2);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        // Note that we cannot rely on bit-exact sin/cos functions used for this
        // transform, so we need a threshold for verifying results vs reference.
        //
        // Relative threshold like 1e-6 is very restrictive, nearly best we can
        // expect of single-precision elementary functions implementation.
        //
        // However, good idea is making such threshold configurable: parameter
        // of this test - which a specific test instantiation could setup.
        //
        // Note that test instantiation for the OpenCV back-end could even let
        // the threshold equal to zero, as CV back-end calls the same kernel.
        //
        // TODO: Make threshold a configurable parameter of this test (ADE-221)

        ASSERT_EQ(out_mat_gapi.size(), sz);

        cv::Mat &outm = out_mat_gapi,
                &outa = out_mat2;
        cv::Mat &refm = out_mat_ocv,
                &refa = out_mat_ocv2;

        // FIXME: Angle result looks inaccurate at OpenCV
        //        (expected relative accuracy like 1e-6)
        EXPECT_LE(cvtest::norm(refm, outm, NORM_INF), 1e-6);
        EXPECT_LE(cvtest::norm(refa, outa, NORM_INF), 1e-3);
    }
}

TEST_P(CmpTest, AccuracyTest)
{
    // G-API code & corresponding OpenCV code ////////////////////////////////
    cv::GMat in1, out;
    if( testWithScalar )
    {
        cv::GScalar in2;
        switch(opType)
        {
        case CMP_EQ: out = cv::gapi::cmpEQ(in1, in2); break;
        case CMP_GT: out = cv::gapi::cmpGT(in1, in2); break;
        case CMP_GE: out = cv::gapi::cmpGE(in1, in2); break;
        case CMP_LT: out = cv::gapi::cmpLT(in1, in2); break;
        case CMP_LE: out = cv::gapi::cmpLE(in1, in2); break;
        case CMP_NE: out = cv::gapi::cmpNE(in1, in2); break;
        default: FAIL() << ""no such compare operation type for matrix and scalar!"";
        }

        cv::compare(in_mat1, sc, out_mat_ocv, opType);

        cv::GComputation c(GIn(in1, in2), GOut(out));
        c.apply(gin(in_mat1, sc), gout(out_mat_gapi), getCompileArgs());
    }
    else
    {
        cv::GMat in2;
        switch(opType)
        {
        case CMP_EQ: out = cv::gapi::cmpEQ(in1, in2); break;
        case CMP_GT: out = cv::gapi::cmpGT(in1, in2); break;
        case CMP_GE: out = cv::gapi::cmpGE(in1, in2); break;
        case CMP_LT: out = cv::gapi::cmpLT(in1, in2); break;
        case CMP_LE: out = cv::gapi::cmpLE(in1, in2); break;
        case CMP_NE: out = cv::gapi::cmpNE(in1, in2); break;
        default: FAIL() << ""no such compare operation type for two matrices!"";
        }

        cv::compare(in_mat1, in_mat2, out_mat_ocv, opType);

        cv::GComputation c(GIn(in1, in2), GOut(out));
        c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());
    }

    // Comparison //////////////////////////////////////////////////////////////
    {
        ASSERT_EQ(out_mat_gapi.size(), sz);
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
    }
}

TEST_P(BitwiseTest, AccuracyTest)
{
    // G-API code & corresponding OpenCV code ////////////////////////////////
    cv::GMat in1, in2, out;
    if( testWithScalar )
    {
        cv::GScalar sc1;
        switch(opType)
        {
            case AND:
                out = cv::gapi::bitwise_and(in1, sc1);
                cv::bitwise_and(in_mat1, sc, out_mat_ocv);
                break;
            case OR:
                out = cv::gapi::bitwise_or(in1, sc1);
                cv::bitwise_or(in_mat1, sc, out_mat_ocv);
                break;
            case XOR:
                out = cv::gapi::bitwise_xor(in1, sc1);
                cv::bitwise_xor(in_mat1, sc, out_mat_ocv);
                break;
            default:
                FAIL() << ""no such bitwise operation type!"";
        }
        cv::GComputation c(GIn(in1, sc1), GOut(out));
        c.apply(gin(in_mat1, sc), gout(out_mat_gapi), getCompileArgs());
    }
    else
    {
        switch(opType)
        {
            case AND:
                out = cv::gapi::bitwise_and(in1, in2);
                cv::bitwise_and(in_mat1, in_mat2, out_mat_ocv);
                break;
            case OR:
                out = cv::gapi::bitwise_or(in1, in2);
                cv::bitwise_or(in_mat1, in_mat2, out_mat_ocv);
                break;
            case XOR:
                out = cv::gapi::bitwise_xor(in1, in2);
                cv::bitwise_xor(in_mat1, in_mat2, out_mat_ocv);
                break;
            default:
                FAIL() << ""no such bitwise operation type!"";
        }
        cv::GComputation c(GIn(in1, in2), GOut(out));
        c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());
    }


    // Comparison //////////////////////////////////////////////////////////////
    {
        ASSERT_EQ(out_mat_gapi.size(), sz);
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
    }
}

TEST_P(NotTest, AccuracyTest)
{
    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in;
    auto out = cv::gapi::bitwise_not(in);
    cv::GComputation c(in, out);

    c.apply(in_mat1, out_mat_gapi, getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::bitwise_not(in_mat1, out_mat_ocv);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        ASSERT_EQ(out_mat_gapi.size(), sz);
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
    }
}

TEST_P(SelectTest, AccuracyTest)
{
    cv::Mat in_mask(sz, CV_8UC1);
    cv::randu(in_mask, cv::Scalar::all(0), cv::Scalar::all(255));

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2, in3;
    auto out = cv::gapi::select(in1, in2, in3);
    cv::GComputation c(GIn(in1, in2, in3), GOut(out));

    c.apply(gin(in_mat1, in_mat2, in_mask), gout(out_mat_gapi), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        in_mat2.copyTo(out_mat_ocv);
        in_mat1.copyTo(out_mat_ocv, in_mask);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        ASSERT_EQ(out_mat_gapi.size(), sz);
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
    }
}

TEST_P(MinTest, AccuracyTest)
{
    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2;
    auto out = cv::gapi::min(in1, in2);
    cv::GComputation c(GIn(in1, in2), GOut(out));

    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::min(in_mat1, in_mat2, out_mat_ocv);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        ASSERT_EQ(out_mat_gapi.size(), sz);
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
    }
}

TEST_P(MaxTest, AccuracyTest)
{
    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2;
    auto out = cv::gapi::max(in1, in2);
    cv::GComputation c(GIn(in1, in2), GOut(out));

    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::max(in_mat1, in_mat2, out_mat_ocv);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        ASSERT_EQ(out_mat_gapi.size(), sz);
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
    }
}

TEST_P(AbsDiffTest, AccuracyTest)
{
    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2;
    auto out = cv::gapi::absDiff(in1, in2);
    cv::GComputation c(GIn(in1, in2), GOut(out));

    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::absdiff(in_mat1, in_mat2, out_mat_ocv);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        ASSERT_EQ(out_mat_gapi.size(), sz);
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
    }
}

TEST_P(AbsDiffCTest, AccuracyTest)
{
    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1;
    cv::GScalar sc1;
    auto out = cv::gapi::absDiffC(in1, sc1);
    cv::GComputation c(cv::GIn(in1, sc1), cv::GOut(out));

    c.apply(gin(in_mat1, sc), gout(out_mat_gapi), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::absdiff(in_mat1, sc, out_mat_ocv);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        ASSERT_EQ(out_mat_gapi.size(), sz);
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
    }
}

TEST_P(SumTest, AccuracyTest)
{
    cv::Scalar out_sum;
    cv::Scalar out_sum_ocv;

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in;
    auto out = cv::gapi::sum(in);

    cv::GComputation c(cv::GIn(in), cv::GOut(out));
    c.apply(cv::gin(in_mat1), cv::gout(out_sum), getCompileArgs());
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        out_sum_ocv = cv::sum(in_mat1);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_sum, out_sum_ocv));
    }
}

TEST_P(AddWeightedTest, AccuracyTest)
{
    auto& rng = cv::theRNG();
    double alpha = rng.uniform(0.0, 1.0);
    double beta = rng.uniform(0.0, 1.0);
    double gamma = rng.uniform(0.0, 1.0);

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2;
    auto out = cv::gapi::addWeighted(in1, alpha, in2, beta, gamma, dtype);
    cv::GComputation c(GIn(in1, in2), GOut(out));

    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::addWeighted(in_mat1, alpha, in_mat2, beta, gamma, out_mat_ocv, dtype);
    }
    // Comparison //////////////////////////////////////////////////////////////
    EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
    EXPECT_EQ(out_mat_gapi.size(), sz);
}

TEST_P(NormTest, AccuracyTest)
{
    cv::Scalar out_norm;
    cv::Scalar out_norm_ocv;

    // G-API code & corresponding OpenCV code ////////////////////////////////
    cv::GMat in1;
    cv::GScalar out;
    switch(opType)
    {
        case NORM_L1: out = cv::gapi::normL1(in1); break;
        case NORM_L2: out = cv::gapi::normL2(in1); break;
        case NORM_INF: out = cv::gapi::normInf(in1); break;
        default: FAIL() << ""no such norm operation type!"";
    }
    out_norm_ocv = cv::norm(in_mat1, opType);
    cv::GComputation c(GIn(in1), GOut(out));
    c.apply(gin(in_mat1), gout(out_norm), getCompileArgs());

    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_norm, out_norm_ocv));
    }
}

TEST_P(IntegralTest, AccuracyTest)
{
    int type_out = (type == CV_8U) ? CV_32SC1 : CV_64FC1;
    in_mat1 = cv::Mat(sz, type);

    cv::randu(in_mat1, cv::Scalar::all(0), cv::Scalar::all(255));

    cv::Size sz_out = cv::Size(sz.width + 1, sz.height + 1);
    cv::Mat out_mat1(sz_out, type_out);
    cv::Mat out_mat_ocv1(sz_out, type_out);

    cv::Mat out_mat2(sz_out, CV_64FC1);
    cv::Mat out_mat_ocv2(sz_out, CV_64FC1);

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, out1, out2;
    std::tie(out1, out2)  = cv::gapi::integral(in1, type_out, CV_64FC1);
    cv::GComputation c(cv::GIn(in1), cv::GOut(out1, out2));

    c.apply(cv::gin(in_mat1), cv::gout(out_mat1, out_mat2), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::integral(in_mat1, out_mat_ocv1, out_mat_ocv2);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv1, out_mat1, NORM_INF));
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv2, out_mat2, NORM_INF));
    }
}

TEST_P(ThresholdTest, AccuracyTestBinary)
{
    cv::Scalar thr = initScalarRandU(50);
    cv::Scalar out_scalar;

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, out;
    cv::GScalar th1, mv1;
    out = cv::gapi::threshold(in1, th1, mv1, tt);
    cv::GComputation c(GIn(in1, th1, mv1), GOut(out));

    c.apply(gin(in_mat1, thr, maxval), gout(out_mat_gapi), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::threshold(in_mat1, out_mat_ocv, thr.val[0], maxval.val[0], tt);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        ASSERT_EQ(out_mat_gapi.size(), sz);
        EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_L1));
    }
}

TEST_P(ThresholdOTTest, AccuracyTestOtsu)
{
    cv::Scalar maxval = initScalarRandU(50) + cv::Scalar(50, 50, 50, 50);
    cv::Scalar out_gapi_scalar;
    double ocv_res;

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, out;
    cv::GScalar mv1, scout;
    std::tie<cv::GMat, cv::GScalar>(out, scout) = cv::gapi::threshold(in1, mv1, tt);
    cv::GComputation c(cv::GIn(in1, mv1), cv::GOut(out, scout));

    c.apply(gin(in_mat1, maxval), gout(out_mat_gapi, out_gapi_scalar), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        ocv_res = cv::threshold(in_mat1, out_mat_ocv, maxval.val[0], maxval.val[0], tt);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
        EXPECT_EQ(out_mat_gapi.size(), sz);
        EXPECT_EQ(ocv_res, out_gapi_scalar.val[0]);
    }
}

TEST_P(InRangeTest, AccuracyTest)
{
    cv::Scalar thrLow = initScalarRandU(100);
    cv::Scalar thrUp = initScalarRandU(100) + cv::Scalar(100, 100, 100, 100);

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1;
    cv::GScalar th1, mv1;
    auto out = cv::gapi::inRange(in1, th1, mv1);
    cv::GComputation c(GIn(in1, th1, mv1), GOut(out));

    c.apply(gin(in_mat1, thrLow, thrUp), gout(out_mat_gapi), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::inRange(in_mat1, thrLow, thrUp, out_mat_ocv);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        ASSERT_EQ(out_mat_gapi.size(), sz);
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
    }
}

TEST_P(Split3Test, AccuracyTest)
{
    cv::Mat out_mat2 = cv::Mat(sz, dtype);
    cv::Mat out_mat3 = cv::Mat(sz, dtype);
    cv::Mat out_mat_ocv2 = cv::Mat(sz, dtype);
    cv::Mat out_mat_ocv3 = cv::Mat(sz, dtype);
    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, out1, out2, out3;
    std::tie(out1, out2, out3)  = cv::gapi::split3(in1);
    cv::GComputation c(cv::GIn(in1), cv::GOut(out1, out2, out3));

    c.apply(cv::gin(in_mat1), cv::gout(out_mat_gapi, out_mat2, out_mat3), getCompileArgs());
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        std::vector<cv::Mat> out_mats_ocv = {out_mat_ocv, out_mat_ocv2, out_mat_ocv3};
        cv::split(in_mat1, out_mats_ocv);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv,  out_mat_gapi, NORM_INF));
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv2, out_mat2, NORM_INF));
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv3, out_mat3, NORM_INF));
    }
}

TEST_P(Split4Test, AccuracyTest)
{
    cv::Mat out_mat2 = cv::Mat(sz, dtype);
    cv::Mat out_mat3 = cv::Mat(sz, dtype);
    cv::Mat out_mat4 = cv::Mat(sz, dtype);
    cv::Mat out_mat_ocv2 = cv::Mat(sz, dtype);
    cv::Mat out_mat_ocv3 = cv::Mat(sz, dtype);
    cv::Mat out_mat_ocv4 = cv::Mat(sz, dtype);

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, out1, out2, out3, out4;
    std::tie(out1, out2, out3, out4)  = cv::gapi::split4(in1);
    cv::GComputation c(cv::GIn(in1), cv::GOut(out1, out2, out3, out4));

    c.apply(cv::gin(in_mat1), cv::gout(out_mat_gapi, out_mat2, out_mat3, out_mat4), getCompileArgs());
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        std::vector<cv::Mat> out_mats_ocv = {out_mat_ocv, out_mat_ocv2, out_mat_ocv3, out_mat_ocv4};
        cv::split(in_mat1, out_mats_ocv);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv,  out_mat_gapi, NORM_INF));
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv2, out_mat2, NORM_INF));
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv3, out_mat3, NORM_INF));
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv4, out_mat4, NORM_INF));
    }
}

static void ResizeAccuracyTest(const CompareMats& cmpF, int type, int interp, cv::Size sz_in,
    cv::Size sz_out, double fx, double fy, cv::GCompileArgs&& compile_args)
{
    cv::Mat in_mat1 (sz_in, type );
    cv::Scalar mean = cv::Scalar::all(127);
    cv::Scalar stddev = cv::Scalar::all(40.f);

    cv::randn(in_mat1, mean, stddev);

    auto out_mat_sz = sz_out.area() == 0 ? cv::Size(saturate_cast<int>(sz_in.width *fx),
                                                    saturate_cast<int>(sz_in.height*fy))
                                         : sz_out;
    cv::Mat out_mat(out_mat_sz, type);
    cv::Mat out_mat_ocv(out_mat_sz, type);

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in;
    auto out = cv::gapi::resize(in, sz_out, fx, fy, interp);

    cv::GComputation c(in, out);
    c.apply(in_mat1, out_mat, std::move(compile_args));
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::resize(in_mat1, out_mat_ocv, sz_out, fx, fy, interp);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat, out_mat_ocv));
    }
}

TEST_P(ResizeTest, AccuracyTest)
{
    ResizeAccuracyTest(cmpF, type, interp, sz, sz_out, 0.0, 0.0, getCompileArgs());
}

TEST_P(ResizeTestFxFy, AccuracyTest)
{
    ResizeAccuracyTest(cmpF, type, interp, sz, cv::Size{0, 0}, fx, fy, getCompileArgs());
}

TEST_P(ResizePTest, AccuracyTest)
{
    constexpr int planeNum = 3;
    cv::Size sz_in_p {sz.width,  sz.height*planeNum};
    cv::Size sz_out_p{sz_out.width, sz_out.height*planeNum};

    cv::Mat in_mat(sz_in_p, CV_8UC1);
    cv::randn(in_mat, cv::Scalar::all(127.0f), cv::Scalar::all(40.f));

    cv::Mat out_mat    (sz_out_p, CV_8UC1);
    cv::Mat out_mat_ocv_p(sz_out_p, CV_8UC1);

    cv::GMatP in;
    auto out = cv::gapi::resizeP(in, sz_out, interp);
    cv::GComputation c(cv::GIn(in), cv::GOut(out));

    c.compile(cv::descr_of(in_mat).asPlanar(planeNum), getCompileArgs())
             (cv::gin(in_mat), cv::gout(out_mat));

    for (int i = 0; i < planeNum; i++) {
        const cv::Mat in_mat_roi = in_mat(cv::Rect(0, i*sz.height,  sz.width,  sz.height));
        cv::Mat out_mat_roi = out_mat_ocv_p(cv::Rect(0, i*sz_out.height, sz_out.width, sz_out.height));
        cv::resize(in_mat_roi, out_mat_roi, sz_out, 0, 0, interp);
    }

    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat, out_mat_ocv_p));
    }
}

TEST_P(Merge3Test, AccuracyTest)
{
    cv::Mat in_mat3(sz, type);
    cv::Scalar mean = cv::Scalar::all(127);
    cv::Scalar stddev = cv::Scalar::all(40.f);

    cv::randn(in_mat3, mean, stddev);

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2, in3;
    auto out = cv::gapi::merge3(in1, in2, in3);

    cv::GComputation c(cv::GIn(in1, in2, in3), cv::GOut(out));
    c.apply(cv::gin(in_mat1, in_mat2, in_mat3), cv::gout(out_mat_gapi), getCompileArgs());
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        std::vector<cv::Mat> in_mats_ocv = {in_mat1, in_mat2, in_mat3};
        cv::merge(in_mats_ocv, out_mat_ocv);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
    }
}

TEST_P(Merge4Test, AccuracyTest)
{
    cv::Mat in_mat3(sz, type);
    cv::Mat in_mat4(sz, type);
    cv::Scalar mean = cv::Scalar::all(127);
    cv::Scalar stddev = cv::Scalar::all(40.f);

    cv::randn(in_mat3, mean, stddev);
    cv::randn(in_mat4, mean, stddev);

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2, in3, in4;
    auto out = cv::gapi::merge4(in1, in2, in3, in4);

    cv::GComputation c(cv::GIn(in1, in2, in3, in4), cv::GOut(out));
    c.apply(cv::gin(in_mat1, in_mat2, in_mat3, in_mat4), cv::gout(out_mat_gapi), getCompileArgs());
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        std::vector<cv::Mat> in_mats_ocv = {in_mat1, in_mat2, in_mat3, in_mat4};
        cv::merge(in_mats_ocv, out_mat_ocv);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
    }
}

TEST_P(RemapTest, AccuracyTest)
{
    cv::Mat in_map1(sz, CV_16SC2);
    cv::Mat in_map2 = cv::Mat();
    cv::randu(in_map1, cv::Scalar::all(0), cv::Scalar::all(255));
    cv::Scalar bv = cv::Scalar();

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1;
    auto out = cv::gapi::remap(in1, in_map1, in_map2, cv::INTER_NEAREST,  cv::BORDER_REPLICATE, bv);
    cv::GComputation c(in1, out);

    c.apply(in_mat1, out_mat_gapi, getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::remap(in_mat1, out_mat_ocv, in_map1, in_map2, cv::INTER_NEAREST, cv::BORDER_REPLICATE, bv);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
        EXPECT_EQ(out_mat_gapi.size(), sz);
    }
}

TEST_P(FlipTest, AccuracyTest)
{
    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in;
    auto out = cv::gapi::flip(in, flipCode);

    cv::GComputation c(in, out);
    c.apply(in_mat1, out_mat_gapi, getCompileArgs());
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::flip(in_mat1, out_mat_ocv, flipCode);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
        EXPECT_EQ(out_mat_gapi.size(), sz);
    }
}

TEST_P(CropTest, AccuracyTest)
{
    cv::Size sz_out = cv::Size(rect_to.width, rect_to.height);
    if (dtype != -1)
    {
        out_mat_gapi = cv::Mat(sz_out, dtype);
        out_mat_ocv = cv::Mat(sz_out, dtype);
    }

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in;
    auto out = cv::gapi::crop(in, rect_to);

    cv::GComputation c(in, out);
    c.apply(in_mat1, out_mat_gapi, getCompileArgs());
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::Mat(in_mat1, rect_to).copyTo(out_mat_ocv);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
        EXPECT_EQ(out_mat_gapi.size(), sz_out);
    }
}

TEST_P(CopyTest, AccuracyTest)
{
    cv::Size sz_out = sz;
    if (dtype != -1)
    {
        out_mat_gapi = cv::Mat(sz_out, dtype);
        out_mat_ocv = cv::Mat(sz_out, dtype);
    }

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in;
    auto out = cv::gapi::copy(in);

    cv::GComputation c(in, out);
    c.apply(in_mat1, out_mat_gapi, getCompileArgs());
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::Mat(in_mat1).copyTo(out_mat_ocv);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
        EXPECT_EQ(out_mat_gapi.size(), sz_out);
    }
}

TEST_P(ConcatHorTest, AccuracyTest)
{
    cv::Size sz_out = sz;

    int wpart = sz_out.width / 4;
    cv::Size sz_in1 = cv::Size(wpart, sz_out.height);
    cv::Size sz_in2 = cv::Size(sz_out.width - wpart, sz_out.height);

    in_mat1 = cv::Mat(sz_in1, type );
    in_mat2 = cv::Mat(sz_in2, type);
    cv::Scalar mean = cv::Scalar::all(127);
    cv::Scalar stddev = cv::Scalar::all(40.f);

    cv::randn(in_mat1, mean, stddev);
    cv::randn(in_mat2, mean, stddev);

    cv::Mat out_mat(sz_out, type);
    out_mat_ocv = cv::Mat(sz_out, type);

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2;
    auto out = cv::gapi::concatHor(in1, in2);

    cv::GComputation c(GIn(in1, in2), GOut(out));
    c.apply(gin(in_mat1, in_mat2), gout(out_mat), getCompileArgs());
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::hconcat(in_mat1, in_mat2, out_mat_ocv);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat, NORM_INF));
    }
}

TEST_P(ConcatVertTest, AccuracyTest)
{
    cv::Size sz_out = sz;

    int hpart = sz_out.height * 2/3;
    cv::Size sz_in1 = cv::Size(sz_out.width, hpart);
    cv::Size sz_in2 = cv::Size(sz_out.width, sz_out.height - hpart);

    in_mat1 = cv::Mat(sz_in1, type);
    in_mat2 = cv::Mat(sz_in2, type);
    cv::Scalar mean = cv::Scalar::all(127);
    cv::Scalar stddev = cv::Scalar::all(40.f);

    cv::randn(in_mat1, mean, stddev);
    cv::randn(in_mat2, mean, stddev);

    cv::Mat out_mat(sz_out, type);
    out_mat_ocv = cv::Mat(sz_out, type);

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2;
    auto out = cv::gapi::concatVert(in1, in2);

    cv::GComputation c(GIn(in1, in2), GOut(out));
    c.apply(gin(in_mat1, in_mat2), gout(out_mat), getCompileArgs());
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::vconcat(in_mat1, in_mat2, out_mat_ocv );
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat, NORM_INF));
    }
}

TEST_P(ConcatVertVecTest, AccuracyTest)
{
    cv::Size sz_out = sz;

    int hpart1 = sz_out.height * 2/5;
    int hpart2 = sz_out.height / 5;
    cv::Size sz_in1 = cv::Size(sz_out.width, hpart1);
    cv::Size sz_in2 = cv::Size(sz_out.width, hpart2);
    cv::Size sz_in3 = cv::Size(sz_out.width, sz_out.height - hpart1 - hpart2);

    in_mat1 = cv::Mat(sz_in1, type);
    in_mat2 = cv::Mat(sz_in2, type);
    cv::Mat in_mat3(sz_in3, type);
    cv::Scalar mean = cv::Scalar::all(127);
    cv::Scalar stddev = cv::Scalar::all(40.f);

    cv::randn(in_mat1, mean, stddev);
    cv::randn(in_mat2, mean, stddev);
    cv::randn(in_mat3, mean, stddev);

    cv::Mat out_mat(sz_out, type);
    out_mat_ocv = cv::Mat(sz_out, type);

    // G-API code //////////////////////////////////////////////////////////////
    std::vector <cv::GMat> mats(3);
    auto out = cv::gapi::concatVert(mats);

    std::vector <cv::Mat> cvmats = {in_mat1, in_mat2, in_mat3};

    cv::GComputation c({mats[0], mats[1], mats[2]}, {out});
    c.apply(gin(in_mat1, in_mat2, in_mat3), gout(out_mat), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::vconcat(cvmats, out_mat_ocv );
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat, NORM_INF));
    }
}

TEST_P(ConcatHorVecTest, AccuracyTest)
{
    cv::Size sz_out = sz;

    int wpart1 = sz_out.width / 3;
    int wpart2 = sz_out.width / 4;
    cv::Size sz_in1 = cv::Size(wpart1, sz_out.height);
    cv::Size sz_in2 = cv::Size(wpart2, sz_out.height);
    cv::Size sz_in3 = cv::Size(sz_out.width - wpart1 - wpart2, sz_out.height);

    in_mat1 = cv::Mat(sz_in1, type);
    in_mat2 = cv::Mat(sz_in2, type);
    cv::Mat in_mat3 (sz_in3, type);
    cv::Scalar mean = cv::Scalar::all(127);
    cv::Scalar stddev = cv::Scalar::all(40.f);

    cv::randn(in_mat1, mean, stddev);
    cv::randn(in_mat2, mean, stddev);
    cv::randn(in_mat3, mean, stddev);

    cv::Mat out_mat(sz_out, type);
    out_mat_ocv = cv::Mat(sz_out, type);

    // G-API code //////////////////////////////////////////////////////////////
    std::vector <cv::GMat> mats(3);
    auto out = cv::gapi::concatHor(mats);

    std::vector <cv::Mat> cvmats = {in_mat1, in_mat2, in_mat3};

    cv::GComputation c({mats[0], mats[1], mats[2]}, {out});
    c.apply(gin(in_mat1, in_mat2, in_mat3), gout(out_mat), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::hconcat(cvmats, out_mat_ocv );
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat, NORM_INF));
    }
}

TEST_P(LUTTest, AccuracyTest)
{
    int type_mat = type;
    int type_lut = dtype;
    int type_out = CV_MAKETYPE(CV_MAT_DEPTH(type_lut), CV_MAT_CN(type_mat));

    initMatrixRandU(type_mat, sz, type_out);
    cv::Size sz_lut = cv::Size(1, 256);
    cv::Mat in_lut(sz_lut, type_lut);
    cv::randu(in_lut, cv::Scalar::all(0), cv::Scalar::all(255));

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in;
    auto out = cv::gapi::LUT(in, in_lut);

    cv::GComputation c(in, out);
    c.apply(in_mat1, out_mat_gapi, getCompileArgs());
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::LUT(in_mat1, in_lut, out_mat_ocv);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
        EXPECT_EQ(out_mat_gapi.size(), sz);
    }
}

TEST_P(ConvertToTest, AccuracyTest)
{
    int type_mat = type;
    int depth_to = dtype;
    int type_out = CV_MAKETYPE(depth_to, CV_MAT_CN(type_mat));
    initMatrixRandU(type_mat, sz, type_out);

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in;
    auto out = cv::gapi::convertTo(in, depth_to, alpha, beta);

    cv::GComputation c(in, out);
    c.apply(in_mat1, out_mat_gapi, getCompileArgs());
    // OpenCV code /////////////////////////////////////////////////////////////
    {
        in_mat1.convertTo(out_mat_ocv, depth_to, alpha, beta);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
        EXPECT_EQ(out_mat_gapi.size(), sz);
    }
}

TEST_P(PhaseTest, AccuracyTest)
{
    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in_x, in_y;
    auto out = cv::gapi::phase(in_x, in_y, angle_in_degrees);

    cv::GComputation c(in_x, in_y, out);
    c.apply(in_mat1, in_mat2, out_mat_gapi, getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    cv::phase(in_mat1, in_mat2, out_mat_ocv, angle_in_degrees);

    // Comparison //////////////////////////////////////////////////////////////
    // FIXME: use a comparison functor instead (after enabling OpenCL)
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
    }
}

TEST_P(SqrtTest, AccuracyTest)
{
    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in;
    auto out = cv::gapi::sqrt(in);

    cv::GComputation c(in, out);
    c.apply(in_mat1, out_mat_gapi, getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    cv::sqrt(in_mat1, out_mat_ocv);

    // Comparison //////////////////////////////////////////////////////////////
    // FIXME: use a comparison functor instead (after enabling OpenCL)
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
    }
}

TEST_P(WarpPerspectiveTest, AccuracyTest)
{
    cv::Point center{in_mat1.size() / 2};
    cv::Mat xy = cv::getRotationMatrix2D(center, angle, scale);
    cv::Matx13d z (0, 0, 1);
    cv::Mat transform_mat;
    cv::vconcat(xy, z, transform_mat);

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in;
    auto out = cv::gapi::warpPerspective(in, transform_mat, in_mat1.size(), flags, border_mode, border_value);

    cv::GComputation c(in, out);
    c.apply(in_mat1, out_mat_gapi, getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    cv::warpPerspective(in_mat1, out_mat_ocv, cv::Mat(transform_mat), in_mat1.size(), flags, border_mode, border_value);

    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
    }
}

TEST_P(WarpAffineTest, AccuracyTest)
{
    cv::Point center{in_mat1.size() / 2};
    cv::Mat warp_mat = cv::getRotationMatrix2D(center, angle, scale);

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in;
    auto out = cv::gapi::warpAffine(in, warp_mat, in_mat1.size(), flags, border_mode, border_value);

    cv::GComputation c(in, out);
    c.apply(in_mat1, out_mat_gapi, getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    cv::warpAffine(in_mat1, out_mat_ocv, warp_mat, in_mat1.size(), flags, border_mode, border_value);

    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
    }
}

TEST_P(NormalizeTest, Test)
{
    initMatrixRandN(type, sz, CV_MAKETYPE(ddepth, CV_MAT_CN(type)));

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in;
    auto out = cv::gapi::normalize(in, a, b, norm_type, ddepth);

    cv::GComputation c(cv::GIn(in), cv::GOut(out));
    c.apply(cv::gin(in_mat1), cv::gout(out_mat_gapi), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    {
        cv::normalize(in_mat1, out_mat_ocv, a, b, norm_type, ddepth);
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
        EXPECT_EQ(out_mat_gapi.size(), sz);
    }
}

// PLEASE DO NOT PUT NEW ACCURACY TESTS BELOW THIS POINT! //////////////////////

TEST_P(BackendOutputAllocationTest, EmptyOutput)
{
    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2, out;
    out = cv::gapi::mul(in1, in2);
    cv::GComputation c(cv::GIn(in1, in2), cv::GOut(out));

    EXPECT_TRUE(out_mat_gapi.empty());
    c.apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat_gapi), getCompileArgs());
    EXPECT_FALSE(out_mat_gapi.empty());

    // OpenCV code /////////////////////////////////////////////////////////////
    cv::multiply(in_mat1, in_mat2, out_mat_ocv);

    // Comparison //////////////////////////////////////////////////////////////
    // Expected: output is allocated to the needed size
    EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
    EXPECT_EQ(sz, out_mat_gapi.size());
}

TEST_P(BackendOutputAllocationTest, CorrectlyPreallocatedOutput)
{
    out_mat_gapi = cv::Mat(sz, type);
    auto out_mat_gapi_ref = out_mat_gapi;  // shallow copy to ensure previous data is not deleted

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2, out;
    out = cv::gapi::add(in1, in2);
    cv::GComputation c(cv::GIn(in1, in2), cv::GOut(out));
    c.apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat_gapi), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    cv::add(in_mat1, in_mat2, out_mat_ocv);

    // Comparison //////////////////////////////////////////////////////////////
    // Expected: output is not reallocated
    EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
    EXPECT_EQ(sz, out_mat_gapi.size());

    EXPECT_EQ(out_mat_gapi_ref.data, out_mat_gapi.data);
}

TEST_P(BackendOutputAllocationTest, IncorrectOutputMeta)
{
    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2, out;
    out = cv::gapi::add(in1, in2);
    cv::GComputation c(cv::GIn(in1, in2), cv::GOut(out));

    const auto run_and_compare = [&c, this] ()
    {
        auto out_mat_gapi_ref = out_mat_gapi; // shallow copy to ensure previous data is not deleted

        // G-API code //////////////////////////////////////////////////////////////
        c.apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat_gapi), getCompileArgs());

        // OpenCV code /////////////////////////////////////////////////////////////
        cv::add(in_mat1, in_mat2, out_mat_ocv, cv::noArray());

        // Comparison //////////////////////////////////////////////////////////////
        // Expected: size is changed, type is changed, output is reallocated
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
        EXPECT_EQ(sz, out_mat_gapi.size());
        EXPECT_EQ(type, out_mat_gapi.type());

        EXPECT_NE(out_mat_gapi_ref.data, out_mat_gapi.data);
    };

    const auto chan = CV_MAT_CN(type);

    out_mat_gapi = cv::Mat(sz, CV_MAKE_TYPE(CV_64F, chan));
    run_and_compare();

    out_mat_gapi = cv::Mat(sz, CV_MAKE_TYPE(CV_MAT_DEPTH(type), chan + 1));
    run_and_compare();
}

TEST_P(BackendOutputAllocationTest, SmallerPreallocatedSize)
{
    out_mat_gapi = cv::Mat(sz / 2, type);
    auto out_mat_gapi_ref = out_mat_gapi; // shallow copy to ensure previous data is not deleted

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2, out;
    out = cv::gapi::mul(in1, in2);
    cv::GComputation c(cv::GIn(in1, in2), cv::GOut(out));
    c.apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat_gapi), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    cv::multiply(in_mat1, in_mat2, out_mat_ocv);

    // Comparison //////////////////////////////////////////////////////////////
    // Expected: size is changed, output is reallocated due to original size < curr size
    EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
    EXPECT_EQ(sz, out_mat_gapi.size());

    EXPECT_NE(out_mat_gapi_ref.data, out_mat_gapi.data);
}

TEST_P(BackendOutputAllocationTest, SmallerPreallocatedSizeWithSubmatrix)
{
    out_mat_gapi = cv::Mat(sz / 2, type);

    cv::Mat out_mat_gapi_submat = out_mat_gapi(cv::Rect({10, 0}, sz / 5));
    EXPECT_EQ(out_mat_gapi.data, out_mat_gapi_submat.datastart);

    auto out_mat_gapi_submat_ref = out_mat_gapi_submat; // shallow copy to ensure previous data is not deleted

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2, out;
    out = cv::gapi::mul(in1, in2);
    cv::GComputation c(cv::GIn(in1, in2), cv::GOut(out));
    c.apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat_gapi_submat), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    cv::multiply(in_mat1, in_mat2, out_mat_ocv);

    // Comparison //////////////////////////////////////////////////////////////
    // Expected: submatrix is reallocated and is ""detached"", original matrix is unchanged
    EXPECT_EQ(0, cvtest::norm(out_mat_gapi_submat, out_mat_ocv, NORM_INF));
    EXPECT_EQ(sz, out_mat_gapi_submat.size());
    EXPECT_EQ(sz / 2, out_mat_gapi.size());

    EXPECT_NE(out_mat_gapi_submat_ref.data, out_mat_gapi_submat.data);
    EXPECT_NE(out_mat_gapi.data, out_mat_gapi_submat.datastart);
}

TEST_P(BackendOutputAllocationTest, LargerPreallocatedSize)
{
    out_mat_gapi = cv::Mat(sz * 2, type);
    auto out_mat_gapi_ref = out_mat_gapi; // shallow copy to ensure previous data is not deleted

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2, out;
    out = cv::gapi::mul(in1, in2);
    cv::GComputation c(cv::GIn(in1, in2), cv::GOut(out));
    c.apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat_gapi), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    cv::multiply(in_mat1, in_mat2, out_mat_ocv);

    // Comparison //////////////////////////////////////////////////////////////
    // Expected: size is changed, output is reallocated
    EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
    EXPECT_EQ(sz, out_mat_gapi.size());

    EXPECT_NE(out_mat_gapi_ref.data, out_mat_gapi.data);
}

TEST_P(BackendOutputAllocationLargeSizeWithCorrectSubmatrixTest,
    LargerPreallocatedSizeWithCorrectSubmatrix)
{
    out_mat_gapi = cv::Mat(sz * 2, type);
    auto out_mat_gapi_ref = out_mat_gapi; // shallow copy to ensure previous data is not deleted

    cv::Mat out_mat_gapi_submat = out_mat_gapi(cv::Rect({5, 8}, sz));
    EXPECT_EQ(out_mat_gapi.data, out_mat_gapi_submat.datastart);

    auto out_mat_gapi_submat_ref = out_mat_gapi_submat;

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2, out;
    out = cv::gapi::mul(in1, in2);
    cv::GComputation c(cv::GIn(in1, in2), cv::GOut(out));
    c.apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat_gapi_submat), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    cv::multiply(in_mat1, in_mat2, out_mat_ocv);

    // Comparison //////////////////////////////////////////////////////////////
    // Expected: submatrix is not reallocated, original matrix is not reallocated
    EXPECT_EQ(0, cvtest::norm(out_mat_gapi_submat, out_mat_ocv, NORM_INF));
    EXPECT_EQ(sz, out_mat_gapi_submat.size());
    EXPECT_EQ(sz * 2, out_mat_gapi.size());

    EXPECT_EQ(out_mat_gapi_ref.data, out_mat_gapi.data);
    EXPECT_EQ(out_mat_gapi_submat_ref.data, out_mat_gapi_submat.data);
    EXPECT_EQ(out_mat_gapi.data, out_mat_gapi_submat.datastart);
}

TEST_P(BackendOutputAllocationTest, LargerPreallocatedSizeWithSmallSubmatrix)
{
    out_mat_gapi = cv::Mat(sz * 2, type);
    auto out_mat_gapi_ref = out_mat_gapi; // shallow copy to ensure previous data is not deleted

    cv::Mat out_mat_gapi_submat = out_mat_gapi(cv::Rect({5, 8}, sz / 2));
    EXPECT_EQ(out_mat_gapi.data, out_mat_gapi_submat.datastart);

    auto out_mat_gapi_submat_ref = out_mat_gapi_submat;

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2, out;
    out = cv::gapi::mul(in1, in2);
    cv::GComputation c(cv::GIn(in1, in2), cv::GOut(out));
    c.apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat_gapi_submat), getCompileArgs());

    // OpenCV code /////////////////////////////////////////////////////////////
    cv::multiply(in_mat1, in_mat2, out_mat_ocv);

    // Comparison //////////////////////////////////////////////////////////////
    // Expected: submatrix is reallocated and is ""detached"", original matrix is unchanged
    EXPECT_EQ(0, cvtest::norm(out_mat_gapi_submat, out_mat_ocv, NORM_INF));
    EXPECT_EQ(sz, out_mat_gapi_submat.size());
    EXPECT_EQ(sz * 2, out_mat_gapi.size());

    EXPECT_EQ(out_mat_gapi_ref.data, out_mat_gapi.data);
    EXPECT_NE(out_mat_gapi_submat_ref.data, out_mat_gapi_submat.data);
    EXPECT_NE(out_mat_gapi.data, out_mat_gapi_submat.datastart);
}

TEST_P(ReInitOutTest, TestWithAdd)
{
    in_mat1 = cv::Mat(sz, type);
    in_mat2 = cv::Mat(sz, type);
    cv::randu(in_mat1, cv::Scalar::all(0), cv::Scalar::all(100));
    cv::randu(in_mat2, cv::Scalar::all(0), cv::Scalar::all(100));

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in1, in2, out;
    out = cv::gapi::add(in1, in2, dtype);
    cv::GComputation c(cv::GIn(in1, in2), cv::GOut(out));

    const auto run_and_compare = [&c, this] ()
    {
        // G-API code //////////////////////////////////////////////////////////////
        c.apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat_gapi), getCompileArgs());

        // OpenCV code /////////////////////////////////////////////////////////////
        cv::add(in_mat1, in_mat2, out_mat_ocv, cv::noArray());

        // Comparison //////////////////////////////////////////////////////////////
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
        EXPECT_EQ(out_mat_gapi.size(), sz);
    };

    // run for uninitialized output
    run_and_compare();

    // run for initialized output (can be initialized with a different size)
    initOutMats(out_sz, type);
    run_and_compare();
}

TEST_P(ParseSSDBLTest, ParseTest)
{
    cv::Mat in_mat = generateSSDoutput(sz);
    std::vector<cv::Rect> boxes_gapi, boxes_ref;
    std::vector<int> labels_gapi, labels_ref;

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in;
    cv::GOpaque<cv::Size> op_sz;
    auto out = cv::gapi::parseSSD(in, op_sz, confidence_threshold, filter_label);
    cv::GComputation c(cv::GIn(in, op_sz), cv::GOut(std::get<0>(out), std::get<1>(out)));
    c.apply(cv::gin(in_mat, sz), cv::gout(boxes_gapi, labels_gapi), getCompileArgs());

    // Reference code //////////////////////////////////////////////////////////
    parseSSDBLref(in_mat, sz, confidence_threshold, filter_label, boxes_ref, labels_ref);

    // Comparison //////////////////////////////////////////////////////////////
    EXPECT_TRUE(boxes_gapi == boxes_ref);
    EXPECT_TRUE(labels_gapi == labels_ref);
}

TEST_P(ParseSSDTest, ParseTest)
{
    cv::Mat in_mat = generateSSDoutput(sz);
    std::vector<cv::Rect> boxes_gapi, boxes_ref;

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in;
    cv::GOpaque<cv::Size> op_sz;
    auto out = cv::gapi::parseSSD(in, op_sz, confidence_threshold,
                                  alignment_to_square, filter_out_of_bounds);
    cv::GComputation c(cv::GIn(in, op_sz), cv::GOut(out));
    c.apply(cv::gin(in_mat, sz), cv::gout(boxes_gapi), getCompileArgs());

    // Reference code //////////////////////////////////////////////////////////
    parseSSDref(in_mat, sz, confidence_threshold, alignment_to_square,
                filter_out_of_bounds, boxes_ref);

    // Comparison //////////////////////////////////////////////////////////////
    EXPECT_TRUE(boxes_gapi == boxes_ref);
}

TEST_P(ParseYoloTest, ParseTest)
{
    cv::Mat in_mat = generateYoloOutput(num_classes);
    auto anchors = cv::gapi::nn::parsers::GParseYolo::defaultAnchors();
    std::vector<cv::Rect> boxes_gapi, boxes_ref;
    std::vector<int> labels_gapi, labels_ref;

    // G-API code //////////////////////////////////////////////////////////////
    cv::GMat in;
    cv::GOpaque<cv::Size> op_sz;
    auto out = cv::gapi::parseYolo(in, op_sz, confidence_threshold, nms_threshold, anchors);
    cv::GComputation c(cv::GIn(in, op_sz), cv::GOut(std::get<0>(out), std::get<1>(out)));
    c.apply(cv::gin(in_mat, sz), cv::gout(boxes_gapi, labels_gapi), getCompileArgs());

    // Reference code //////////////////////////////////////////////////////////
    parseYoloRef(in_mat, sz, confidence_threshold, nms_threshold, num_classes, anchors, boxes_ref, labels_ref);

    // Comparison //////////////////////////////////////////////////////////////
    EXPECT_TRUE(boxes_gapi == boxes_ref);
    EXPECT_TRUE(labels_gapi == labels_ref);
}

TEST_P(SizeTest, ParseTest)
{
    cv::GMat in;
    cv::Size out_sz;

    auto out = cv::gapi::size(in);
    cv::GComputation c(cv::GIn(in), cv::GOut(out));
    c.apply(cv::gin(in_mat1), cv::gout(out_sz), getCompileArgs());

    EXPECT_EQ(out_sz, sz);
}

TEST_P(SizeRTest, ParseTest)
{
    cv::Rect rect(cv::Point(0,0), sz);
    cv::Size out_sz;

    cv::GOpaque<cv::Rect> op_rect;
    auto out = cv::gapi::size(op_rect);
    cv::GComputation c(cv::GIn(op_rect), cv::GOut(out));
    c.apply(cv::gin(rect), cv::gout(out_sz), getCompileArgs());

    EXPECT_EQ(out_sz, sz);
}

} // opencv_test

#endif //OPENCV_GAPI_CORE_TESTS_INL_HPP
",16300,True,3524.6779937368515,median
"[[smpp-component]]
= SMPP Component
:page-source: components/camel-smpp/src/main/docs/smpp-component.adoc

*Since Camel 2.2*

// HEADER START
*Both producer and consumer is supported*
// HEADER END

This component provides access to an SMSC (Short Message Service Center)
over the http://smsforum.net/SMPP_v3_4_Issue1_2.zip[SMPP] protocol to
send and receive SMS. The http://jsmpp.org[JSMPP] library is used for
the protocol implementation.

The Camel component currently operates as an
http://en.wikipedia.org/wiki/ESME[ESME] (External Short Messaging
Entity) and not as an SMSC itself.

You are also able to execute ReplaceSm,
QuerySm, SubmitMulti, CancelSm and DataSm.

Maven users will need to add the following dependency to their `pom.xml`
for this component:

[source,xml]
------------------------------------------------------------
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-smpp</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
------------------------------------------------------------

== SMS limitations

SMS is neither reliable or secure.  Users who require reliable and
secure delivery may want to consider using the XMPP or SIP components
instead, combined with a smartphone app supporting the chosen protocol.

* Reliability: although the SMPP standard offers a range of feedback
mechanisms to indicate errors, non-delivery and confirmation of delivery
it is not uncommon for mobile networks to hide or simulate these
responses.  For example, some networks automatically send a delivery
confirmation for every message even if the destination number is invalid
or not switched on.  Some networks silently drop messages if they think
they are spam.  Spam detection rules in the network may be very crude,
sometimes more than 100 messages per day from a single sender may be
considered spam.
* Security: there is basic encryption for the last hop from the radio
tower down to the recipient handset.  SMS messages are not encrypted or
authenticated in any other part of the network.  Some operators allow
staff in retail outlets or call centres to browse through the SMS
message histories of their customers.  Message sender identity can be
easily forged.  Regulators and even the mobile telephone industry itself
has cautioned against the use of SMS in two-factor authentication
schemes and other purposes where security is important.

While the Camel component makes it as easy as possible to send messages
to the SMS network, it can not offer an easy solution to these problems.

== Data coding, alphabet and international character sets

Data coding and alphabet can be specified on a per-message basis. 
Default values can be specified for the endpoint.  It is important to
understand the relationship between these options and the way the
component acts when more than one value is set.

Data coding is an 8 bit field in the SMPP wire format.

Alphabet corresponds to bits 0-3 of the data coding field.  For some
types of message, where a message class is used (by setting bit 5 of the
data coding field), the lower two bits of the data coding field are not
interpreted as alphabet and only bits 2 and 3 impact the alphabet.

Furthermore, current version of the JSMPP library only seems to support
bits 2 and 3, assuming that bits 0 and 1 are used for message class. 
This is why the Alphabet class in JSMPP doesn't support the value 3
(binary 0011) which indicates ISO-8859-1.

Although JSMPP provides a representation of the message class parameter,
the Camel component doesn't currently provide a way to set it other than
manually setting the corresponding bits in the data coding field.

When setting the data coding field in the outgoing message, the Camel
component considers the following values and uses the first one it can
find:

* the data coding specified in a header
* the alphabet specified in a header
* the data coding specified in the endpoint configuration (URI
parameter)

Older versions of Camel had bugs in support for international character
sets.  This feature only worked when a single encoding was used for all
messages and was troublesome when users wanted to change it on a
per-message basis.  Users who require this to work should ensure their
version of Camel includes the fix for 

JIRA Issues Macro: com.atlassian.sal.api.net.ResponseStatusException:
Unexpected response received. Status code: 404

.

In addition to trying to send the data coding value to the SMSC, the
Camel component also tries to analyze the message body, convert it to a
Java String (Unicode) and convert that to a byte array in the
corresponding alphabet  When deciding which alphabet to use in the byte
array, the Camel SMPP component does not consider the data coding value
(header or configuration), it only considers the specified alphabet
(from either the header or endpoint parameter).

If some characters in the String can't be represented in the chosen
alphabet, they may be replaced by the question mark ( ? ) symbol.  Users
of the API may want to consider checking if their message body can be
converted to ISO-8859-1 before passing it to the component and if not,
setting the alphabet header to request UCS-2 encoding.  If the alphabet
and data coding options are not specified at all then the component may
try to detect the required encoding and set the data coding for you.

The list of alphabet codes are specified in the SMPP specification v3.4,
section 5.2.19.  One notable limitation of the SMPP specification is
that there is no alphabet code for explicitly requesting use of the GSM
3.38 (7 bit) character set.  Choosing the value 0 for the alphabet
selects the SMSC _default_ alphabet, this usually means GSM 3.38 but it
is not guaranteed.  The SMPP gateway Nexmo
https://help.nexmo.com/hc/en-us/articles/204015813-How-to-change-the-character-encoding-in-SMPP-[actually
allows the default to be mapped to any other character set with a
control panel option]. It is suggested that users check with their SMSC
operator to confirm exactly which character set is being used as the
default.

== Message splitting and throttling

After transforming a message body from a String to a byte array, the
Camel component is also responsible for splitting the message into parts
(within the 140 byte SMS size limit) before passing it to JSMPP.  This
is completed automatically.

If the GSM 3.38 alphabet is used, the component will pack up to 160
characters into the 140 byte message body.  If an 8 bit character set is
used (e.g. ISO-8859-1 for western Europe) then 140 characters will be
allowed within the 140 byte message body.  If 16 bit UCS-2 encoding is
used then just 70 characters fit into each 140 byte message.

Some SMSC providers implement throttling rules.  Each part of a message
that has been split may be counted separately by the provider's
throttling mechanism.  The Camel Throttler component can be useful for
throttling messages in the SMPP route before handing them to the SMSC.

== URI format

[source,java]
--------------------------------------------
smpp://[username@]hostname[:port][?options]
smpps://[username@]hostname[:port][?options]
--------------------------------------------

If no *username* is provided, then Camel will provide the default value
`smppclient`. +
 If no *port* number is provided, then Camel will provide the default
value `2775`. +
If the protocol name is ""smpps"", camel-smpp with try to
use SSLSocket to init a connection to the server.

You can append query options to the URI in the following format,
`?option=value&option=value&...`

== URI Options




// component options: START
The SMPP component supports 4 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *configuration* (advanced) | To use the shared SmppConfiguration as configuration. |  | SmppConfiguration
| *basicPropertyBinding* (advanced) | Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
|===
// component options: END






// endpoint options: START
The SMPP endpoint is configured using URI syntax:

----
smpp:host:port
----

with the following path and query parameters:

=== Path Parameters (2 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *host* | Hostname for the SMSC server to use. | localhost | String
| *port* | Port number for the SMSC server to use. | 2775 | Integer
|===


=== Query Parameters (40 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *initialReconnectDelay* (common) | Defines the initial delay in milliseconds after the consumer/producer tries to reconnect to the SMSC, after the connection was lost. | 5000 | long
| *maxReconnect* (common) | Defines the maximum number of attempts to reconnect to the SMSC, if SMSC returns a negative bind response | 2147483647 | int
| *reconnectDelay* (common) | Defines the interval in milliseconds between the reconnect attempts, if the connection to the SMSC was lost and the previous was not succeed. | 5000 | long
| *splittingPolicy* (common) | You can specify a policy for handling long messages: ALLOW - the default, long messages are split to 140 bytes per message TRUNCATE - long messages are split and only the first fragment will be sent to the SMSC. Some carriers drop subsequent fragments so this reduces load on the SMPP connection sending parts of a message that will never be delivered. REJECT - if a message would need to be split, it is rejected with an SMPP NegativeResponseException and the reason code signifying the message is too long. | ALLOW | SmppSplittingPolicy
| *systemType* (common) | This parameter is used to categorize the type of ESME (External Short Message Entity) that is binding to the SMSC (max. 13 characters). |  | String
| *addressRange* (consumer) | You can specify the address range for the SmppConsumer as defined in section 5.2.7 of the SMPP 3.4 specification. The SmppConsumer will receive messages only from SMSC's which target an address (MSISDN or IP address) within this range. |  | String
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. |  | ExchangePattern
| *destAddr* (producer) | Defines the destination SME address. For mobile terminated messages, this is the directory number of the recipient MS. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. | 1717 | String
| *destAddrNpi* (producer) | Defines the type of number (TON) to be used in the SME destination address parameters. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. The following NPI values are defined: 0: Unknown 1: ISDN (E163/E164) 2: Data (X.121) 3: Telex (F.69) 6: Land Mobile (E.212) 8: National 9: Private 10: ERMES 13: Internet (IP) 18: WAP Client Id (to be defined by WAP Forum) |  | byte
| *destAddrTon* (producer) | Defines the type of number (TON) to be used in the SME destination address parameters. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. The following TON values are defined: 0: Unknown 1: International 2: National 3: Network Specific 4: Subscriber Number 5: Alphanumeric 6: Abbreviated |  | byte
| *lazySessionCreation* (producer) | Sessions can be lazily created to avoid exceptions, if the SMSC is not available when the Camel producer is started. Camel will check the in message headers 'CamelSmppSystemId' and 'CamelSmppPassword' of the first exchange. If they are present, Camel will use these data to connect to the SMSC. | false | boolean
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *numberingPlanIndicator* (producer) | Defines the numeric plan indicator (NPI) to be used in the SME. The following NPI values are defined: 0: Unknown 1: ISDN (E163/E164) 2: Data (X.121) 3: Telex (F.69) 6: Land Mobile (E.212) 8: National 9: Private 10: ERMES 13: Internet (IP) 18: WAP Client Id (to be defined by WAP Forum) |  | byte
| *priorityFlag* (producer) | Allows the originating SME to assign a priority level to the short message. Only for SubmitSm and SubmitMulti. Four Priority Levels are supported: 0: Level 0 (lowest) priority 1: Level 1 priority 2: Level 2 priority 3: Level 3 (highest) priority |  | byte
| *protocolId* (producer) | The protocol id |  | byte
| *registeredDelivery* (producer) | Is used to request an SMSC delivery receipt and/or SME originated acknowledgements. The following values are defined: 0: No SMSC delivery receipt requested. 1: SMSC delivery receipt requested where final delivery outcome is success or failure. 2: SMSC delivery receipt requested where the final delivery outcome is delivery failure. |  | byte
| *replaceIfPresentFlag* (producer) | Used to request the SMSC to replace a previously submitted message, that is still pending delivery. The SMSC will replace an existing message provided that the source address, destination address and service type match the same fields in the new message. The following replace if present flag values are defined: 0: Don't replace 1: Replace |  | byte
| *serviceType* (producer) | The service type parameter can be used to indicate the SMS Application service associated with the message. The following generic service_types are defined: CMT: Cellular Messaging CPT: Cellular Paging VMN: Voice Mail Notification VMA: Voice Mail Alerting WAP: Wireless Application Protocol USSD: Unstructured Supplementary Services Data |  | String
| *sourceAddr* (producer) | Defines the address of SME (Short Message Entity) which originated this message. | 1616 | String
| *sourceAddrNpi* (producer) | Defines the numeric plan indicator (NPI) to be used in the SME originator address parameters. The following NPI values are defined: 0: Unknown 1: ISDN (E163/E164) 2: Data (X.121) 3: Telex (F.69) 6: Land Mobile (E.212) 8: National 9: Private 10: ERMES 13: Internet (IP) 18: WAP Client Id (to be defined by WAP Forum) |  | byte
| *sourceAddrTon* (producer) | Defines the type of number (TON) to be used in the SME originator address parameters. The following TON values are defined: 0: Unknown 1: International 2: National 3: Network Specific 4: Subscriber Number 5: Alphanumeric 6: Abbreviated |  | byte
| *typeOfNumber* (producer) | Defines the type of number (TON) to be used in the SME. The following TON values are defined: 0: Unknown 1: International 2: National 3: Network Specific 4: Subscriber Number 5: Alphanumeric 6: Abbreviated |  | byte
| *basicPropertyBinding* (advanced) | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
| *enquireLinkTimer* (advanced) | Defines the interval in milliseconds between the confidence checks. The confidence check is used to test the communication path between an ESME and an SMSC. | 5000 | Integer
| *sessionStateListener* (advanced) | You can refer to a org.jsmpp.session.SessionStateListener in the Registry to receive callbacks when the session state changed. |  | SessionStateListener
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
| *transactionTimer* (advanced) | Defines the maximum period of inactivity allowed after a transaction, after which an SMPP entity may assume that the session is no longer active. This timer may be active on either communicating SMPP entity (i.e. SMSC or ESME). | 10000 | Integer
| *alphabet* (codec) | Defines encoding of data according the SMPP 3.4 specification, section 5.2.19. 0: SMSC Default Alphabet 4: 8 bit Alphabet 8: UCS2 Alphabet |  | byte
| *dataCoding* (codec) | Defines the data coding according the SMPP 3.4 specification, section 5.2.19. Example data encodings are: 0: SMSC Default Alphabet 3: Latin 1 (ISO-8859-1) 4: Octet unspecified (8-bit binary) 8: UCS2 (ISO/IEC-10646) 13: Extended Kanji JIS(X 0212-1990) |  | byte
| *encoding* (codec) | Defines the encoding scheme of the short message user data. Only for SubmitSm, ReplaceSm and SubmitMulti. | ISO-8859-1 | String
| *httpProxyHost* (proxy) | If you need to tunnel SMPP through a HTTP proxy, set this attribute to the hostname or ip address of your HTTP proxy. |  | String
| *httpProxyPassword* (proxy) | If your HTTP proxy requires basic authentication, set this attribute to the password required for your HTTP proxy. |  | String
| *httpProxyPort* (proxy) | If you need to tunnel SMPP through a HTTP proxy, set this attribute to the port of your HTTP proxy. | 3128 | Integer
| *httpProxyUsername* (proxy) | If your HTTP proxy requires basic authentication, set this attribute to the username required for your HTTP proxy. |  | String
| *proxyHeaders* (proxy) | These headers will be passed to the proxy server while establishing the connection. |  | Map
| *password* (security) | The password for connecting to SMSC server. |  | String
| *systemId* (security) | The system id (username) for connecting to SMSC server. | smppclient | String
| *usingSSL* (security) | Whether using SSL with the smpps protocol | false | boolean
|===
// endpoint options: END
// spring-boot-auto-configure options: START
== Spring Boot Auto-Configuration

When using Spring Boot make sure to use the following Maven dependency to have support for auto configuration:

[source,xml]
----
<dependency>
  <groupId>org.apache.camel.springboot</groupId>
  <artifactId>camel-smpp-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
----


The component supports 40 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *camel.component.smpp.basic-property-binding* | Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | Boolean
| *camel.component.smpp.bridge-error-handler* | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | Boolean
| *camel.component.smpp.configuration.address-range* | You can specify the address range for the SmppConsumer as defined in section 5.2.7 of the SMPP 3.4 specification. The SmppConsumer will receive messages only from SMSC's which target an address (MSISDN or IP address) within this range. |  | String
| *camel.component.smpp.configuration.alphabet* | Defines encoding of data according the SMPP 3.4 specification, section 5.2.19. <ul> <li>0: SMSC Default Alphabet <li>4: 8 bit Alphabet</li> <li>8: UCS2 Alphabet</li></li> </ul> |  | Byte
| *camel.component.smpp.configuration.data-coding* | Defines the data coding according the SMPP 3.4 specification, section 5.2.19. Example data encodings are: <ul> <li>0: SMSC Default Alphabet</li> <li>3: Latin 1 (ISO-8859-1)</li> <li>4: Octet unspecified (8-bit binary)</li> <li>8: UCS2 (ISO/IEC-10646)</li> <li>13: Extended Kanji JIS(X 0212-1990)</li> </ul> |  | Byte
| *camel.component.smpp.configuration.dest-addr* | Defines the destination SME address. For mobile terminated messages, this is the directory number of the recipient MS. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. | 1717 | String
| *camel.component.smpp.configuration.dest-addr-npi* | Defines the type of number (TON) to be used in the SME destination address parameters. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. The following NPI values are defined: <ul> <li>0: Unknown</li> <li>1: ISDN (E163/E164)</li> <li>2: Data (X.121)</li> <li>3: Telex (F.69)</li> <li>6: Land Mobile (E.212)</li> <li>8: National</li> <li>9: Private</li> <li>10: ERMES</li> <li>13: Internet (IP)</li> <li>18: WAP Client Id (to be defined by WAP Forum)</li> </ul> |  | Byte
| *camel.component.smpp.configuration.dest-addr-ton* | Defines the type of number (TON) to be used in the SME destination address parameters. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. The following TON values are defined: <ul> <li>0: Unknown</li> <li>1: International</li> <li>2: National</li> <li>3: Network Specific</li> <li>4: Subscriber Number</li> <li>5: Alphanumeric</li> <li>6: Abbreviated</li> </ul> |  | Byte
| *camel.component.smpp.configuration.encoding* | Defines the encoding scheme of the short message user data. Only for SubmitSm, ReplaceSm and SubmitMulti. | ISO-8859-1 | String
| *camel.component.smpp.configuration.enquire-link-timer* | Defines the interval in milliseconds between the confidence checks. The confidence check is used to test the communication path between an ESME and an SMSC. | 5000 | Integer
| *camel.component.smpp.configuration.host* | Hostname for the SMSC server to use. | localhost | String
| *camel.component.smpp.configuration.http-proxy-host* | If you need to tunnel SMPP through a HTTP proxy, set this attribute to the hostname or ip address of your HTTP proxy. |  | String
| *camel.component.smpp.configuration.http-proxy-password* | If your HTTP proxy requires basic authentication, set this attribute to the password required for your HTTP proxy. |  | String
| *camel.component.smpp.configuration.http-proxy-port* | If you need to tunnel SMPP through a HTTP proxy, set this attribute to the port of your HTTP proxy. | 3128 | Integer
| *camel.component.smpp.configuration.http-proxy-username* | If your HTTP proxy requires basic authentication, set this attribute to the username required for your HTTP proxy. |  | String
| *camel.component.smpp.configuration.initial-reconnect-delay* | Defines the initial delay in milliseconds after the consumer/producer tries to reconnect to the SMSC, after the connection was lost. | 5000 | Long
| *camel.component.smpp.configuration.lazy-session-creation* | Sessions can be lazily created to avoid exceptions, if the SMSC is not available when the Camel producer is started. Camel will check the in message headers 'CamelSmppSystemId' and 'CamelSmppPassword' of the first exchange. If they are present, Camel will use these data to connect to the SMSC. | false | Boolean
| *camel.component.smpp.configuration.max-reconnect* | Defines the maximum number of attempts to reconnect to the SMSC, if SMSC returns a negative bind response | 2147483647 | Integer
| *camel.component.smpp.configuration.numbering-plan-indicator* | Defines the numeric plan indicator (NPI) to be used in the SME. The following NPI values are defined: <ul> <li>0: Unknown</li> <li>1: ISDN (E163/E164)</li> <li>2: Data (X.121)</li> <li>3: Telex (F.69)</li> <li>6: Land Mobile (E.212)</li> <li>8: National</li> <li>9: Private</li> <li>10: ERMES</li> <li>13: Internet (IP)</li> <li>18: WAP Client Id (to be defined by WAP Forum)</li> </ul> |  | Byte
| *camel.component.smpp.configuration.password* | Defines the encoding scheme of the short message user data. Only for SubmitSm, ReplaceSm and SubmitMulti. |  | String
| *camel.component.smpp.configuration.port* | Port number for the SMSC server to use. | 2775 | Integer
| *camel.component.smpp.configuration.priority-flag* | Allows the originating SME to assign a priority level to the short message. Only for SubmitSm and SubmitMulti. Four Priority Levels are supported: <ul> <li>0: Level 0 (lowest) priority</li> <li>1: Level 1 priority</li> <li>2: Level 2 priority</li> <li>3: Level 3 (highest) priority</li> </ul> |  | Byte
| *camel.component.smpp.configuration.protocol-id* | The protocol id |  | Byte
| *camel.component.smpp.configuration.proxy-headers* | These headers will be passed to the proxy server while establishing the connection. |  | Map
| *camel.component.smpp.configuration.reconnect-delay* | Defines the interval in milliseconds between the reconnect attempts, if the connection to the SMSC was lost and the previous was not succeed. | 5000 | Long
| *camel.component.smpp.configuration.registered-delivery* | Is used to request an SMSC delivery receipt and/or SME originated acknowledgements. The following values are defined: <ul> <li>0: No SMSC delivery receipt requested.</li> <li>1: SMSC delivery receipt requested where final delivery outcome is success or failure.</li> <li>2: SMSC delivery receipt requested where the final delivery outcome is delivery failure.</li> </ul> |  | Byte
| *camel.component.smpp.configuration.replace-if-present-flag* | Used to request the SMSC to replace a previously submitted message, that is still pending delivery. The SMSC will replace an existing message provided that the source address, destination address and service type match the same fields in the new message. The following replace if present flag values are defined: <ul> <li>0: Don't replace</li> <li>1: Replace</li> </ul> |  | Byte
| *camel.component.smpp.configuration.service-type* | The service type parameter can be used to indicate the SMS Application service associated with the message. The following generic service_types are defined: <ul> <li>CMT: Cellular Messaging</li> <li>CPT: Cellular Paging</li> <li>VMN: Voice Mail Notification</li> <li>VMA: Voice Mail Alerting</li> <li>WAP: Wireless Application Protocol</li> <li>USSD: Unstructured Supplementary Services Data</li> </ul> |  | String
| *camel.component.smpp.configuration.session-state-listener* | You can refer to a org.jsmpp.session.SessionStateListener in the Registry to receive callbacks when the session state changed. |  | SessionStateListener
| *camel.component.smpp.configuration.source-addr* | Defines the address of SME (Short Message Entity) which originated this message. | 1616 | String
| *camel.component.smpp.configuration.source-addr-npi* | Defines the numeric plan indicator (NPI) to be used in the SME originator address parameters. The following NPI values are defined: <ul> <li>0: Unknown</li> <li>1: ISDN (E163/E164)</li> <li>2: Data (X.121)</li> <li>3: Telex (F.69)</li> <li>6: Land Mobile (E.212)</li> <li>8: National</li> <li>9: Private</li> <li>10: ERMES</li> <li>13: Internet (IP)</li> <li>18: WAP Client Id (to be defined by WAP Forum)</li> </ul> |  | Byte
| *camel.component.smpp.configuration.source-addr-ton* | Defines the type of number (TON) to be used in the SME originator address parameters. The following TON values are defined: <ul> <li>0: Unknown</li> <li>1: International</li> <li>2: National</li> <li>3: Network Specific</li> <li>4: Subscriber Number</li> <li>5: Alphanumeric</li> <li>6: Abbreviated</li> </ul> |  | Byte
| *camel.component.smpp.configuration.splitting-policy* | You can specify a policy for handling long messages: <ul> <li>ALLOW - the default, long messages are split to 140 bytes per message</li> <li>TRUNCATE - long messages are split and only the first fragment will be sent to the SMSC. Some carriers drop subsequent fragments so this reduces load on the SMPP connection sending parts of a message that will never be delivered.</li> <li>REJECT - if a message would need to be split, it is rejected with an SMPP NegativeResponseException and the reason code signifying the message is too long.</li> </ul> |  | SmppSplittingPolicy
| *camel.component.smpp.configuration.system-id* | The system id (username) for connecting to SMSC server. | smppclient | String
| *camel.component.smpp.configuration.system-type* | This parameter is used to categorize the type of ESME (External Short Message Entity) that is binding to the SMSC (max. 13 characters). |  | String
| *camel.component.smpp.configuration.transaction-timer* | Defines the maximum period of inactivity allowed after a transaction, after which an SMPP entity may assume that the session is no longer active. This timer may be active on either communicating SMPP entity (i.e. SMSC or ESME). | 10000 | Integer
| *camel.component.smpp.configuration.type-of-number* | Defines the type of number (TON) to be used in the SME. The following TON values are defined: <ul> <li>0: Unknown</li> <li>1: International</li> <li>2: National</li> <li>3: Network Specific</li> <li>4: Subscriber Number</li> <li>5: Alphanumeric</li> <li>6: Abbreviated</li> </ul> |  | Byte
| *camel.component.smpp.configuration.using-s-s-l* | Whether using SSL with the smpps protocol | false | Boolean
| *camel.component.smpp.enabled* | Whether to enable auto configuration of the smpp component. This is enabled by default. |  | Boolean
| *camel.component.smpp.lazy-start-producer* | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | Boolean
|===
// spring-boot-auto-configure options: END




You can have as many of these options as you like.

[source,java]
------------------------------------------------------------------------------------------------------------------
smpp://smppclient@localhost:2775?password=password&enquireLinkTimer=3000&transactionTimer=5000&systemType=consumer
------------------------------------------------------------------------------------------------------------------

== Producer Message Headers

The following message headers can be used to affect the behavior of the
SMPP producer

[width=""100%"",cols=""10%,10%,80%"",options=""header"",]
|=======================================================================
|Header |Type |Description

|`CamelSmppDestAddr` |`List`/`String` |*only for SubmitSm, SubmitMulti, CancelSm and DataSm* Defines the
destination SME address(es). For mobile terminated messages, this is the
directory number of the recipient MS. Is must be a `List<String>` for
SubmitMulti and a `String` otherwise.

|`CamelSmppDestAddrTon` |`Byte` |*only for SubmitSm, SubmitMulti, CancelSm and DataSm* Defines the type
of number (TON) to be used in the SME destination address parameters.
Use the `sourceAddrTon` URI option values defined above.

|`CamelSmppDestAddrNpi` |`Byte` |*only for SubmitSm, SubmitMulti, CancelSm and DataSm* Defines the
numeric plan indicator (NPI) to be used in the SME destination address
parameters. Use the URI option `sourceAddrNpi` values defined above.

|`CamelSmppSourceAddr` |`String` |Defines the address of SME (Short Message Entity) which originated this
message.

|`CamelSmppSourceAddrTon` |`Byte` |Defines the type of number (TON) to be used in the SME originator
address parameters. Use the `sourceAddrTon` URI option values defined
above.

|`CamelSmppSourceAddrNpi` |`Byte` |Defines the numeric plan indicator (NPI) to be used in the SME
originator address parameters. Use the URI option `sourceAddrNpi` values
defined above.

|`CamelSmppServiceType` |`String` |The service type parameter can be used to indicate the SMS Application
service associated with the message. Use the URI option `serviceType`
settings above.

|`CamelSmppRegisteredDelivery` |`Byte` |*only for SubmitSm, ReplaceSm, SubmitMulti and DataSm* Is used to
request an SMSC delivery receipt and/or SME originated acknowledgements.
Use the URI option `registeredDelivery` settings above.

|`CamelSmppPriorityFlag` |`Byte` |*only for SubmitSm and SubmitMulti* Allows the originating SME to assign
a priority level to the short message. Use the URI option `priorityFlag`
settings above.

|`CamelSmppScheduleDeliveryTime` |`Date` |*only for SubmitSm, SubmitMulti and ReplaceSm* This parameter specifies
the scheduled time at which the message delivery should be first
attempted. It defines either the absolute date and time or relative time
from the current SMSC time at which delivery of this message will be
attempted by the SMSC. It can be specified in either absolute time
format or relative time format. The encoding of a time format is
specified in chapter 7.1.1. in the smpp specification v3.4.

|`CamelSmppValidityPeriod` |`String`/`Date` |*only for SubmitSm, SubmitMulti and ReplaceSm* The validity period
parameter indicates the SMSC expiration time, after which the message
should be discarded if not delivered to the destination. If it's
provided as `Date`, it's interpreted as absolute time or relative time
format if you provide it as `String` as specified in chapter 7.1.1 in
the smpp specification v3.4.

|`CamelSmppReplaceIfPresentFlag` |`Byte` |*only for SubmitSm and SubmitMulti* The replace if present flag
parameter is used to request the SMSC to replace a previously submitted
message, that is still pending delivery. The SMSC will replace an
existing message provided that the source address, destination address
and service type match the same fields in the new message. The following
values are defined: `0`, Don't replace and `1`, Replace

|`CamelSmppAlphabet` / `CamelSmppDataCoding` |`Byte` |*For SubmitSm, SubmitMulti and ReplaceSm*  The data
coding according to the SMPP 3.4 specification, section 5.2.19. Use the
URI option `alphabet` settings above.

|`CamelSmppOptionalParameter` |`Map<Short, Object>` |*only for SubmitSm, SubmitMulti and
DataSm* The optional parameter which are send to the SMSC. The value is
converted in the following way: `String` -> `org.jsmpp.bean.OptionalParameter.COctetString`, 
`byte[]` -> `org.jsmpp.bean.OptionalParameter.OctetString`, 
`Byte` -> `org.jsmpp.bean.OptionalParameter.Byte`,
`Integer` -> `org.jsmpp.bean.OptionalParameter.Int`,
`Short` -> `org.jsmpp.bean.OptionalParameter.Short`, 
`null` -> `org.jsmpp.bean.OptionalParameter.Null`

|CamelSmppEncoding |String |*only for SubmitSm,
SubmitMulti and DataSm*.  Specifies the encoding (character set name) of
the bytes in the message body.  If the message body is a string then
this is not relevant because Java Strings are always Unicode.  If the
body is a byte array then this header can be used to indicate that it is
ISO-8859-1 or some other value.  Default value is specified by the
endpoint configuration parameter _encoding_

|CamelSmppSplittingPolicy |String |*only for SubmitSm,
SubmitMulti and DataSm*.  Specifies the policy for message splitting for
this exchange.  Possible values are described in the endpoint
configuration parameter _splittingPolicy_
|=======================================================================

The following message headers are used by the SMPP producer to set the
response from the SMSC in the message header

[width=""100%"",cols=""10%,10%,80%"",options=""header"",]
|=======================================================================
|Header |Type |Description

|`CamelSmppId` |`List<String>`/`String` |The id to identify the submitted short message(s) for later use.
In case of a ReplaceSm, QuerySm, CancelSm and DataSm this
header vaule is a `String`. In case of a SubmitSm or SubmitMultiSm this
header vaule is a `List<String>`.

|`CamelSmppSentMessageCount` |`Integer` |*only for SubmitSm and SubmitMultiSm* The total
number of messages which has been sent.

|`CamelSmppError` |`Map<String, List<Map<String, Object>>>` |*only for SubmitMultiSm* The errors which
occurred by sending the short message(s) the form `Map<String, List<Map<String, Object>>>` (messageID : (destAddr :
address, error : errorCode)).

|`CamelSmppOptionalParameter` |`Map<Short, Object>` |*only for DataSm* The optional
parameter which are returned from the SMSC by sending the message. The
key is the `Short` code for the optional parameter. The value is
converted in the following way: 
`org.jsmpp.bean.OptionalParameter.COctetString` -> `String`,
`org.jsmpp.bean.OptionalParameter.OctetString` -> `byte[]`,
`org.jsmpp.bean.OptionalParameter.Byte` -> `Byte`,
`org.jsmpp.bean.OptionalParameter.Int` -> `Integer`,
`org.jsmpp.bean.OptionalParameter.Short` -> `Short`, 
`org.jsmpp.bean.OptionalParameter.Null` -> `null`
|=======================================================================

== Consumer Message Headers

The following message headers are used by the SMPP consumer to set the
request data from the SMSC in the message header

[width=""100%"",cols=""10%,10%,80%"",options=""header"",]
|=======================================================================
|Header |Type |Description

|`CamelSmppSequenceNumber` |`Integer` |*only for AlertNotification, DeliverSm and DataSm* A sequence number
allows a response PDU to be correlated with a request PDU. The
associated SMPP response PDU must preserve this field.

|`CamelSmppCommandId` |`Integer` |*only for AlertNotification, DeliverSm and DataSm* The command id field
identifies the particular SMPP PDU. For the complete list of defined
values see chapter 5.1.2.1 in the smpp specification v3.4.

|`CamelSmppSourceAddr` |`String` |*only for AlertNotification, DeliverSm and DataSm* Defines the address
of SME (Short Message Entity) which originated this message.

|`CamelSmppSourceAddrNpi` |`Byte` |*only for AlertNotification and DataSm* Defines the numeric plan
indicator (NPI) to be used in the SME originator address parameters. Use
the URI option `sourceAddrNpi` values defined above.

|`CamelSmppSourceAddrTon` |`Byte` |*only for AlertNotification and DataSm* Defines the type of number (TON)
to be used in the SME originator address parameters. Use the
`sourceAddrTon` URI option values defined above.

|`CamelSmppEsmeAddr` |`String` |*only for AlertNotification* Defines the destination ESME address. For
mobile terminated messages, this is the directory number of the
recipient MS.

|`CamelSmppEsmeAddrNpi` |`Byte` |*only for AlertNotification* Defines the numeric plan indicator (NPI) to
be used in the ESME originator address parameters. Use the URI option
`sourceAddrNpi` values defined above.

|`CamelSmppEsmeAddrTon` |`Byte` |*only for AlertNotification* Defines the type of number (TON) to be used
in the ESME originator address parameters. Use the `sourceAddrTon` URI
option values defined above.

|`CamelSmppId` |`String` |*only for smsc DeliveryReceipt and DataSm* The message ID allocated to
the message by the SMSC when originally submitted.

|`CamelSmppDelivered` |`Integer` |*only for smsc DeliveryReceipt* Number of short messages delivered. This
is only relevant where the original message was submitted to a
distribution list.The value is padded with leading zeros if necessary.

|`CamelSmppDoneDate` |`Date` |*only for smsc DeliveryReceipt* The time and date at which the short
message reached it's final state. The format is as follows: YYMMDDhhmm.

|`CamelSmppStatus` |`DeliveryReceiptState` |*only for smsc DeliveryReceipt:* The final status of the message. The
following values are defined: `DELIVRD`: Message is delivered to destination,
`EXPIRED`: Message validity period has expired,
`DELETED`: Message has been deleted, 
`UNDELIV`: Message is undeliverable, 
`ACCEPTD`: Message is in accepted state (i.e. has been manually read on
behalf of the subscriber by customer service),
`UNKNOWN`: Message is in invalid state,
`REJECTD`: Message is in a rejected state

|`CamelSmppCommandStatus` |`Integer` |*only for DataSm* The Command status of the message.

|`CamelSmppError` |`String` |*only for smsc DeliveryReceipt* Where appropriate this may hold a
Network specific error code or an SMSC error code for the attempted
delivery of the message. These errors are Network or SMSC specific and
are not included here.

|`CamelSmppSubmitDate` |`Date` |*only for smsc DeliveryReceipt* The time and date at which the short
message was submitted. In the case of a message which has been replaced,
this is the date that the original message was replaced. The format is
as follows: YYMMDDhhmm.

|`CamelSmppSubmitted` |`Integer` |*only for smsc DeliveryReceipt* Number of short messages originally
submitted. This is only relevant when the original message was submitted
to a distribution list.The value is padded with leading zeros if
necessary.

|`CamelSmppDestAddr` |`String` |*only for DeliverSm and DataSm:* Defines the destination SME address.
For mobile terminated messages, this is the directory number of the
recipient MS.

|`CamelSmppScheduleDeliveryTime` |`String` |*only for DeliverSm:* This parameter specifies the scheduled time at
which the message delivery should be first attempted. It defines either
the absolute date and time or relative time from the current SMSC time
at which delivery of this message will be attempted by the SMSC. It can
be specified in either absolute time format or relative time format. The
encoding of a time format is specified in Section 7.1.1. in the smpp
specification v3.4.

|`CamelSmppValidityPeriod` |`String` |*only for DeliverSm* The validity period parameter indicates the SMSC
expiration time, after which the message should be discarded if not
delivered to the destination. It can be defined in absolute time format
or relative time format. The encoding of absolute and relative time
format is specified in Section 7.1.1 in the smpp specification v3.4.

|`CamelSmppServiceType` |`String` |*only for DeliverSm and DataSm* The service type parameter indicates the
SMS Application service associated with the message.

|`CamelSmppRegisteredDelivery` |`Byte` |*only for DataSm* Is used to request an delivery receipt and/or SME
originated acknowledgements. Same values as in Producer header list
above.

|`CamelSmppDestAddrNpi` |`Byte` |*only for DataSm* Defines the numeric plan indicator (NPI) in the
destination address parameters. Use the URI option `sourceAddrNpi`
values defined above.

|`CamelSmppDestAddrTon` |`Byte` |*only for DataSm* Defines the type of number (TON) in the destination
address parameters. Use the `sourceAddrTon` URI option values defined
above.

|`CamelSmppMessageType` |`String` |Identifies the type of an incoming message:
`AlertNotification`: an SMSC alert notification,
`DataSm`: an SMSC data short message,
`DeliveryReceipt`: an SMSC delivery receipt,
`DeliverSm`: an SMSC deliver short message

|`CamelSmppOptionalParameter` |`Map<Short, Object>` |*only for DeliverSm* The optional
parameters send back by the SMSC. The key is the `Short` code for the
optional parameter. The value is converted in the following way: 
`org.jsmpp.bean.OptionalParameter.COctetString` -> `String`,
`org.jsmpp.bean.OptionalParameter.OctetString` -> `byte[]`,
`org.jsmpp.bean.OptionalParameter.Byte` -> `Byte`,
`org.jsmpp.bean.OptionalParameter.Int` -> `Integer`,
`org.jsmpp.bean.OptionalParameter.Short` -> `Short`,
`org.jsmpp.bean.OptionalParameter.Null` -> `null`
|=======================================================================

[TIP]
====
*JSMPP library*

See the documentation of the http://jsmpp.org[JSMPP Library] for more
details about the underlying library.
====

== Exception handling

This component supports the general Camel exception handling
capabilities

When an error occurs sending a message with SubmitSm (the default
action), the org.apache.camel.component.smpp.SmppException is thrown
with a nested exception, org.jsmpp.extra.NegativeResponseException. 
Call NegativeResponseException.getCommandStatus() to obtain the exact
SMPP negative response code, the values are explained in the SMPP
specification 3.4, section 5.1.3. +
When the SMPP consumer receives a `DeliverSm` or
`DataSm` short message and the processing of these messages fails, you
can also throw a `ProcessRequestException` instead of handle the
failure. In this case, this exception is forwarded to the underlying
http://jsmpp.org[JSMPP library] which will return the included error
code to the SMSC. This feature is useful to e.g. instruct the SMSC to
resend the short message at a later time. This could be done with the
following lines of code:

[source,java]
--------------------------------------------------------------------------------------------------------------------------
from(""smpp://smppclient@localhost:2775?password=password&enquireLinkTimer=3000&transactionTimer=5000&systemType=consumer"")
  .doTry()
    .to(""bean:dao?method=updateSmsState"")
  .doCatch(Exception.class)
    .throwException(new ProcessRequestException(""update of sms state failed"", 100))
  .end();
--------------------------------------------------------------------------------------------------------------------------

Please refer to the http://smsforum.net/SMPP_v3_4_Issue1_2.zip[SMPP
specification] for the complete list of error codes and their meanings.

== Samples

A route which sends an SMS using the Java DSL:

[source,java]
------------------------------------------------------------------------------------------
from(""direct:start"")
  .to(""smpp://smppclient@localhost:2775?
      password=password&enquireLinkTimer=3000&transactionTimer=5000&systemType=producer"");
------------------------------------------------------------------------------------------

A route which sends an SMS using the Spring XML DSL:

[source,xml]
-----------------------------------------------------------------------------------------------------------
<route>
  <from uri=""direct:start""/>
  <to uri=""smpp://smppclient@localhost:2775?
           password=password&amp;enquireLinkTimer=3000&amp;transactionTimer=5000&amp;systemType=producer""/>
</route>
-----------------------------------------------------------------------------------------------------------

A route which receives an SMS using the Java DSL:

[source,java]
--------------------------------------------------------------------------------------------------------------------------
from(""smpp://smppclient@localhost:2775?password=password&enquireLinkTimer=3000&transactionTimer=5000&systemType=consumer"")
  .to(""bean:foo"");
--------------------------------------------------------------------------------------------------------------------------

A route which receives an SMS using the Spring XML DSL:

[source,xml]
----------------------------------------------------------------------------------------------------------------
  <route>
     <from uri=""smpp://smppclient@localhost:2775?
                password=password&amp;enquireLinkTimer=3000&amp;transactionTimer=5000&amp;systemType=consumer""/>
     <to uri=""bean:foo""/>
  </route>
----------------------------------------------------------------------------------------------------------------

[TIP]
====
*SMSC simulator*

If you need an SMSC simulator for your test, you can use the simulator
provided by
http://opensmpp.logica.com/CommonPart/Download/download2.html#simulator[Logica].
====

== Debug logging

This component has log level *DEBUG*, which can be helpful in debugging
problems. If you use log4j, you can add the following line to your
configuration:

[source,java]
--------------------------------------------------
log4j.logger.org.apache.camel.component.smpp=DEBUG
--------------------------------------------------

",12146,False,2371.691101829221,median
"#include ""Platform.h""
#include ""kext_inject.h""
#include ""DataHubCpu.h""

#ifndef DEBUG_ALL
#define KEXT_INJECT_DEBUG 0
#else
#define KEXT_INJECT_DEBUG DEBUG_ALL
#endif


#if KEXT_INJECT_DEBUG == 2
#define DBG(...) MsgLog(__VA_ARGS__)
#elif KEXT_INJECT_DEBUG == 1
#define DBG(...)  printf(__VA_ARGS__);
#else
#define DBG(...)
#endif

// runtime debug
//
#define OLD_EXTRA_KEXT_PATCH 0

////////////////////
// globals
////////////////////
LIST_ENTRY gKextList = INITIALIZE_LIST_HEAD_VARIABLE (gKextList);


////////////////////
// before booting
////////////////////
EFI_STATUS EFIAPI ThinFatFile(IN OUT UINT8 **binary, IN OUT UINTN *length, IN cpu_type_t archCpuType)
{
  UINT32 nfat, swapped, size = 0;
  FAT_HEADER *fhp = (FAT_HEADER *)*binary;
  FAT_ARCH   *fap = (FAT_ARCH *)(*binary + sizeof(FAT_HEADER));
  cpu_type_t fapcputype;
  UINT32 fapoffset;
  UINT32 fapsize;

  swapped = 0;
  if (fhp->magic == FAT_MAGIC) {
    nfat = fhp->nfat_arch;
  } else if (fhp->magic == FAT_CIGAM) {
    nfat = SwapBytes32(fhp->nfat_arch);
    swapped = 1;
    //already thin
  } else if (fhp->magic == THIN_X64){
    if (archCpuType == CPU_TYPE_X86_64) {
      return EFI_SUCCESS;
    }
    return EFI_NOT_FOUND;
  } else if (fhp->magic == THIN_IA32){
    if (archCpuType == CPU_TYPE_I386) {
      return EFI_SUCCESS;
    }
    return EFI_NOT_FOUND;
  } else {
    MsgLog(""Thinning fails\\n"");
    return EFI_NOT_FOUND;
  }

  for (; nfat > 0; nfat--, fap++) {
    if (swapped) {
      fapcputype = SwapBytes32(fap->cputype);
      fapoffset = SwapBytes32(fap->offset);
      fapsize = SwapBytes32(fap->size);
    } else {
      fapcputype = fap->cputype;
      fapoffset = fap->offset;
      fapsize = fap->size;
    }
    if (fapcputype == archCpuType) {
      *binary = (*binary + fapoffset);
      size = fapsize;
      break;
    }
  }
  if (length != 0) *length = size;

  return EFI_SUCCESS;
}

void toLowerStr(CHAR8 *tstr, CHAR8 *str) {
    UINT16 cnt = 0;
    
    for (cnt = 0; *str != '\\0' && cnt <= 0xFF; cnt++, str++, tstr++) {
        if (*str >= 'A' && *str <= 'Z')
            *tstr = 'a' + (*str - 'A');
        else
            *tstr = *str;
    }
    *tstr = '\\0';
}

BOOLEAN checkOSBundleRequired(UINT8 loaderType, TagPtr dict)
{
    BOOLEAN inject = TRUE;
    TagPtr  osBundleRequired;
    CHAR8   osbundlerequired[256];
    
    osBundleRequired = GetProperty(dict,""OSBundleRequired"");
    if (osBundleRequired)
        toLowerStr(osbundlerequired, osBundleRequired->string);
    else
        osbundlerequired[0] = '\\0';

    if (OSTYPE_IS_OSX_RECOVERY(loaderType) ||
        OSTYPE_IS_OSX_INSTALLER(loaderType)) {
        if (strncmp(osbundlerequired, ""root"", 4) &&
            strncmp(osbundlerequired, ""local"", 5) &&
            strncmp(osbundlerequired, ""console"", 7) &&
            strncmp(osbundlerequired, ""network-root"", 12)) {
            inject = FALSE;
        }
    }
    
    return inject;
}

//extern VOID KernelAndKextPatcherInit(IN LOADER_ENTRY *Entry);
//extern VOID AnyKextPatch(UINT8 *Driver, UINT32 DriverSize, CHAR8 *InfoPlist, UINT32 InfoPlistSize, INT32 N, LOADER_ENTRY *Entry);

EFI_STATUS LOADER_ENTRY::LoadKext(IN EFI_FILE *RootDir, IN CHAR16 *FileName, IN cpu_type_t archCpuType, IN OUT VOID *kext_v)
{
  EFI_STATUS  Status;
  UINT8*      infoDictBuffer = NULL;
  UINTN       infoDictBufferLength = 0;
  UINT8*      executableFatBuffer = NULL;
  UINT8*      executableBuffer = NULL;
  UINTN       executableBufferLength = 0;
  CHAR8*      bundlePathBuffer = NULL;
  UINTN       bundlePathBufferLength = 0;
  CHAR16      *TempName;
  CHAR16      *Executable;
  TagPtr      dict = NULL;
  TagPtr      prop = NULL;
  BOOLEAN     NoContents = FALSE;
  BOOLEAN     inject = FALSE;
  _BooterKextFileInfo *infoAddr = NULL;
  _DeviceTreeBuffer *kext = (_DeviceTreeBuffer *)kext_v;

  TempName = PoolPrint(L""%s\\\\%s"", FileName, L""Contents\\\\Info.plist"");
  // snwprintf(TempName, 512, L""%s\\\\%s"", FileName, ""Contents\\\\Info.plist"");
  Status = egLoadFile(RootDir, TempName, &infoDictBuffer, &infoDictBufferLength);
  FreePool(TempName);
  if (EFI_ERROR(Status)) {
    //try to find a planar kext, without Contents
    TempName = PoolPrint(L""%s\\\\%s"", FileName, L""Info.plist"");
    //  snwprintf(TempName, 512, L""%s\\\\%s"", FileName, ""Info.plist"");
    Status = egLoadFile(RootDir, TempName, &infoDictBuffer, &infoDictBufferLength);
    FreePool(TempName);
    if (EFI_ERROR(Status)) {
      MsgLog(""Failed to load extra kext (Info.plist not found): %ls\\n"", FileName);
      return EFI_NOT_FOUND;
    }
    NoContents = TRUE;
  }
  if(ParseXML((CHAR8*)infoDictBuffer,&dict,(UINT32)infoDictBufferLength)!=0) {
    FreePool(infoDictBuffer);
    MsgLog(""Failed to load extra kext (failed to parse Info.plist): %ls\\n"", FileName);
    return EFI_NOT_FOUND;
  }
    
  inject = checkOSBundleRequired(LoaderType, dict);
  if(!inject) {
      MsgLog(""Skipping kext injection by OSBundleRequired : %ls\\n"", FileName);
      return EFI_UNSUPPORTED;
  }
    
  prop = GetProperty(dict,""CFBundleExecutable"");
  if(prop!=0) {
    Executable = PoolPrint(L""%a"", prop->string);
    //   AsciiStrToUnicodeStrS(prop->string, Executable, 256);
    if (NoContents) {
      TempName = PoolPrint(L""%s\\\\%s"", FileName, Executable);
      //     snwprintf(TempName, 512, ""%s\\\\%s"", FileName, Executable);
    } else {
      TempName = PoolPrint(L""%s\\\\%s\\\\%s"", FileName, L""Contents\\\\MacOS"",Executable);
      //    snwprintf(TempName, 512, L""%s\\\\%s\\\\%s"", FileName, ""Contents\\\\MacOS"",Executable);
    }
    FreePool(Executable);
    Status = egLoadFile(RootDir, TempName, &executableFatBuffer, &executableBufferLength);
    FreePool(TempName);
    if (EFI_ERROR(Status)) {
      FreePool(infoDictBuffer);
      MsgLog(""Failed to load extra kext (executable not found): %ls\\n"", FileName);
      return EFI_NOT_FOUND;
    }
    executableBuffer = executableFatBuffer;
    if (ThinFatFile(&executableBuffer, &executableBufferLength, archCpuType)) {
      FreePool(infoDictBuffer);
      FreePool(executableBuffer);
      MsgLog(""Thinning failed: %ls\\n"", FileName);
      return EFI_NOT_FOUND;
    }
  }
  bundlePathBufferLength = StrLen(FileName) + 1;
  bundlePathBuffer = (__typeof__(bundlePathBuffer))AllocateZeroPool(bundlePathBufferLength);
  UnicodeStrToAsciiStrS(FileName, bundlePathBuffer, bundlePathBufferLength);

  kext->length = (UINT32)(sizeof(_BooterKextFileInfo) + infoDictBufferLength + executableBufferLength + bundlePathBufferLength);
  infoAddr = (_BooterKextFileInfo *)AllocatePool(kext->length);
  infoAddr->infoDictPhysAddr = sizeof(_BooterKextFileInfo);
  infoAddr->infoDictLength = (UINT32)infoDictBufferLength;
  infoAddr->executablePhysAddr = (UINT32)(sizeof(_BooterKextFileInfo) + infoDictBufferLength);
  infoAddr->executableLength = (UINT32)executableBufferLength;
  infoAddr->bundlePathPhysAddr = (UINT32)(sizeof(_BooterKextFileInfo) + infoDictBufferLength + executableBufferLength);
  infoAddr->bundlePathLength = (UINT32)bundlePathBufferLength;
  kext->paddr = (UINT32)(UINTN)infoAddr; // Note that we cannot free infoAddr because of this
  CopyMem((CHAR8 *)infoAddr + sizeof(_BooterKextFileInfo), infoDictBuffer, infoDictBufferLength);
  CopyMem((CHAR8 *)infoAddr + sizeof(_BooterKextFileInfo) + infoDictBufferLength, executableBuffer, executableBufferLength);
  CopyMem((CHAR8 *)infoAddr + sizeof(_BooterKextFileInfo) + infoDictBufferLength + executableBufferLength, bundlePathBuffer, bundlePathBufferLength);
  FreePool(infoDictBuffer);
  FreePool(executableFatBuffer);
  FreePool(bundlePathBuffer);

  return EFI_SUCCESS;
}

EFI_STATUS LOADER_ENTRY::AddKext(IN EFI_FILE *RootDir, IN CHAR16 *FileName, IN cpu_type_t archCpuType)
{
  EFI_STATUS  Status;
  KEXT_ENTRY  *KextEntry;

  KextEntry = (__typeof__(KextEntry))AllocatePool (sizeof(KEXT_ENTRY));
  KextEntry->Signature = KEXT_SIGNATURE;
  Status = LoadKext(RootDir, FileName, archCpuType, &KextEntry->kext);
  if(EFI_ERROR(Status)) {
    FreePool(KextEntry);
  } else {
    InsertTailList (&gKextList, &KextEntry->Link);
  }

  return Status;
}

UINT32 GetListCount(LIST_ENTRY const* List)
{
  LIST_ENTRY    *Link;
  UINT32      Count=0;

  if(!IsListEmpty(List)) {
    for (Link = List->ForwardLink; Link != List; Link = Link->ForwardLink)
      Count++;
  }

  return Count;
}

UINT32 GetKextCount()
{
  return (UINT32)GetListCount(&gKextList);
}

UINT32 GetKextsSize()
{
  LIST_ENTRY    *Link;
  KEXT_ENTRY    *KextEntry;
  UINT32        kextsSize=0;

  if(!IsListEmpty(&gKextList)) {
    for (Link = gKextList.ForwardLink; Link != &gKextList; Link = Link->ForwardLink) {
      KextEntry = CR(Link, KEXT_ENTRY, Link, KEXT_SIGNATURE);
      kextsSize += RoundPage(KextEntry->kext.length);
    }
  }
  return kextsSize;
}

VOID LOADER_ENTRY::LoadPlugInKexts(IN EFI_FILE *RootDir, IN CHAR16 *DirName, IN cpu_type_t archCpuType, IN BOOLEAN Force)
{
   REFIT_DIR_ITER          PlugInIter;
   EFI_FILE_INFO           *PlugInFile;
   CHAR16                  *FileName;
   if ((RootDir == NULL) || (DirName == NULL)) {
      return;
   }
   DirIterOpen(RootDir, DirName, &PlugInIter);
   while (DirIterNext(&PlugInIter, 1, L""*.kext"", &PlugInFile)) {
     if (PlugInFile->FileName[0] == '.' || StrStr(PlugInFile->FileName, L"".kext"") == NULL)
       continue;   // skip this
     FileName = PoolPrint(L""%s\\\\%s"", DirName, PlugInFile->FileName);
     //     snwprintf(FileName, 512, ""%s\\\\%s"", DirName, PlugInFile->FileName);
     MsgLog(""    %ls PlugIn kext: %ls\\n"", Force ? L""Force"" : L""Extra"", FileName);
     AddKext( RootDir, FileName, archCpuType);
     FreePool(FileName);
   }
   DirIterClose(&PlugInIter);
}

VOID LOADER_ENTRY::AddKexts(CONST CHAR16 *SrcDir, CONST CHAR16 *Path, cpu_type_t archCpuType)
{
  CHAR16                  *FileName;
  CHAR16                  *PlugInName;
  SIDELOAD_KEXT           *CurrentKext;
  SIDELOAD_KEXT           *CurrentPlugInKext;
  EFI_STATUS              Status;

  MsgLog(""Preparing kexts injection for arch=%ls from %ls\\n"", (archCpuType==CPU_TYPE_X86_64)?L""x86_64"":(archCpuType==CPU_TYPE_I386)?L""i386"":L"""", SrcDir);
  CurrentKext = InjectKextList;
  while (CurrentKext) {
    DBG(""  current kext name=%ls path=%ls, match against=%ls\\n"", CurrentKext->FileName, CurrentKext->KextDirNameUnderOEMPath, Path);
    if (StrCmp(CurrentKext->KextDirNameUnderOEMPath, Path) == 0) {
      FileName = PoolPrint(L""%s\\\\%s"", SrcDir, CurrentKext->FileName);
      //   snwprintf(FileName, 512, ""%s\\\\%s"", SrcDir, CurrentKext->FileName);
      if (!(CurrentKext->MenuItem.BValue)) {
        // inject require
        MsgLog(""->Extra kext: %ls (v.%ls)\\n"", FileName, CurrentKext->Version);
        Status = AddKext(SelfVolume->RootDir, FileName, archCpuType);
        if(!EFI_ERROR(Status)) {
          // decide which plugins to inject
          CurrentPlugInKext = CurrentKext->PlugInList;
          while (CurrentPlugInKext) {
            PlugInName = PoolPrint(L""%s\\\\%s\\\\%s"", FileName, L""Contents\\\\PlugIns"", CurrentPlugInKext->FileName);
            //     snwprintf(PlugInName, 512, L""%s\\\\%s\\\\%s"", FileName, ""Contents\\\\PlugIns"", CurrentPlugInKext->FileName);
            if (!(CurrentPlugInKext->MenuItem.BValue)) {
              // inject PlugIn require
              MsgLog(""    |-- PlugIn kext: %ls (v.%ls)\\n"", PlugInName, CurrentPlugInKext->Version);
              AddKext(SelfVolume->RootDir, PlugInName, archCpuType);
            } else {
              MsgLog(""    |-- Disabled plug-in kext: %ls (v.%ls)\\n"", PlugInName, CurrentPlugInKext->Version);
            }
            FreePool(PlugInName);
            CurrentPlugInKext = CurrentPlugInKext->Next;
          } // end of plug-in kext injection
        }
      } else {
        // disable current kext injection
        if (!StriStr(SrcDir, L""Off"")) {
          MsgLog(""Disabled kext: %ls (v.%ls)\\n"", FileName, CurrentKext->Version);
        }
      }
      FreePool(FileName);
    }
    CurrentKext = CurrentKext->Next;
  } // end of kext injection

}

EFI_STATUS LOADER_ENTRY::LoadKexts()
{
  CHAR16                  *SrcDir = NULL;
  REFIT_DIR_ITER          PlugInIter;
  EFI_FILE_INFO           *PlugInFile;
  CHAR16                  *FileName;
  CHAR16                  *PlugIns;
//  CONST CHAR16                  *Arch = NULL;
//  CONST CHAR16                  *Ptr = NULL;
#if defined(MDE_CPU_X64)
  cpu_type_t              archCpuType=CPU_TYPE_X86_64;
#else
  cpu_type_t              archCpuType=CPU_TYPE_I386;
#endif
  UINTN                    mm_extra_size;
  VOID                    *mm_extra;
  UINTN                    extra_size;
  VOID                    *extra;

  SIDELOAD_KEXT           *CurrentKext = NULL;
  SIDELOAD_KEXT           *CurrentPlugInKext = NULL;
  SIDELOAD_KEXT           *Next = NULL;

  // Make Arch point to the last appearance of ""arch="" in LoadOptions (which is what boot.efi will use).
//  if (LoadOptions.notEmpty()) {
//    for (Ptr = StrStr(LoadOptions, L""arch=""); Ptr != NULL; Arch = Ptr + StrLen(L""arch=""), Ptr = StrStr(Arch, L""arch=""));
//  }

//  if (Arch != NULL && StrnCmp(Arch,L""x86_64"",StrLen(L""x86_64"")) == 0) {
    if (LoadOptions.contains(""arch=x86_64"")) {
    archCpuType = CPU_TYPE_X86_64;
//  } else if (Arch != NULL && StrnCmp(Arch,L""i386"",StrLen(L""i386"")) == 0) {
    } else if (LoadOptions.contains(""arch=i386"")) {
    archCpuType = CPU_TYPE_I386;
  } else if (OSVersion != NULL) {
    UINT64 os_version = AsciiOSVersionToUint64(OSVersion);
    if (os_version >= AsciiOSVersionToUint64(""10.8"")) {
      archCpuType = CPU_TYPE_X86_64; // For OSVersion >= 10.8, only x86_64 exists
    } else if (os_version < AsciiOSVersionToUint64(""10.7"")) {
      archCpuType = CPU_TYPE_I386; // For OSVersion < 10.7, use default of i386
    }
  }

  // Force kexts to load
  if ((KernelAndKextPatches != NULL) &&
      (KernelAndKextPatches->NrForceKexts > 0) &&
      (KernelAndKextPatches->ForceKexts != NULL)) {
    INT32 i = 0;
    for (; i < KernelAndKextPatches->NrForceKexts; ++i) {
      MsgLog(""  Force kext: %ls\\n"", KernelAndKextPatches->ForceKexts[i]);
      if (Volume && Volume->RootDir) {
        // Check if the entry is a directory
        if (StrStr(KernelAndKextPatches->ForceKexts[i], L"".kext"") == NULL) {
          DirIterOpen(Volume->RootDir, KernelAndKextPatches->ForceKexts[i], &PlugInIter);
          while (DirIterNext(&PlugInIter, 1, L""*.kext"", &PlugInFile)) {
            if (PlugInFile->FileName[0] == '.' || StrStr(PlugInFile->FileName, L"".kext"") == NULL)
              continue;   // skip this
            FileName = PoolPrint(L""%s\\\\%s"", KernelAndKextPatches->ForceKexts[i], PlugInFile->FileName);
            //    snwprintf(FileName, 512, ""%s\\\\%s"", KernelAndKextPatches->ForceKexts[i], PlugInFile->FileName);
            MsgLog(""  Force kext: %ls\\n"", FileName);
            AddKext( Volume->RootDir, FileName, archCpuType);
            PlugIns = PoolPrint(L""%s\\\\Contents\\\\PlugIns"", FileName);
            //  snwprintf(PlugIns, 512, ""%s\\\\Contents\\\\PlugIns"", FileName);
            LoadPlugInKexts(Volume->RootDir, PlugIns, archCpuType, TRUE);
            FreePool(FileName);
            FreePool(PlugIns);
          }
          DirIterClose(&PlugInIter);
        } else {
          AddKext( Volume->RootDir, KernelAndKextPatches->ForceKexts[i], archCpuType);
          PlugIns = PoolPrint(L""%s\\\\Contents\\\\PlugIns"", KernelAndKextPatches->ForceKexts[i]);
          //  snwprintf(PlugIns, 512, ""%s\\\\Contents\\\\PlugIns"", KernelAndKextPatches->ForceKexts[i]);
          LoadPlugInKexts(Volume->RootDir, PlugIns, archCpuType, TRUE);
          FreePool(PlugIns);
        }
      }
    }
  }

  CHAR16 UniOSVersion[16];
  AsciiStrToUnicodeStrS(OSVersion, UniOSVersion, 16);
  DBG(""UniOSVersion == %ls\\n"", UniOSVersion);

  CHAR16 UniShortOSVersion[6];
  CHAR8  ShortOSVersion[6];
  if (AsciiOSVersionToUint64(OSVersion) < AsciiOSVersionToUint64(""10.10"")) {
    // OSVersion that are earlier than 10.10(form: 10.x.y)
    AsciiStrnCpyS(ShortOSVersion, 6, OSVersion, 4);
    AsciiStrToUnicodeStrS(OSVersion, UniShortOSVersion, 5);
  } else {
    AsciiStrnCpyS(ShortOSVersion, 6, OSVersion, 5);
    AsciiStrToUnicodeStrS(OSVersion, UniShortOSVersion, 6);
  }
  DBG(""ShortOSVersion == %s\\n"", ShortOSVersion);
  DBG(""UniShortOSVersion == %ls\\n"", UniShortOSVersion);

  // syscl - allow specific load inject kext
  // Clover/Kexts/Other is for general injection thus we need to scan both Other and OSVersion folder
  if ((SrcDir = GetOtherKextsDir(TRUE)) != NULL) {
    AddKexts(SrcDir, L""Other"", archCpuType);
    FreePool(SrcDir);
  } else {
    DBG(""GetOtherKextsDir(TRUE) return NULL\\n"");
  }
    // slice: CLOVER/kexts/Off keep disabled kext which can be allowed
  if ((SrcDir = GetOtherKextsDir(FALSE)) != NULL) {
    AddKexts(SrcDir, L""Off"", archCpuType);
    FreePool(SrcDir);
  } else {
    DBG(""GetOtherKextsDir(FALSE) return NULL\\n"");
  }

  // Add kext from 10
  {
    CHAR16 *OSAllVersionKextsDir;
    CHAR16 *OSShortVersionKextsDir;
    CHAR16 *OSVersionKextsDirName;
    CHAR16 *DirName;
    CHAR16 *DirPath;
    OSAllVersionKextsDir = PoolPrint(L""%s\\\\kexts\\\\10"", OEMPath);
    // snwprintf(OSAllVersionKextsDir, sizeof(OSAllVersionKextsDir), ""%s\\\\kexts\\\\10"", OEMPath);
    AddKexts(OSAllVersionKextsDir, L""10"", archCpuType);
    FreePool(OSAllVersionKextsDir);

    if (OSTYPE_IS_OSX_INSTALLER(LoaderType)) {
      DirName = PoolPrint(L""10_install"");
      // snwprintf(DirName, sizeof(DirName), ""10_install"");
    } else if (OSTYPE_IS_OSX_RECOVERY(LoaderType)) {
      DirName = PoolPrint(L""10_recovery"");
      // snwprintf(DirName, sizeof(DirName), ""10_recovery"");
    } else {
      DirName = PoolPrint(L""10_normal"");
      // snwprintf(DirName, sizeof(DirName), ""10_normal"");
    }
    DirPath = PoolPrint(L""%s\\\\kexts\\\\%s"", OEMPath, DirName);
    // snwprintf(DirPath, sizeof(DirPath), ""%s\\\\kexts\\\\%s"", OEMPath, DirName);
    AddKexts( DirPath, DirName, archCpuType);
    FreePool(DirPath);
    FreePool(DirName);


    // Add kext from 10.{version}

    OSShortVersionKextsDir = PoolPrint(L""%s\\\\kexts\\\\%s"", OEMPath, UniShortOSVersion);
    // snwprintf(OSShortVersionKextsDir, sizeof(OSShortVersionKextsDir), ""%s\\\\kexts\\\\%s"", OEMPath, UniShortOSVersion);
    AddKexts( OSShortVersionKextsDir, UniShortOSVersion, archCpuType);
    FreePool(OSShortVersionKextsDir);

    if (OSTYPE_IS_OSX_INSTALLER(LoaderType)) {
      DirName = PoolPrint(L""%s_install"", UniShortOSVersion);
      // snwprintf(DirName, sizeof(DirName), ""%s_install"", UniShortOSVersion);
    } else if (OSTYPE_IS_OSX_RECOVERY(LoaderType)) {
      DirName = PoolPrint(L""%s_recovery"", UniShortOSVersion);
      // snwprintf(DirName, sizeof(DirName), ""%s_recovery"", UniShortOSVersion);
    } else {
      DirName = PoolPrint(L""%s_normal"", UniShortOSVersion);
      // snwprintf(DirName, sizeof(DirName), ""%s_normal"", UniShortOSVersion);
    }
    DirPath = PoolPrint(L""%s\\\\kexts\\\\%s"", OEMPath, DirName);
    // snwprintf(DirPath, sizeof(DirPath), ""%s\\\\kexts\\\\%s"", OEMPath, DirName);
    AddKexts( DirPath, DirName, archCpuType);
    FreePool(DirPath);
    FreePool(DirName);


    // Add kext from :
    // 10.{version}.0 if NO minor version
    // 10.{version}.{minor version} if minor version is > 0

    if ( AsciiStrCmp(ShortOSVersion, OSVersion) == 0 ) {
      OSVersionKextsDirName = PoolPrint(L""%a.0"", OSVersion);
      // snwprintf(OSVersionKextsDirName, sizeof(OSVersionKextsDirName), ""%a.0"", OSVersion);
    } else {
      OSVersionKextsDirName = PoolPrint(L""%a"", OSVersion);
      // snwprintf(OSVersionKextsDirName, sizeof(OSVersionKextsDirName), ""%a"", OSVersion);
    }

    DirPath = PoolPrint(L""%s\\\\kexts\\\\%s"", OEMPath, OSVersionKextsDirName);
    // snwprintf(DirPath, sizeof(DirPath), ""%s\\\\kexts\\\\%s"", OEMPath, OSVersionKextsDirName);
    AddKexts( DirPath, OSVersionKextsDirName, archCpuType);
    FreePool(DirPath);

    if ( OSTYPE_IS_OSX_INSTALLER(LoaderType)) {
      DirName = PoolPrint(L""%s_install"", OSVersionKextsDirName);
      // snwprintf(DirName, sizeof(DirName), ""%s_install"", OSVersionKextsDirName);
    } else if (OSTYPE_IS_OSX_RECOVERY(LoaderType)) {
      DirName = PoolPrint(L""%s_recovery"", OSVersionKextsDirName);
      // snwprintf(DirName, sizeof(DirName), ""%s_recovery"", OSVersionKextsDirName);
    } else {
      DirName = PoolPrint(L""%s_normal"", OSVersionKextsDirName);
      // snwprintf(DirName, sizeof(DirName), ""%s_normal"", OSVersionKextsDirName);
    }
    DirPath = PoolPrint(L""%s\\\\kexts\\\\%s"", OEMPath, DirName);
    // snwprintf(DirPath, sizeof(DirPath), ""%s\\\\kexts\\\\%s"", OEMPath, DirName);
    AddKexts( DirPath, DirName, archCpuType);
    FreePool(DirPath);
    FreePool(DirName);
    FreePool(OSVersionKextsDirName);
  }


  // reserve space in the device tree
  if (GetKextCount() > 0) {
    mm_extra_size = GetKextCount() * (sizeof(DeviceTreeNodeProperty) + sizeof(_DeviceTreeBuffer));
    mm_extra = (__typeof__(mm_extra))AllocateZeroPool(mm_extra_size - sizeof(DeviceTreeNodeProperty));
    /*Status =  */LogDataHub(&gEfiMiscSubClassGuid, L""mm_extra"", mm_extra, (UINT32)(mm_extra_size - sizeof(DeviceTreeNodeProperty)));
    extra_size = GetKextsSize();
    extra = (__typeof__(extra))AllocateZeroPool(extra_size - sizeof(DeviceTreeNodeProperty) + EFI_PAGE_SIZE);
    /*Status =  */LogDataHub(&gEfiMiscSubClassGuid, L""extra"", extra, (UINT32)(extra_size - sizeof(DeviceTreeNodeProperty) + EFI_PAGE_SIZE));
    // MsgLog(""count: %d    \\n"", GetKextCount());
    // MsgLog(""mm_extra_size: %d    \\n"", mm_extra_size);
    // MsgLog(""extra_size: %d     \\n"", extra_size);
    // MsgLog(""offset: %d       \\n"", extra_size - sizeof(DeviceTreeNodeProperty) + EFI_PAGE_SIZE);
    //no more needed
    FreePool(mm_extra);
    FreePool(extra);
  }

  //No more InjectKextList needed. Will free the list
  while (InjectKextList) {
    CurrentKext = InjectKextList->Next;
    CurrentPlugInKext = InjectKextList->PlugInList;
    while (CurrentPlugInKext) {
      Next = CurrentPlugInKext->Next;
      FreePool(CurrentPlugInKext->FileName);
      FreePool(CurrentPlugInKext->KextDirNameUnderOEMPath);
      FreePool(CurrentPlugInKext->Version);
      FreePool(CurrentPlugInKext);
      CurrentPlugInKext = Next;
    }
    FreePool(InjectKextList->FileName);
    FreePool(InjectKextList->KextDirNameUnderOEMPath);
    FreePool(InjectKextList->Version);
    FreePool(InjectKextList);
    InjectKextList = CurrentKext;
  }
  return EFI_SUCCESS;
}



/*
 * Adler32 from Chameleon
 */
#define BASE 65521L /* largest prime smaller than 65536 */
#define NMAX 5000
// NMAX (was 5521) the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1

#define DO1(buf,i)  {s1 += buf[i]; s2 += s1;}
#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
#define DO16(buf)   DO8(buf,0); DO8(buf,8);

static UINT32 Adler32(unsigned char *buf, long len)
{
  unsigned long s1 = 1; // adler & 0xffff;
  unsigned long s2 = 0; // (adler >> 16) & 0xffff;
  unsigned long result;
  long k;

  while (len > 0) {
    k = len < NMAX ? len : NMAX;
    len -= k;
    while (k >= 16) {
      DO16(buf);
      buf += 16;
      k -= 16;
    }
    if (k != 0) do {
      s1 += *buf++;
      s2 += s1;
    } while (--k);
    s1 %= BASE;
    s2 %= BASE;
  }
  result = (s2 << 16) | s1;
  // result is in big endian
  return (UINT32)result;
}

typedef struct {
  UINT32  Magic;
  UINT32  Signature;
  UINT32  Length;
  UINT32  Adler32;
  UINT32  Version;
  UINT32  NumKexts;
  UINT32  CpuType;
  UINT32  CpuSubtype;
} MKextHeader;

typedef struct {
  UINT32  PlistOffset;
  UINT32  PlistCompressedSize;
  UINT32  PlistFullSize;
  UINT32  PlistModifiedSeconds;
  UINT32  BinaryOffset;
  UINT32  BinaryCompressedSize;
  UINT32  BinaryFullSize;
  UINT32  BinaryModifiedSeconds;
} MKextFile;

#define MKEXT_MAGIC     0x54584b4d
#define MKEXT_SIGNATURE 0x58534f4d
#define MKEXT_VERSION_1 0x00800001

int LOADER_ENTRY::is_mkext_v1(UINT8* drvPtr)
{
  _DeviceTreeBuffer *dtb = (_DeviceTreeBuffer*) (((UINT8*)drvPtr) + sizeof(DeviceTreeNodeProperty));
  MKextHeader* mkext_ptr = (MKextHeader*)(UINTN)(dtb->paddr);

  if (mkext_ptr->Magic == MKEXT_MAGIC
   && mkext_ptr->Signature == MKEXT_SIGNATURE
   && mkext_ptr->Version == MKEXT_VERSION_1) {
    DBG_RT(""MKext_v1 found at paddr=0x%08x, length=0x%08x\\n"", dtb->paddr, dtb->length);
    return 1;
  }
  return 0;
}

void LOADER_ENTRY::patch_mkext_v1(UINT8 *drvPtr)
{
  _DeviceTreeBuffer *dtb = (_DeviceTreeBuffer*) (((UINT8*)drvPtr) + sizeof(DeviceTreeNodeProperty));
  MKextHeader* mkext_ptr = (MKextHeader*)(UINTN)dtb->paddr;

  UINT32 mkext_len      = SwapBytes32(mkext_ptr->Length);
  UINT32 mkext_numKexts = SwapBytes32(mkext_ptr->NumKexts);

  LIST_ENTRY    *Link;
  KEXT_ENTRY    *KextEntry;
  if(!IsListEmpty(&gKextList)) {
    for (Link = gKextList.ForwardLink; Link != &gKextList; Link = Link->ForwardLink) {
      KextEntry = CR(Link, KEXT_ENTRY, Link, KEXT_SIGNATURE);
      MKextFile *mkext_insert = (MKextFile*)((UINT8*)mkext_ptr + sizeof(MKextHeader) + mkext_numKexts * sizeof(MKextFile));

      // free some space
      CopyMem((UINT8*)mkext_insert + sizeof(MKextFile),
              (UINT8*)mkext_insert,
              mkext_len - (sizeof(MKextHeader) + mkext_numKexts * sizeof(MKextFile)));
      mkext_len += sizeof(MKextFile);

      // update the offsets to reflect 0x20 bytes moved above
      for (UINT32 i = 0; i < mkext_numKexts; i++) {
        MKextFile *kext_base = (MKextFile*)((UINT8*)mkext_ptr + sizeof(MKextHeader) + i * sizeof(MKextFile));
        UINT32 plist_offset  = SwapBytes32(kext_base->PlistOffset)  + sizeof(MKextFile);
        UINT32 binary_offset = SwapBytes32(kext_base->BinaryOffset) + sizeof(MKextFile);
        kext_base->PlistOffset  = SwapBytes32(plist_offset);
        kext_base->BinaryOffset = SwapBytes32(binary_offset);
      }

      // copy kext data (plist+binary)
      CopyMem((UINT8*)mkext_ptr + mkext_len,
              (UINT8*)(KextEntry->kext.paddr + sizeof(_BooterKextFileInfo)),
              (UINT32)((_BooterKextFileInfo*)(UINTN)(KextEntry->kext.paddr))->infoDictLength
               + (UINT32)((_BooterKextFileInfo*)(UINTN)(KextEntry->kext.paddr))->executableLength);

      // insert kext offsets
      mkext_insert->PlistOffset           = SwapBytes32(mkext_len);
      mkext_len += ((_BooterKextFileInfo*)(UINTN)(KextEntry->kext.paddr))->infoDictLength;
      mkext_insert->PlistCompressedSize   = 0;
      mkext_insert->PlistFullSize         = SwapBytes32((UINT32)((_BooterKextFileInfo*)(UINTN)(KextEntry->kext.paddr))->infoDictLength);
      mkext_insert->PlistModifiedSeconds  = 0;
      mkext_insert->BinaryOffset          = SwapBytes32(mkext_len);
      mkext_len += ((_BooterKextFileInfo*)(UINTN)(KextEntry->kext.paddr))->executableLength;
      mkext_insert->BinaryCompressedSize  = 0;
      mkext_insert->BinaryFullSize        = SwapBytes32((UINT32)((_BooterKextFileInfo*)(UINTN)(KextEntry->kext.paddr))->executableLength);
      mkext_insert->BinaryModifiedSeconds = 0;
      mkext_numKexts ++;

      // update the header
      mkext_ptr->Length   = SwapBytes32(mkext_len);
      mkext_ptr->NumKexts = SwapBytes32(mkext_numKexts);

      // update the checksum
      mkext_ptr->Adler32 = SwapBytes32(Adler32((UINT8*)mkext_ptr + 0x10, mkext_len - 0x10));

      // update the memory-map reference
      dtb->length = mkext_len;
    }
  }
}


////////////////////
// OnExitBootServices
////////////////////
EFI_STATUS LOADER_ENTRY::InjectKexts(IN UINT32 deviceTreeP, IN UINT32* deviceTreeLength)
{
  UINT8                             *dtEntry = (UINT8*)(UINTN) deviceTreeP;
  UINTN                             dtLen = (UINTN) *deviceTreeLength;

  DTEntry                           platformEntry;
  DTEntry                           memmapEntry;
  CHAR8                             *ptr;
  OpaqueDTPropertyIterator          OPropIter;
  DTPropertyIterator                iter = &OPropIter;
  DeviceTreeNodeProperty            *prop = NULL;

  UINT8                             *infoPtr = 0;
  UINT8                             *extraPtr = 0;
  UINT8                             *drvPtr = 0;
  UINTN                             offset = 0;

  LIST_ENTRY                        *Link;
  KEXT_ENTRY                        *KextEntry;
  UINTN                             KextBase = 0;
  _DeviceTreeBuffer                 *mm;
  _BooterKextFileInfo               *drvinfo;

  UINT32                            KextCount;
  UINTN                             Index;


  DBG_RT(""\\nInjectKexts: "");
  KextCount = GetKextCount();
  if (KextCount == 0) {
    DBG_RT(""no kexts to inject.\\nPausing 5 secs ...\\n"");
    if (KernelAndKextPatches->KPDebug) {
      gBS->Stall(5000000);
    }
    return EFI_NOT_FOUND;
  }
  DBG_RT(""%d kexts ...\\n"", KextCount);

  // kextsBase = Desc->PhysicalStart + (((UINTN) Desc->NumberOfPages) * EFI_PAGE_SIZE);
  // kextsPages = EFI_SIZE_TO_PAGES(kext.length);
  // Status = gBS->AllocatePages(AllocateAddress, EfiLoaderData, kextsPages, &kextsBase);
  // if (EFI_ERROR(Status)) { MsgLog(""Kext inject: could not allocate memory\\n""); return Status; }
  // Desc->NumberOfPages += kextsPages;
  // CopyMem((VOID*)kextsBase, (VOID*)(UINTN)kext.paddr, kext.length);
  // drvinfo = (_BooterKextFileInfo*) kextsBase;
  // drvinfo->infoDictPhysAddr += (UINT32)kextsBase;
  // drvinfo->executablePhysAddr += (UINT32)kextsBase;
  // drvinfo->bundlePathPhysAddr += (UINT32)kextsBase;

  DTInit(dtEntry, deviceTreeLength);
  if(!EFI_ERROR(DTLookupEntry(NULL,""/chosen/memory-map"", &memmapEntry))) {
    if(!EFI_ERROR(DTCreatePropertyIterator(memmapEntry, iter))) {
      while(!EFI_ERROR(DTIterateProperties(iter, &ptr))) {
        prop = iter->CurrentProperty;
        drvPtr = (UINT8*) prop;
        if(strncmp(prop->Name, ""Driver-"", 7)==0 || strncmp(prop->Name, ""DriversPackage-"", 15)==0) {
          break;
        }
      }
    }
  }

  if(!EFI_ERROR(DTLookupEntry(NULL, ""/efi/platform"", &platformEntry))) {
    if(!EFI_ERROR(DTCreatePropertyIterator(platformEntry, iter))) {
      while(!EFI_ERROR(DTIterateProperties(iter, &ptr))) {
        prop = iter->CurrentProperty;
        if(strncmp(prop->Name, ""mm_extra"", 8)==0) {
          infoPtr = (UINT8*)prop;
        }
        if(strncmp(prop->Name, ""extra"", 5)==0) {
          extraPtr = (UINT8*)prop;
        }
      }
    }
  }

  if (drvPtr == 0 || infoPtr == 0 || extraPtr == 0 || drvPtr > infoPtr || drvPtr > extraPtr || infoPtr > extraPtr) {
    printf(""\\nInvalid device tree for kext injection\\n"");
    gBS->Stall(5000000);
    return EFI_INVALID_PARAMETER;
  }

  // make space for memory map entries
  platformEntry->NumProperties -= 2;
  offset = sizeof(DeviceTreeNodeProperty) + ((DeviceTreeNodeProperty*) infoPtr)->Length;
  CopyMem(drvPtr+offset, drvPtr, infoPtr-drvPtr);

  // make space behind device tree
  // platformEntry->nProperties--;
  offset = sizeof(DeviceTreeNodeProperty)+((DeviceTreeNodeProperty*) extraPtr)->Length;
  CopyMem(extraPtr, extraPtr+offset, dtLen-(UINTN)(extraPtr-dtEntry)-offset);
  *deviceTreeLength -= (UINT32)offset;

  KextBase = RoundPage(dtEntry + *deviceTreeLength);
  if(!IsListEmpty(&gKextList)) {
    Index = 1;
    for (Link = gKextList.ForwardLink; Link != &gKextList; Link = Link->ForwardLink) {
      KextEntry = CR(Link, KEXT_ENTRY, Link, KEXT_SIGNATURE);

      CopyMem((VOID*) KextBase, (VOID*)(UINTN) KextEntry->kext.paddr, KextEntry->kext.length);
      drvinfo = (_BooterKextFileInfo*) KextBase;
      drvinfo->infoDictPhysAddr += (UINT32) KextBase;
      drvinfo->executablePhysAddr += (UINT32) KextBase;
      drvinfo->bundlePathPhysAddr += (UINT32) KextBase;

      memmapEntry->NumProperties++;
      prop = ((DeviceTreeNodeProperty*) drvPtr);
      prop->Length = sizeof(_DeviceTreeBuffer);
      mm = (_DeviceTreeBuffer*) (((UINT8*)prop) + sizeof(DeviceTreeNodeProperty));
      mm->paddr = (UINT32)KextBase;
      mm->length = KextEntry->kext.length;
      snprintf(prop->Name, 31, ""Driver-%X"", (UINT32)KextBase);

      drvPtr += sizeof(DeviceTreeNodeProperty) + sizeof(_DeviceTreeBuffer);
      KextBase = RoundPage(KextBase + KextEntry->kext.length);
		DBG_RT("" %llu - %s\\n"", Index, (CHAR8 *)(UINTN)drvinfo->bundlePathPhysAddr);
      if (gSettings.KextPatchesAllowed) {
        INT32  i;
        CHAR8  SavedValue;
        CHAR8 *InfoPlist = (CHAR8*)(UINTN)drvinfo->infoDictPhysAddr;
        SavedValue = InfoPlist[drvinfo->infoDictLength];
        InfoPlist[drvinfo->infoDictLength] = '\\0';
        KernelAndKextPatcherInit();
        for (i = 0; i < KernelAndKextPatches->NrKexts; i++) {
          if ((KernelAndKextPatches->KextPatches[i].DataLen > 0) &&
              (AsciiStrStr(InfoPlist, KernelAndKextPatches->KextPatches[i].Name) != NULL)) {
            AnyKextPatch(
                         (UINT8*)(UINTN)drvinfo->executablePhysAddr,
                         drvinfo->executableLength,
                         InfoPlist,
                         drvinfo->infoDictLength,
                         i
                         );
          }
        }
        InfoPlist[drvinfo->infoDictLength] = SavedValue;
      }
      Index++;
    }
  }

  DBG_RT(""Done.\\n"");
  Stall(5000000);
  return EFI_SUCCESS;
}


////////////////////////////////////
//
// KernelBooterExtensionsPatch to load extra kexts besides kernelcache
//
//

// Snow Leopard i386
const UINT8   KBESnowSearchEXT_i386[]  = { 0xE8, 0xED, 0xF9, 0xFF, 0xFF, 0xEB, 0x08, 0x89, 0x1C, 0x24 };
const UINT8   KBESnowReplaceEXT_i386[] = { 0xE8, 0xED, 0xF9, 0xFF, 0xFF, 0x90, 0x90, 0x89, 0x1C, 0x24 };

// Snow Leopard X64
const UINT8   KBESnowSearchEXT_X64[]   = { 0xE8, 0x5A, 0xFB, 0xFF, 0xFF, 0xEB, 0x08, 0x48, 0x89, 0xDF };
const UINT8   KBESnowReplaceEXT_X64[]  = { 0xE8, 0x5A, 0xFB, 0xFF, 0xFF, 0x90, 0x90, 0x48, 0x89, 0xDF };

// Lion i386
const UINT8   KBELionSearchEXT_i386[]  = { 0xE8, 0xAA, 0xFB, 0xFF, 0xFF, 0xEB, 0x08, 0x89, 0x34, 0x24 };
const UINT8   KBELionReplaceEXT_i386[] = { 0xE8, 0xAA, 0xFB, 0xFF, 0xFF, 0x90, 0x90, 0x89, 0x34, 0x24 };

// Lion X64
const UINT8   KBELionSearchEXT_X64[]   = { 0xE8, 0x0C, 0xFD, 0xFF, 0xFF, 0xEB, 0x08, 0x48, 0x89, 0xDF };
const UINT8   KBELionReplaceEXT_X64[]  = { 0xE8, 0x0C, 0xFD, 0xFF, 0xFF, 0x90, 0x90, 0x48, 0x89, 0xDF };


//
// We can not rely on OSVersion global variable for OS version detection,
// since in some cases it is not correct (install of ML from Lion, for example).
// So, we'll use ""brute-force"" method - just try to patch.
// Actually, we'll at least check that if we can find only one instance of code that
// we are planning to patch.
//
// Fully reworked by Sherlocks. 2019.06.23
//


VOID EFIAPI LOADER_ENTRY::KernelBooterExtensionsPatch()
{
//  UINTN   Num = 0;
  UINTN   NumSnow_i386_EXT   = 0;
  UINTN   NumSnow_X64_EXT    = 0;
  UINTN   NumLion_i386_EXT   = 0;
  UINTN   NumLion_X64_EXT    = 0;
  UINTN   patchLocation2 = 0, patchLocation3 = 0;


  DBG_RT(""\\nPatching kernel for injected kexts...\\n"");

  if (is64BitKernel) {
    NumSnow_X64_EXT  = SearchAndCount(KernelData, KERNEL_MAX_SIZE, KBESnowSearchEXT_X64, sizeof(KBESnowSearchEXT_X64));
    NumLion_X64_EXT  = SearchAndCount(KernelData, KERNEL_MAX_SIZE, KBELionSearchEXT_X64, sizeof(KBELionSearchEXT_X64));
  } else {
    NumSnow_i386_EXT = SearchAndCount(KernelData, KERNEL_MAX_SIZE, KBESnowSearchEXT_i386, sizeof(KBESnowSearchEXT_i386));
    NumLion_i386_EXT = SearchAndCount(KernelData, KERNEL_MAX_SIZE, KBELionSearchEXT_i386, sizeof(KBELionSearchEXT_i386));
  }

  if (NumSnow_i386_EXT + NumSnow_X64_EXT + NumLion_i386_EXT + NumLion_X64_EXT > 1) {
    // more then one pattern found - we do not know what to do with it
    // and we'll skipp it
//	  DBG_RT(""\\nERROR patching kernel for injected kexts:\\nmultiple patterns found (Snowi386: %llu, SnowX64: %llu, Lioni386: %llu, LionX64: %llu) - skipping patching!\\n"", NumSnow_i386_EXT, NumSnow_X64_EXT, NumLion_i386_EXT, NumLion_X64_EXT);
//    Stall(10000000);
    return;
  }

  // X64
  if (is64BitKernel) {
    if (NumSnow_X64_EXT == 1) {
      /*Num=*/ SearchAndReplace(KernelData, KERNEL_MAX_SIZE, KBESnowSearchEXT_X64, sizeof(KBESnowSearchEXT_X64), KBESnowReplaceEXT_X64, 1);
//		DBG_RT(""==> kernel Snow Leopard X64: %llu replaces done.\\n"", Num);
    } else if (NumLion_X64_EXT == 1) {
      /*Num=*/ SearchAndReplace(KernelData, KERNEL_MAX_SIZE, KBELionSearchEXT_X64, sizeof(KBELionSearchEXT_X64), KBELionReplaceEXT_X64, 1);
//		DBG_RT(""==> kernel Lion X64: %llu replaces done.\\n"", Num);
    } else {
      // EXT - load extra kexts besides kernelcache.
#if OLD_EXTRA_KEXT_PATCH
      UINT32  patchLocation1 = 0;
      for (UINT32 i = 0; i < 0x1000000; i++) {
        // 01 00 31 FF BE 14 00 05
        if (Kernel[i+0] == 0x01 && Kernel[i+1] == 0x00 && Kernel[i+2] == 0x31 &&
            Kernel[i+3] == 0xFF && Kernel[i+4] == 0xBE && Kernel[i+5] == 0x14 &&
            Kernel[i+6] == 0x00 && Kernel[i+7] == 0x05) {
          DBG_RT(""==> found EXT Base (10.8 - recent macOS)\\n"");
          for (UINT32 y = i; y < 0x1000000; y++) {
            // E8 XX 00 00 00 EB XX XX
            if (Kernel[y+0] == 0xE8 && Kernel[y+2] == 0x00 && Kernel[y+3] == 0x00 &&
                Kernel[y+4] == 0x00 && Kernel[y+5] == 0xEB) {
                //(Kernel[y+7] == 0x48 || Kernel[y+7] == 0xE8)) { // 48:10.8-10.9/E8:10.10+
              patchLocation1 = y;
              DBG_RT(""==> found EXT (10.8 - recent macOS) at 0x%08x\\n"", patchLocation1);
              break;
            }
          }
          break;
        }
      }
            
      if (!patchLocation1) {
        DBG_RT(""==> can't find EXT (10.8 - recent macOS), kernel patch aborted.\\n"");
        gBS->Stall(3000000);
      }
            
      if (patchLocation1) {
        DBG_RT(""==> patched EXT (10.8 - recent macOS) location=%x\\n"", patchLocation1);
        for (i = 5; i < 7; i++) {
          // E8 XX 00 00 00 EB XX XX
          // E8 XX 00 00 00 90 90 XX
          Kernel[patchLocation1 + i] = 0x90;
        }
      }
#else
      //Capitan
//      procedure at 950950, len = fffffffffffff3f0
//      proclen=256, end=256 startLen=0
//      found start at 0x950950
//      found pattern: 1
//    address: 0095098b
//    bytes:eb05

      UINTN procLocation = searchProc(""readStartupExtensions"");
      const UINT8 findJmp[] = {0xEB, 0x05};
      const UINT8 patchJmp[] = {0x90, 0x90};
//      DBG_RT(""==> readStartupExtensions at %llx\\n"", procLocation);
      if (!SearchAndReplace(&KernelData[procLocation], 0x100, findJmp, 2, patchJmp, 1)) {
        DBG_RT(""load kexts not patched\\n"");
//        for (UINTN j=procLocation+0x3b; j<procLocation+0x4b; ++j) {
//          DBG_RT(""%02x"", Kernel[j]);
//        }
//        DBG_RT(""\\n"");
//        Stall(10000000);
        //second attempt brute force for 10.16
        const UINT8 findJmp2[] = {0xEB, 0x05, 0xE8, 0x7D, 0x03};
        const UINT8 patchJmp2[] = {0x90, 0x90, 0xE8, 0x7D, 0x03};
        if (!SearchAndReplace(&KernelData[0], KERNEL_MAX_SIZE, findJmp2, 5, patchJmp2, 1)) {
          DBG_RT(""load kexts 2 not patched\\n"");
        } else {
          DBG_RT(""load kexts 2 patched !!!\\n"");
        }
      } else {
        DBG_RT(""load kexts patched\\n"");
//        for (UINTN j=procLocation+0x3b; j<procLocation+0x5b; ++j) {
//          DBG_RT(""%02x"", Kernel[j]);
//        }
//        DBG_RT(""\\n"");
      }
      Stall(12000000);
#endif
      // SIP - bypass kext check by System Integrity Protection.
      //the pattern found in  __ZN6OSKext14loadExecutableEv:        // OSKext::loadExecutable()
//    iMac2017:Catalina sergey$ ./FindMask kernel -p loadExecutable -e 1000 -f 488500740048000048,FFFF00FF00FF0000FF
//      descending
//      procedure at 7a1ed0, len = ffffffffffff4b50
//      proclen=4096, end=4096 startLen=0
//      found start at 0x7a1ed0
//      found pattern: 1
//    address: 007a29b7
//    bytes:4885c074224889c348

//Capitan
//      ffffff800084897b 4885DB                          test       rbx, rbx
//      ffffff800084897e 7470                            je         0xffffff80008489f0 -> patch to not jump
//                       7412                                    jmp ffffff8000848992
//      ; Basic Block Input Regs: rbx -  Killed Regs: rax rdi
//      ffffff8000848980 488B03                          mov        rax, qword [ds:rbx]
//      ffffff8000848983 4889DF                          mov        rdi, rbx
//      ffffff8000848986 FF5028                          call       qword [ds:rax+0x28]
//      ffffff8000848989 483B1DE04F2B00                  cmp        rbx, qword [ds:0xffffff8000afd970]
//      ffffff8000848990 745E                            je         0xffffff80008489f0 -> patch to not jump
//      ; Basic Block Input Regs: r13 -  Killed Regs: rax rbx rdi
//      ffffff8000848992 498B4500                        mov        rax, qword [ds:r13+0x0]
//      procedure at 6487f0, len = 7250
//      proclen=512, end=512 startLen=0
//      found start at 0x6487f0
//      found pattern: 1
//    address: 0064897b
//    bytes:4885db7470

#if OLD_EXTRA_KEXT_PATCH
      for (UINT32 i = 0; i < 0x1000000; i++) {
        // 45 31 FF 41 XX 01 00 00 DC 48
        if (Kernel[i+0] == 0x45 && Kernel[i+1] == 0x31 && Kernel[i+3] == 0x41 &&
            //(Kernel[i+4] == 0xBF || Kernel[i+4] == 0xBE) && // BF:10.11/BE:10.12+
            Kernel[i+5] == 0x01 && Kernel[i+6] == 0x00 && Kernel[i+7] == 0x00 &&
            Kernel[i+8] == 0xDC && Kernel[i+9] == 0x48) {
          
          DBG_RT(""==> found loadExecutable (10.11 - recent macOS) at %x\\n"", i);
          for (UINT32 y = i; y < 0x100000; y++) {
            // 48 85 XX 74 XX 48 XX XX 48
            if (Kernel[y+0] == 0x48 && Kernel[y+1] == 0x85 && Kernel[y+3] == 0x74 &&
                Kernel[y+5] == 0x48 && Kernel[y+8] == 0x48) {
              patchLocation2 = y;
              DBG_RT(""==> found SIP (10.11 - 10.14) at 0x%08x\\n"", patchLocation2);
              break;
            // 00 85 C0 0F 84 XX 00 00 00 49  //???? - not found in Catalina
            } else if (Kernel[y+0] == 0x00 && Kernel[y+1] == 0x85 && Kernel[y+2] == 0xC0 &&
                       Kernel[y+3] == 0x0F && Kernel[y+4] == 0x84 && Kernel[y+9] == 0x49) {
              patchLocation2 = y;
              DBG_RT(""==> found SIP (10.15 - recent macOS) at 0x%08x\\n"", patchLocation2);
              break;
            }
          }
          break;
        }
      }
#else
      const UINT8 find3[] = {0x48, 0x85, 00, 0x74, 00, 0x48, 00, 00, 0x48 };
      const UINT8 mask3[] = {0xFF, 0xFF, 00, 0xFF, 00, 0xFF, 00, 00, 0xFF };
 
#endif
      
//ffffff80009a2267 488D35970D2400                  lea        rsi, qword [ds:0xffffff8000be3005] ; ""com.apple.private.security.kext-management""
//ffffff80009a226e E89D780D00                      call       _IOTaskHasEntitlement
//ffffff80009a2273 85C0                            test       eax, eax =>change to eb06 -> jmp .+6
//ffffff80009a2275 0F843C010000                    je         0xffffff80009a23b7
//ffffff80009a227b
      UINTN taskLocation = searchProc(""IOTaskHasEntitlement"");
      procLocation = searchProc(""loadExecutable"");
      patchLocation2 = FindMemMask(&KernelData[procLocation], 0x1000, find3, sizeof(find3), mask3, sizeof(mask3));
      if (patchLocation2 != KERNEL_MAX_SIZE) {
        DBG_RT(""=> patch SIP applied\\n"");
        patchLocation2 += procLocation;
        KernelData[patchLocation2 + 3] = 0xEB;
        if (KernelData[patchLocation2 + 4] == 0x6C) {
          KernelData[patchLocation2 + 4] = 0x15;
        } else {
          KernelData[patchLocation2 + 4] = 0x12;
        }
      } else {
        patchLocation2 = FindRelative32(KernelData, procLocation, 0x1000, taskLocation);
        if (patchLocation2 != 0) {
          DBG_RT(""=> patch2 SIP applied\\n"");
          KernelData[patchLocation2] = 0xEB;
          KernelData[patchLocation2 + 1] = 0x06;
        } else {
          DBG_RT(""=> patch2 SIP not applied\\n"");
        }
      }
      Stall(10000000);
      
/*
      //Capitan: 48 85 db 74 70 48 8b 03 48
      if (patchLocation2) {
        if (taskFound) {
          UINT8 jmp = Kernel[patchLocation2 + 4];
          const UINT8 repl4[] = {0xB8, 0x01, 0x00, 0x00, 0x00, 0xEB};
          CopyMem(&Kernel[patchLocation2], repl4, sizeof(repl4));
          Kernel[patchLocation2 + 6] = jmp;
          DBG_RT(""=> mojave SIP applyed\\n"");
        } else
        if (Kernel[patchLocation2 + 0] == 0x48 && Kernel[patchLocation2 + 1] == 0x85) {
          
          Kernel[patchLocation2 + 3] = 0xEB;
          DBG_RT(""==> patched SIP (10.11 - 10.14)\\n"");
          if (Kernel[patchLocation2 + 4] == 0x6C) {
            // 48 85 XX 74 6C 48 XX XX 48
            // 48 85 XX EB 15 48 XX XX 48
            Kernel[patchLocation2 + 4] = 0x15; // 10.14.4-10.14.6
          } else {
            // 48 85 XX 74 XX 48 XX XX 48
            // 48 85 XX EB 12 48 XX XX 48
            Kernel[patchLocation2 + 4] = 0x12; // 10.11-10.14.3
          }
        // PMheart
        } else if (Kernel[patchLocation2 + 0] == 0x00 && Kernel[patchLocation2 + 1] == 0x85) {
          DBG_RT(""==> patched SIP (10.15 - recent macOS)\\n"");
          for (i = 3; i < 9; i++) {
            // 00 85 C0 0F 84 XX 00 00 00 49
            // 00 85 C0 90 90 90 90 90 90 49
            Kernel[patchLocation2 + i] = 0x90;
          }
        }
      }
      Stall(9000000);
 */
 //Slice - hope this patch useful for some system that I have no.
      // KxldUnmap by vit9696
      // Avoid race condition in OSKext::removeKextBootstrap when using booter kexts without keepsyms=1.
      procLocation = searchProc(""removeKextBootstrap"");
      const UINT8 find5[] = {0x00, 0x0F, 0x85, 00, 00, 0x00, 0x00, 0x48 };
      const UINT8 mask5[] = {0xFF, 0xFF, 0xFF, 00, 00, 0xFF, 0xFF, 0xFF };
      patchLocation3 = FindMemMask(&KernelData[procLocation], 0x1000, find5, sizeof(find5), mask5, sizeof(mask5));
      

 /*
      for (UINT32 i = 0; i < 0x1000000; i++) {
        // 55 48 89 E5 41 57 41 56 41 54 53 //10
        // 48 83 EC 30 48 C7 45 B8 XX XX XX //21
        // XX XX XX XX XX XX XX XX XX XX XX //32
        // XX XX XX XX XX XX XX XX XX XX XX //43
        // XX XX XX XX XX XX XX XX XX FF XX //54
        // XX XX XX XX XX XX XX XX XX FF FF //65
        if (Kernel[i+0] == 0x55 && Kernel[i+1] == 0x48 && Kernel[i+2] == 0x89 &&
            Kernel[i+3] == 0xE5 && Kernel[i+4] == 0x41 && Kernel[i+5] == 0x57 &&
            Kernel[i+6] == 0x41 && Kernel[i+7] == 0x56 && Kernel[i+8] == 0x41 &&
            Kernel[i+9] == 0x54 && Kernel[i+10] == 0x53 && Kernel[i+11] == 0x48 &&
            Kernel[i+12] == 0x83 && Kernel[i+13] == 0xEC && Kernel[i+14] == 0x30 &&
            Kernel[i+15] == 0x48 && Kernel[i+16] == 0xC7 && Kernel[i+17] == 0x45 &&
            Kernel[i+18] == 0xB8 && Kernel[i+53] == 0xFF && Kernel[i+64] == 0xFF && Kernel[i+65] == 0xFF) {
          DBG_RT(""==> found KxldUnmap Base (10.14 - recent macOS)\\n"");
          for (UINT32 y = i; y < 0x1000000; y++) {
            // 00 0F 85 XX XX 00 00 48
            if (Kernel[y+0] == 0x00 && Kernel[y+1] == 0x0F && Kernel[y+2] == 0x85 &&
                Kernel[y+5] == 0x00 && Kernel[y+6] == 0x00 && Kernel[y+7] == 0x48) {
              patchLocation3 = y;
              DBG_RT(""==> found KxldUnmap (10.14 - recent macOS) at 0x%08x\\n"", patchLocation3);
              break;
            }
          }
          break;
        }
      }
 */
      if (patchLocation3  == KERNEL_MAX_SIZE) {
        DBG_RT(""==> can't find KxldUnmap (10.14 - recent macOS)\\n"");
        Stall(3000000);
      } else {
        DBG_RT(""==> patched KxldUnmap (10.14 - recent macOS)\\n"");
        // 00 0F 85 XX XX 00 00 48
        // 00 90 E9 XX XX 00 00 48
        KernelData[procLocation + patchLocation3 + 1] = 0x90;
        KernelData[procLocation + patchLocation3 + 2] = 0xE9;
      }
    }
  } else {
    // i386
    if (NumSnow_i386_EXT == 1) {
/*Num=*/ SearchAndReplace(KernelData, KERNEL_MAX_SIZE, KBESnowSearchEXT_i386, sizeof(KBESnowSearchEXT_i386), KBESnowReplaceEXT_i386, 1);
//		DBG_RT(""==> kernel Snow Leopard i386: %llu replaces done.\\n"", Num);
    } else if (NumLion_i386_EXT == 1) {
/*Num=*/ SearchAndReplace(KernelData, KERNEL_MAX_SIZE, KBELionSearchEXT_i386, sizeof(KBELionSearchEXT_i386), KBELionReplaceEXT_i386, 1);
//		DBG_RT(""==> kernel Lion i386: %llu replaces done.\\n"", Num);
    } else {
      DBG_RT(""==> ERROR: NOT patched - unknown kernel.\\n"");
    }
  }

  DBG_RT(""Pausing 5 secs ...\\n"");
  Stall(5000000);
}
",16249,True,2524.1895599421323,median
"/* Copyright (c) 2020, Peter Barrett
**
** Permission to use, copy, modify, and/or distribute this software for
** any purpose with or without fee is hereby granted, provided that the
** above copyright notice and this permission notice appear in all copies.
**
** THE SOFTWARE IS PROVIDED ""AS IS"" AND THE AUTHOR DISCLAIMS ALL
** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
** SOFTWARE.
*/

/*
** Extracted from Peter Barrett's ESP_8_BIT project and adapted to Arduino
** library by Roger Cheng
*/

#include ""C_ESP_8_BIT_composite.h""

static const char *TAG = ""ESP_8_BIT"";

static ESP_8_BIT_composite* _instance_ = NULL;
static int _pal_ = 0;
static dac_channel_t _dac_ch = DAC_CHANNEL_1;  // @chrmlinux03


//====================================================================================================
//====================================================================================================
//
// low level HW setup of DAC/DMA/APLL/PWM
//

lldesc_t _dma_desc[4] = {0};
intr_handle_t _isr_handle;

extern ""C""
void IRAM_ATTR video_isr(volatile void* buf);

// simple isr
void IRAM_ATTR i2s_intr_handler_video(void *arg)
{
  if (I2S0.int_st.out_eof)
    video_isr(((lldesc_t*)I2S0.out_eof_des_addr)->buf); // get the next line of video
  I2S0.int_clr.val = I2S0.int_st.val;                     // reset the interrupt
}

static esp_err_t start_dma(int line_width, int samples_per_cc, int ch = 1)
{
  periph_module_enable(PERIPH_I2S0_MODULE);

  // setup interrupt
  if (esp_intr_alloc(ETS_I2S0_INTR_SOURCE, ESP_INTR_FLAG_LEVEL1 | ESP_INTR_FLAG_IRAM,
                     i2s_intr_handler_video, 0, &_isr_handle) != ESP_OK)
    return -1;

  // reset conf
  I2S0.conf.val = 1;
  I2S0.conf.val = 0;
  I2S0.conf.tx_right_first = 1;
  I2S0.conf.tx_mono = (ch == 2 ? 0 : 1);

  I2S0.conf2.lcd_en = 1;
  I2S0.fifo_conf.tx_fifo_mod_force_en = 1;
  I2S0.sample_rate_conf.tx_bits_mod = 16;
  I2S0.conf_chan.tx_chan_mod = (ch == 2) ? 0 : 1;

  // Create TX DMA buffers
  for (int i = 0; i < 2; i++) {
    int n = line_width * 2 * ch;
    if (n >= 4092) {
      printf(""DMA chunk too big:%s\\n"", n);
      return -1;
    }
    _dma_desc[i].buf = (uint8_t*)heap_caps_calloc(1, n, MALLOC_CAP_DMA);
    if (!_dma_desc[i].buf)
      return -1;

    _dma_desc[i].owner = 1;
    _dma_desc[i].eof = 1;
    _dma_desc[i].length = n;
    _dma_desc[i].size = n;
    _dma_desc[i].empty = (uint32_t)(i == 1 ? _dma_desc : _dma_desc + 1);
  }
  I2S0.out_link.addr = (uint32_t)_dma_desc;

  //  Setup up the apll: See ref 3.2.7 Audio PLL
  //  f_xtal = (int)rtc_clk_xtal_freq_get() * 1000000;
  //  f_out = xtal_freq * (4 + sdm2 + sdm1/256 + sdm0/65536); // 250 < f_out < 500
  //  apll_freq = f_out/((o_div + 2) * 2)
  //  operating range of the f_out is 250 MHz ~ 500 MHz
  //  operating range of the apll_freq is 16 ~ 128 MHz.
  //  select sdm0,sdm1,sdm2 to produce nice multiples of colorburst frequencies

  //  see calc_freq() for math: (4+a)*10/((2 + b)*2) mhz
  //  up to 20mhz seems to work ok:
  //  rtc_clk_apll_enable(1,0x00,0x00,0x4,0);   // 20mhz for fancy DDS

  if (!_pal_) {
    switch (samples_per_cc) {
      case 3: rtc_clk_apll_enable(1, 0x46, 0x97, 0x4, 2);   break; // 10.7386363636 3x NTSC (10.7386398315mhz)
      case 4: rtc_clk_apll_enable(1, 0x46, 0x97, 0x4, 1);   break; // 14.3181818182 4x NTSC (14.3181864421mhz)
    }
  } else {
    rtc_clk_apll_enable(1, 0x04, 0xA4, 0x6, 1); // 17.734476mhz ~4x PAL
  }

  I2S0.clkm_conf.clkm_div_num = 1;            // I2S clock divider’s integral value.
  I2S0.clkm_conf.clkm_div_b = 0;              // Fractional clock divider’s numerator value.
  I2S0.clkm_conf.clkm_div_a = 1;              // Fractional clock divider’s denominator value
  I2S0.sample_rate_conf.tx_bck_div_num = 1;
  I2S0.clkm_conf.clka_en = 1;                 // Set this bit to enable clk_apll.
  I2S0.fifo_conf.tx_fifo_mod = (ch == 2) ? 0 : 1; // 32-bit dual or 16-bit single channel data

  //    dac_output_enable(DAC_CHANNEL_1);           // DAC, video on GPIO25
  dac_output_enable(_dac_ch);           			// DAC, video on GPIO25/GPIO26
  dac_i2s_enable();                           // start DAC!

  I2S0.conf.tx_start = 1;                     // start DMA!
  I2S0.int_clr.val = 0xFFFFFFFF;
  I2S0.int_ena.out_eof = 1;
  I2S0.out_link.start = 1;
  return esp_intr_enable(_isr_handle);        // start interruprs!
}

void video_init_hw(int line_width, int samples_per_cc)
{
  // setup apll 4x NTSC or PAL colorburst rate
  start_dma(line_width, samples_per_cc, 1);

  // Now ideally we would like to use the decoupled left DAC channel to produce audio
  // But when using the APLL there appears to be some clock domain conflict that causes
  // nasty digitial spikes and dropouts.
}

//====================================================================================================
//====================================================================================================


// ntsc phase representation of a rrrgggbb pixel
// must be in RAM so VBL works
const static DRAM_ATTR uint32_t ntsc_RGB332[256] = {
  0x18181818, 0x18171A1C, 0x1A151D22, 0x1B141F26, 0x1D1C1A1B, 0x1E1B1C20, 0x20191F26, 0x2119222A,
  0x23201C1F, 0x241F1E24, 0x251E222A, 0x261D242E, 0x29241F23, 0x2A232128, 0x2B22242E, 0x2C212632,
  0x2E282127, 0x2F27232C, 0x31262732, 0x32252936, 0x342C232B, 0x352B2630, 0x372A2936, 0x38292B3A,
  0x3A30262F, 0x3B2F2833, 0x3C2E2B3A, 0x3D2D2E3E, 0x40352834, 0x41342B38, 0x43332E3E, 0x44323042,
  0x181B1B18, 0x191A1D1C, 0x1B192022, 0x1C182327, 0x1E1F1D1C, 0x1F1E2020, 0x201D2326, 0x211C252B,
  0x24232020, 0x25222224, 0x2621252A, 0x2720272F, 0x29272224, 0x2A262428, 0x2C25282E, 0x2D242A33,
  0x2F2B2428, 0x302A272C, 0x32292A32, 0x33282C37, 0x352F272C, 0x362E2930, 0x372D2C36, 0x382C2F3B,
  0x3B332930, 0x3C332B34, 0x3D312F3A, 0x3E30313F, 0x41382C35, 0x42372E39, 0x4336313F, 0x44353443,
  0x191E1E19, 0x1A1D211D, 0x1B1C2423, 0x1C1B2628, 0x1F22211D, 0x20212321, 0x21202627, 0x221F292C,
  0x24262321, 0x25252525, 0x2724292B, 0x28232B30, 0x2A2A2625, 0x2B292829, 0x2D282B2F, 0x2E272D34,
  0x302E2829, 0x312E2A2D, 0x322C2D33, 0x332B3038, 0x36332A2D, 0x37322C31, 0x38303037, 0x392F323C,
  0x3B372D31, 0x3C362F35, 0x3E35323B, 0x3F343440, 0x423B2F36, 0x423A313A, 0x44393540, 0x45383744,
  0x1A21221A, 0x1B20241E, 0x1C1F2724, 0x1D1E2A29, 0x1F25241E, 0x20242622, 0x22232A28, 0x23222C2D,
  0x25292722, 0x26292926, 0x27272C2C, 0x28262E30, 0x2B2E2926, 0x2C2D2B2A, 0x2D2B2E30, 0x2E2A3134,
  0x31322B2A, 0x32312E2E, 0x332F3134, 0x342F3338, 0x36362E2E, 0x37353032, 0x39343338, 0x3A33363C,
  0x3C3A3032, 0x3D393236, 0x3E38363C, 0x3F373840, 0x423E3337, 0x433E353B, 0x453C3841, 0x463B3A45,
  0x1A24251B, 0x1B24271F, 0x1D222B25, 0x1E212D29, 0x2029281F, 0x21282A23, 0x22262D29, 0x23252F2D,
  0x262D2A23, 0x272C2C27, 0x282A2F2D, 0x292A3231, 0x2C312C27, 0x2C302F2B, 0x2E2F3231, 0x2F2E3435,
  0x31352F2B, 0x3234312F, 0x34333435, 0x35323739, 0x3739312F, 0x38383333, 0x39373739, 0x3A36393D,
  0x3D3D3433, 0x3E3C3637, 0x3F3B393D, 0x403A3B41, 0x43423637, 0x4441383B, 0x453F3C42, 0x463F3E46,
  0x1B28291C, 0x1C272B20, 0x1D252E26, 0x1E25302A, 0x212C2B20, 0x222B2D24, 0x232A312A, 0x2429332E,
  0x26302D24, 0x272F3028, 0x292E332E, 0x2A2D3532, 0x2C343028, 0x2D33322C, 0x2F323532, 0x30313836,
  0x3238322C, 0x33373430, 0x34363836, 0x35353A3A, 0x383C3530, 0x393B3734, 0x3A3A3A3A, 0x3B393C3E,
  0x3D403734, 0x3E403938, 0x403E3C3E, 0x413D3F42, 0x44453A38, 0x45443C3C, 0x46433F42, 0x47424147,
  0x1C2B2C1D, 0x1D2A2E21, 0x1E293227, 0x1F28342B, 0x212F2E21, 0x222E3125, 0x242D342B, 0x252C362F,
  0x27333125, 0x28323329, 0x2A31362F, 0x2B303933, 0x2D373329, 0x2E36352D, 0x2F353933, 0x30343B37,
  0x333B362D, 0x343B3831, 0x35393B37, 0x36383D3B, 0x38403831, 0x393F3A35, 0x3B3D3E3B, 0x3C3C403F,
  0x3E443A35, 0x3F433D39, 0x4141403F, 0x42414243, 0x44483D39, 0x45473F3D, 0x47464243, 0x48454548,
  0x1C2E301E, 0x1D2E3222, 0x1F2C3528, 0x202B382C, 0x22333222, 0x23323426, 0x2530382C, 0x262F3A30,
  0x28373526, 0x2936372A, 0x2A343A30, 0x2B343C34, 0x2E3B372A, 0x2F3A392E, 0x30393C34, 0x31383F38,
  0x333F392E, 0x343E3C32, 0x363D3F38, 0x373C413C, 0x39433C32, 0x3A423E36, 0x3C41413C, 0x3D404440,
  0x3F473E36, 0x4046403A, 0x41454440, 0x42444644, 0x454C413A, 0x464B433E, 0x47494644, 0x49494949,
};

// PAL yuyv palette, must be in RAM
const static DRAM_ATTR uint32_t pal_yuyv[] = {
  0x18181818, 0x1A16191E, 0x1E121A26, 0x21101A2C, 0x1E1D1A1B, 0x211B1A20, 0x25171B29, 0x27151C2E,
  0x25231B1E, 0x27201C23, 0x2B1D1D2B, 0x2E1A1E31, 0x2B281D20, 0x2E261E26, 0x31221F2E, 0x34202034,
  0x322D1F23, 0x342B2029, 0x38282131, 0x3A252137, 0x38332126, 0x3A30212B, 0x3E2D2234, 0x412A2339,
  0x3E382229, 0x4136232E, 0x44322436, 0x4730253C, 0x453E242C, 0x483C2531, 0x4B382639, 0x4E36273F,
  0x171B1D19, 0x1A181E1F, 0x1D151F27, 0x20121F2D, 0x1E201F1C, 0x201E1F22, 0x241A202A, 0x26182130,
  0x2425201F, 0x27232124, 0x2A20222D, 0x2D1D2332, 0x2A2B2222, 0x2D282327, 0x3125242F, 0x33222435,
  0x31302424, 0x332E242A, 0x372A2632, 0x3A282638, 0x37362627, 0x3A33262D, 0x3D302735, 0x402D283B,
  0x3E3B272A, 0x4039282F, 0x44352938, 0x46332A3D, 0x4441292D, 0x473E2A32, 0x4B3B2B3B, 0x4D382C40,
  0x171D221B, 0x191B2220, 0x1D182329, 0x1F15242E, 0x1D23231E, 0x1F202423, 0x231D252B, 0x261A2631,
  0x23282520, 0x26262626, 0x2A22272E, 0x2C202834, 0x2A2E2723, 0x2C2B2829, 0x30282931, 0x33252937,
  0x30332926, 0x3331292B, 0x362D2A34, 0x392B2B39, 0x36382A29, 0x39362B2E, 0x3D322C36, 0x3F302D3C,
  0x3D3E2C2B, 0x3F3B2D31, 0x43382E39, 0x46352F3F, 0x44432E2E, 0x46412F34, 0x4A3E303C, 0x4D3B3042,
  0x1620271C, 0x181E2722, 0x1C1A282A, 0x1F182930, 0x1C26281F, 0x1F232924, 0x22202A2D, 0x251D2B32,
  0x232B2A22, 0x25292B27, 0x29252C30, 0x2B232C35, 0x29302C24, 0x2C2E2C2A, 0x2F2A2D32, 0x32282E38,
  0x2F362D27, 0x32332E2D, 0x36302F35, 0x382D303B, 0x363B2F2A, 0x38393030, 0x3C353138, 0x3F33323E,
  0x3C40312D, 0x3F3E3232, 0x423A333B, 0x45383340, 0x43463330, 0x46443435, 0x4940353E, 0x4C3E3543,
  0x15232B1E, 0x18212C23, 0x1B1D2D2B, 0x1E1B2E31, 0x1C282D20, 0x1E262E26, 0x22222F2E, 0x24202F34,
  0x222E2F23, 0x242B3029, 0x28283131, 0x2B253137, 0x28333126, 0x2B31312B, 0x2F2D3234, 0x312B3339,
  0x2F383229, 0x3136332E, 0x35323436, 0x3730353C, 0x353E342B, 0x383B3531, 0x3B383639, 0x3E35363F,
  0x3B43362E, 0x3E413634, 0x423D373C, 0x443B3842, 0x42493831, 0x45473837, 0x4943393F, 0x4B413A45,
  0x1526301F, 0x17233125, 0x1B20322D, 0x1D1D3333, 0x1B2B3222, 0x1D293327, 0x21253430, 0x24233435,
  0x21303425, 0x242E342A, 0x272A3532, 0x2A283638, 0x28363527, 0x2A33362D, 0x2E303735, 0x302D383B,
  0x2E3B372A, 0x30393830, 0x34353938, 0x37333A3E, 0x3440392D, 0x373E3A32, 0x3B3B3B3B, 0x3D383B40,
  0x3B463B30, 0x3D433B35, 0x41403C3D, 0x443D3D43, 0x424C3D33, 0x44493D38, 0x48463E40, 0x4A433F46,
  0x14283520, 0x16263626, 0x1A23372E, 0x1D203734, 0x1A2E3723, 0x1D2B3729, 0x20283831, 0x23253937,
  0x21333826, 0x2331392B, 0x272D3A34, 0x292B3B39, 0x27383A29, 0x29363B2E, 0x2D333C36, 0x30303D3C,
  0x2D3E3C2B, 0x303B3D31, 0x34383E39, 0x36363E3F, 0x34433E2E, 0x36413E34, 0x3A3D3F3C, 0x3C3B4042,
  0x3A493F31, 0x3D464036, 0x4043413F, 0x43404244, 0x414E4134, 0x434C4239, 0x47484342, 0x4A464447,
  0x132B3A22, 0x16293B27, 0x19253C30, 0x1C233D35, 0x19313C25, 0x1C2E3D2A, 0x202B3E32, 0x22283E38,
  0x20363E27, 0x22343E2D, 0x26303F35, 0x292E403B, 0x263B3F2A, 0x29394030, 0x2C364138, 0x2F33423E,
  0x2D41412D, 0x2F3E4232, 0x333B433B, 0x35384440, 0x33464330, 0x35444435, 0x3940453E, 0x3C3E4543,
  0x394C4533, 0x3C494538, 0x40464640, 0x42434746, 0x40514735, 0x434F473B, 0x464B4843, 0x49494949,
  //odd
  0x18181818, 0x19161A1E, 0x1A121E26, 0x1A10212C, 0x1A1D1E1B, 0x1A1B2120, 0x1B172529, 0x1C15272E,
  0x1B23251E, 0x1C202723, 0x1D1D2B2B, 0x1E1A2E31, 0x1D282B20, 0x1E262E26, 0x1F22312E, 0x20203434,
  0x1F2D3223, 0x202B3429, 0x21283831, 0x21253A37, 0x21333826, 0x21303A2B, 0x222D3E34, 0x232A4139,
  0x22383E29, 0x2336412E, 0x24324436, 0x2530473C, 0x243E452C, 0x253C4831, 0x26384B39, 0x27364E3F,
  0x1D1B1719, 0x1E181A1F, 0x1F151D27, 0x1F12202D, 0x1F201E1C, 0x1F1E2022, 0x201A242A, 0x21182630,
  0x2025241F, 0x21232724, 0x22202A2D, 0x231D2D32, 0x222B2A22, 0x23282D27, 0x2425312F, 0x24223335,
  0x24303124, 0x242E332A, 0x262A3732, 0x26283A38, 0x26363727, 0x26333A2D, 0x27303D35, 0x282D403B,
  0x273B3E2A, 0x2839402F, 0x29354438, 0x2A33463D, 0x2941442D, 0x2A3E4732, 0x2B3B4B3B, 0x2C384D40,
  0x221D171B, 0x221B1920, 0x23181D29, 0x24151F2E, 0x23231D1E, 0x24201F23, 0x251D232B, 0x261A2631,
  0x25282320, 0x26262626, 0x27222A2E, 0x28202C34, 0x272E2A23, 0x282B2C29, 0x29283031, 0x29253337,
  0x29333026, 0x2931332B, 0x2A2D3634, 0x2B2B3939, 0x2A383629, 0x2B36392E, 0x2C323D36, 0x2D303F3C,
  0x2C3E3D2B, 0x2D3B3F31, 0x2E384339, 0x2F35463F, 0x2E43442E, 0x2F414634, 0x303E4A3C, 0x303B4D42,
  0x2720161C, 0x271E1822, 0x281A1C2A, 0x29181F30, 0x28261C1F, 0x29231F24, 0x2A20222D, 0x2B1D2532,
  0x2A2B2322, 0x2B292527, 0x2C252930, 0x2C232B35, 0x2C302924, 0x2C2E2C2A, 0x2D2A2F32, 0x2E283238,
  0x2D362F27, 0x2E33322D, 0x2F303635, 0x302D383B, 0x2F3B362A, 0x30393830, 0x31353C38, 0x32333F3E,
  0x31403C2D, 0x323E3F32, 0x333A423B, 0x33384540, 0x33464330, 0x34444635, 0x3540493E, 0x353E4C43,
  0x2B23151E, 0x2C211823, 0x2D1D1B2B, 0x2E1B1E31, 0x2D281C20, 0x2E261E26, 0x2F22222E, 0x2F202434,
  0x2F2E2223, 0x302B2429, 0x31282831, 0x31252B37, 0x31332826, 0x31312B2B, 0x322D2F34, 0x332B3139,
  0x32382F29, 0x3336312E, 0x34323536, 0x3530373C, 0x343E352B, 0x353B3831, 0x36383B39, 0x36353E3F,
  0x36433B2E, 0x36413E34, 0x373D423C, 0x383B4442, 0x38494231, 0x38474537, 0x3943493F, 0x3A414B45,
  0x3026151F, 0x31231725, 0x32201B2D, 0x331D1D33, 0x322B1B22, 0x33291D27, 0x34252130, 0x34232435,
  0x34302125, 0x342E242A, 0x352A2732, 0x36282A38, 0x35362827, 0x36332A2D, 0x37302E35, 0x382D303B,
  0x373B2E2A, 0x38393030, 0x39353438, 0x3A33373E, 0x3940342D, 0x3A3E3732, 0x3B3B3B3B, 0x3B383D40,
  0x3B463B30, 0x3B433D35, 0x3C40413D, 0x3D3D4443, 0x3D4C4233, 0x3D494438, 0x3E464840, 0x3F434A46,
  0x35281420, 0x36261626, 0x37231A2E, 0x37201D34, 0x372E1A23, 0x372B1D29, 0x38282031, 0x39252337,
  0x38332126, 0x3931232B, 0x3A2D2734, 0x3B2B2939, 0x3A382729, 0x3B36292E, 0x3C332D36, 0x3D30303C,
  0x3C3E2D2B, 0x3D3B3031, 0x3E383439, 0x3E36363F, 0x3E43342E, 0x3E413634, 0x3F3D3A3C, 0x403B3C42,
  0x3F493A31, 0x40463D36, 0x4143403F, 0x42404344, 0x414E4134, 0x424C4339, 0x43484742, 0x44464A47,
  0x3A2B1322, 0x3B291627, 0x3C251930, 0x3D231C35, 0x3C311925, 0x3D2E1C2A, 0x3E2B2032, 0x3E282238,
  0x3E362027, 0x3E34222D, 0x3F302635, 0x402E293B, 0x3F3B262A, 0x40392930, 0x41362C38, 0x42332F3E,
  0x41412D2D, 0x423E2F32, 0x433B333B, 0x44383540, 0x43463330, 0x44443535, 0x4540393E, 0x453E3C43,
  0x454C3933, 0x45493C38, 0x46464040, 0x47434246, 0x47514035, 0x474F433B, 0x484B4643, 0x49494949,
};

//====================================================================================================
//====================================================================================================

uint32_t cpu_ticks()
{
  return xthal_get_ccount();
}

uint32_t us() {
  return cpu_ticks() / 240;
}

// Color clock frequency is 315/88 (3.57954545455)
// DAC_MHZ is 315/11 or 8x color clock
// 455/2 color clocks per line, round up to maintain phase
// HSYNCH period is 44/315*455 or 63.55555..us
// Field period is 262*44/315*455 or 16651.5555us

#define IRE(_x)          ((uint32_t)(((_x)+40)*255/3.3/147.5) << 8)   // 3.3V DAC
#define SYNC_LEVEL       IRE(-40)
#define BLANKING_LEVEL   IRE(0)
#define BLACK_LEVEL      IRE(7.5)
#define GRAY_LEVEL       IRE(50)
#define WHITE_LEVEL      IRE(100)


#define P0 (color >> 16)
#define P1 (color >> 8)
#define P2 (color)
#define P3 (color << 8)

// Double-buffering: _bufferA and _bufferB will be swapped back and forth.
static uint8_t** _bufferA;
static uint8_t** _bufferB;

// _lines may point to either _bufferA or _bufferB, depending on which is being displayed
// _backBuffer points to whichever one _lines is not pointing to
static uint8_t** _lines; // Front buffer currently on display
static uint8_t** _backBuffer; // Back buffer waiting to be swapped to front

// TRUE when _backBuffer is ready to go.
static bool _swapReady;

// Notification handle once front and back buffers have been swapped.
static TaskHandle_t _swapCompleteNotify;

// Number of swaps completed
static uint32_t _swap_counter = 0;

volatile int _line_counter = 0;
volatile uint32_t _frame_counter = 0;

int _active_lines;
int _line_count;

int _line_width;
int _samples_per_cc;
const uint32_t* _palette;

float _sample_rate;

int _hsync;
int _hsync_long;
int _hsync_short;
int _burst_start;
int _burst_width;
int _active_start;

int16_t* _burst0 = 0; // pal bursts
int16_t* _burst1 = 0;

static int usec(float us)
{
  uint32_t r = (uint32_t)(us * _sample_rate);
  return ((r + _samples_per_cc) / (_samples_per_cc << 1)) * (_samples_per_cc << 1); // multiple of color clock, word align
}

#define NTSC_COLOR_CLOCKS_PER_SCANLINE 228       // really 227.5 for NTSC but want to avoid half phase fiddling for now
#define NTSC_FREQUENCY (315000000.0/88)
#define NTSC_LINES 262

#define PAL_COLOR_CLOCKS_PER_SCANLINE 284        // really 283.75 ?
#define PAL_FREQUENCY 4433618.75
#define PAL_LINES 312

void pal_init();

void video_init(int samples_per_cc, int ntsc)
{
  _samples_per_cc = samples_per_cc;

  if (ntsc) {
    _sample_rate = 315.0 / 88 * samples_per_cc; // DAC rate
    _line_width = NTSC_COLOR_CLOCKS_PER_SCANLINE * samples_per_cc;
    _line_count = NTSC_LINES;
    _hsync_long = usec(63.555 - 4.7);
    _active_start = usec(samples_per_cc == 4 ? 10 : 10.5);
    _hsync = usec(4.7);
    _palette = ntsc_RGB332;
    _pal_ = 0;
  } else {
    pal_init();
    _palette = pal_yuyv;
    _pal_ = 1;
  }

  _active_lines = 240;
  video_init_hw(_line_width, _samples_per_cc);   // init the hardware
}

//===================================================================================================
//===================================================================================================
// PAL

void pal_init()
{
  int cc_width = 4;
  _sample_rate = PAL_FREQUENCY * cc_width / 1000000.0;   // DAC rate in mhz
  _line_width = PAL_COLOR_CLOCKS_PER_SCANLINE * cc_width;
  _line_count = PAL_LINES;
  _hsync_short = usec(2);
  _hsync_long = usec(30);
  _hsync = usec(4.7);
  _burst_start = usec(5.6);
  _burst_width = (int)(10 * cc_width + 4) & 0xFFFE;
  _active_start = usec(10.4);

  // make colorburst tables for even and odd lines
  _burst0 = new int16_t[_burst_width];
  _burst1 = new int16_t[_burst_width];
  float phase = 2 * M_PI / 2;
  for (int i = 0; i < _burst_width; i++)
  {
    _burst0[i] = BLANKING_LEVEL + sin(phase + 3 * M_PI / 4) * BLANKING_LEVEL / 1.5;
    _burst1[i] = BLANKING_LEVEL + sin(phase - 3 * M_PI / 4) * BLANKING_LEVEL / 1.5;
    phase += 2 * M_PI / cc_width;
  }
}

void IRAM_ATTR blit_pal(uint8_t* src, uint16_t* dst)
{
  uint32_t c, color;
  bool even = _line_counter & 1;
  const uint32_t* p = even ? _palette : _palette + 256;
  int left = 0;
  int right = 256;
  uint8_t mask = 0xFF;
  uint8_t c0, c1, c2, c3, c4;
  uint8_t y1, y2, y3;

  // 192 of 288 color clocks wide: roughly correct aspect ratio
  dst += 88;

  // 4 pixels over 3 color clocks, 12 samples
  // do the blitting
  for (int i = left; i < right; i += 4) {
    c = *((uint32_t*)(src + i));
    color = p[c & mask];
    dst[0 ^ 1] = P0;
    dst[1 ^ 1] = P1;
    dst[2 ^ 1] = P2;
    color = p[(c >> 8) & mask];
    dst[3 ^ 1] = P3;
    dst[4 ^ 1] = P0;
    dst[5 ^ 1] = P1;
    color = p[(c >> 16) & mask];
    dst[6 ^ 1] = P2;
    dst[7 ^ 1] = P3;
    dst[8 ^ 1] = P0;
    color = p[(c >> 24) & mask];
    dst[9 ^ 1] = P1;
    dst[10 ^ 1] = P2;
    dst[11 ^ 1] = P3;
    dst += 12;
  }
}

void IRAM_ATTR burst_pal(uint16_t* line)
{
  line += _burst_start;
  int16_t* b = (_line_counter & 1) ? _burst0 : _burst1;
  for (int i = 0; i < _burst_width; i += 2) {
    line[i ^ 1] = b[i];
    line[(i + 1) ^ 1] = b[i + 1];
  }
}

//===================================================================================================
//===================================================================================================
// ntsc tables
// AA AA                // 2 pixels, 1 color clock - atari
// AA AB BB             // 3 pixels, 2 color clocks - nes
// AAA ABB BBC CCC      // 4 pixels, 3 color clocks - sms

// cc == 3 gives 684 samples per line, 3 samples per cc, 3 pixels for 2 cc
// cc == 4 gives 912 samples per line, 4 samples per cc, 2 pixels per cc

#ifdef PERF
#define BEGIN_TIMING()  uint32_t t = cpu_ticks()
#define END_TIMING() t = cpu_ticks() - t; _blit_ticks_min = min(_blit_ticks_min,t); _blit_ticks_max = max(_blit_ticks_max,t);
#define ISR_BEGIN() uint32_t t = cpu_ticks()
#define ISR_END() t = cpu_ticks() - t;_isr_us += (t+120)/240;
uint32_t _blit_ticks_min = 0;
uint32_t _blit_ticks_max = 0;
uint32_t _isr_us = 0;
#else
#define BEGIN_TIMING()
#define END_TIMING()
#define ISR_BEGIN()
#define ISR_END()
#endif

// draw a line of game in NTSC
void IRAM_ATTR blit(uint8_t* src, uint16_t* dst)
{
  uint32_t* d = (uint32_t*)dst;
  const uint32_t* p = _palette;
  uint32_t color, c;
  uint32_t mask = 0xFF;
  int i;

  BEGIN_TIMING();
  if (_pal_) {
    blit_pal(src, dst);
    END_TIMING();
    return;
  }

  // AAA ABB BBC CCC
  // 4 pixels, 3 color clocks, 4 samples per cc
  // each pixel gets 3 samples, 192 color clocks wide
  for (i = 0; i < 256; i += 4) {
    c = *((uint32_t*)(src + i));
    color = p[c & mask];
    dst[0 ^ 1] = P0;
    dst[1 ^ 1] = P1;
    dst[2 ^ 1] = P2;
    color = p[(c >> 8) & mask];
    dst[3 ^ 1] = P3;
    dst[4 ^ 1] = P0;
    dst[5 ^ 1] = P1;
    color = p[(c >> 16) & mask];
    dst[6 ^ 1] = P2;
    dst[7 ^ 1] = P3;
    dst[8 ^ 1] = P0;
    color = p[(c >> 24) & mask];
    dst[9 ^ 1] = P1;
    dst[10 ^ 1] = P2;
    dst[11 ^ 1] = P3;
    dst += 12;
  }

  END_TIMING();
}

void IRAM_ATTR burst(uint16_t* line)
{
  if (_pal_) {
    burst_pal(line);
    return;
  }

  int i, phase;
  switch (_samples_per_cc) {
    case 4:
      // 4 samples per color clock
      for (i = _hsync; i < _hsync + (4 * 10); i += 4) {
        line[i + 1] = BLANKING_LEVEL;
        line[i + 0] = BLANKING_LEVEL + BLANKING_LEVEL / 2;
        line[i + 3] = BLANKING_LEVEL;
        line[i + 2] = BLANKING_LEVEL - BLANKING_LEVEL / 2;
      }
      break;
    case 3:
      // 3 samples per color clock
      phase = 0.866025 * BLANKING_LEVEL / 2;
      for (i = _hsync; i < _hsync + (3 * 10); i += 6) {
        line[i + 1] = BLANKING_LEVEL;
        line[i + 0] = BLANKING_LEVEL + phase;
        line[i + 3] = BLANKING_LEVEL - phase;
        line[i + 2] = BLANKING_LEVEL;
        line[i + 5] = BLANKING_LEVEL + phase;
        line[i + 4] = BLANKING_LEVEL - phase;
      }
      break;
  }
}

void IRAM_ATTR sync(uint16_t* line, int syncwidth)
{
  for (int i = 0; i < syncwidth; i++)
    line[i] = SYNC_LEVEL;
}

void IRAM_ATTR blanking(uint16_t* line, bool vbl)
{
  int syncwidth = vbl ? _hsync_long : _hsync;
  sync(line, syncwidth);
  for (int i = syncwidth; i < _line_width; i++)
    line[i] = BLANKING_LEVEL;
  if (!vbl)
    burst(line);    // no burst during vbl
}

// Fancy pal non-interlace
// http://martin.hinner.info/vga/pal.html
void IRAM_ATTR pal_sync2(uint16_t* line, int width, int swidth)
{
  swidth = swidth ? _hsync_long : _hsync_short;
  int i;
  for (i = 0; i < swidth; i++)
    line[i] = SYNC_LEVEL;
  for (; i < width; i++)
    line[i] = BLANKING_LEVEL;
}

uint8_t DRAM_ATTR _sync_type[8] = {0, 0, 0, 3, 3, 2, 0, 0};
void IRAM_ATTR pal_sync(uint16_t* line, int i)
{
  uint8_t t = _sync_type[i - 304];
  pal_sync2(line, _line_width / 2, t & 2);
  pal_sync2(line + _line_width / 2, _line_width / 2, t & 1);
}

// Wait for front and back buffers to swap before starting drawing
void video_sync()
{
  if (!_lines)
    return;
  ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
}

// Workhorse ISR handles audio and video updates
extern ""C""
void IRAM_ATTR video_isr(volatile void* vbuf)
{
  if (!_lines)
    return;

  ISR_BEGIN();

  int i = _line_counter++;
  uint16_t* buf = (uint16_t*)vbuf;
  if (_pal_) {
    // pal
    if (i < 32) {
      blanking(buf, false);               // pre render/black 0-32
    } else if (i < _active_lines + 32) {    // active video 32-272
      sync(buf, _hsync);
      burst(buf);
      blit(_lines[i - 32], buf + _active_start);
    } else if (i < 304) {                   // post render/black 272-304
      blanking(buf, false);
    } else {
      pal_sync(buf, i);                   // 8 lines of sync 304-312
    }
  } else {
    // ntsc
    if (i < _active_lines) {                // active video
      sync(buf, _hsync);
      burst(buf);
      blit(_lines[i], buf + _active_start);

    } else if (i < (_active_lines + 5)) {   // post render/black
      blanking(buf, false);

    } else if (i < (_active_lines + 8)) {   // vsync
      blanking(buf, true);

    } else {                                // pre render/black
      blanking(buf, false);
    }
  }

  if (_line_counter == _line_count) {
    _line_counter = 0;                      // frame is done
    _frame_counter++;

    // Is the back buffer ready to go?
    if (_swapReady) {
      // Swap front and back buffers
      if (_lines == _bufferA) {
        _lines = _bufferB;
        _backBuffer = _bufferA;
      } else {
        _lines = _bufferA;
        _backBuffer = _bufferB;
      }
      _swapReady = false;
      _swap_counter++;

      // Signal video_sync() swap has completed
      vTaskNotifyGiveFromISR(
        _swapCompleteNotify,
        NULL);
    }
  }

  ISR_END();
}

//===================================================================================================
//===================================================================================================
// Wrapper class

/*
   @brief Constructor for ESP_8_BIT composite video wrapper class
   @param ntsc True (or nonzero) for NTSC mode, False (or zero) for PAL mode
*/
ESP_8_BIT_composite::ESP_8_BIT_composite(int ntsc)
{
  _pal_ = !ntsc;
  if (NULL == _instance_)
  {
    _instance_ = this;
  }
  _started = false;
  _bufferA = NULL;
  _bufferB = NULL;
}

/*
   @brief Destructor for ESP_8_BIT composite video wrapper class.
*/
ESP_8_BIT_composite::~ESP_8_BIT_composite()
{
  if (_bufferA)
  {
    frameBufferFree(_bufferA);
    _bufferA = NULL;
  }
  if (_bufferB)
  {
    frameBufferFree(_bufferB);
    _bufferB = NULL;
  }
  if (_started)
  {
    // Free resources by mirroring everything allocated in start_dma()
    esp_intr_disable(_isr_handle);
    dac_i2s_disable();
    //    dac_output_disable(DAC_CHANNEL_1);
    dac_output_disable(_dac_ch); // @chrmlinux03
    if (!_pal_) {
      rtc_clk_apll_enable(false, 0x46, 0x97, 0x4, 1);
    } else {
      rtc_clk_apll_enable(false, 0x04, 0xA4, 0x6, 1);
    }
    for (int i = 0; i < 2; i++) {
      heap_caps_free((void*)(_dma_desc[i].buf));
      _dma_desc[i].buf = NULL;
    }
    // Missing: There doesn't seem to be a esp_intr_free() to go with esp_intr_alloc()?
    periph_module_disable(PERIPH_I2S0_MODULE);
    _started = false;
  }
  _lines = NULL;
  _backBuffer = NULL;
  _instance_ = NULL;
}

/*
   @brief Check to ensure this instance is the first and only allowed instance
*/
void ESP_8_BIT_composite::instance_check()
{
  if (_instance_ != this)
  {
    ESP_LOGE(TAG, ""Only one instance of ESP_8_BIT_composite class is allowed."");
    ESP_ERROR_CHECK(ESP_FAIL);
  }
}

/*
   @brief Video subsystem setup: allocate frame buffer and start engine
*/
void ESP_8_BIT_composite::begin(dac_channel_t dac_ch)
{
  instance_check();
  _dac_ch = dac_ch;

  if (_started)
  {
    ESP_LOGE(TAG, ""begin() is only allowed to be called once."");
    ESP_ERROR_CHECK(ESP_FAIL);
  }
  _started = true;

  _bufferA = frameBufferAlloc();
  _bufferB = frameBufferAlloc();

  _lines = _bufferA;
  _backBuffer = _bufferB;

  // Initialize double-buffering infrastructure
  _swapReady = false;
  _swapCompleteNotify = xTaskGetCurrentTaskHandle();

  // Start video signal generator
  video_init(4, !_pal_);
}

/////////////////////////////////////////////////////////////////////////////
//
//  Frame buffer memory allocation notes
//
// Architecture can tolerate each _line[i] being a separate chunk of memory
// but allocating in tiny 256 byte chunks is inefficient. (16 bytes of
// overhead per allocation.) On the opposite end, allocating the entire
// buffer at once (256*240 = 60kB) demands a large contiguous chunk of
// memory which might not exist if memory space is fragmented.
//
// Compromise: Allocate frame buffer in 4kB chunks. This means each
// frame buffer is made of 15 4kB chunks instead of a single 60kB chunk.
//
// 14 extra allocations * 16 byte overhead = 224 extra bytes, worth it.

const uint16_t linesPerFrame = 240;
const uint16_t bytesPerLine = 256;
const uint16_t linesPerChunk = 16;
const uint16_t chunkSize = bytesPerLine * linesPerChunk;
const uint16_t chunksPerFrame = 15;

/*
   @brief Allocate memory for frame buffer
*/
uint8_t** ESP_8_BIT_composite::frameBufferAlloc()
{
  uint8_t** lineArray = NULL;
  uint8_t*  lineChunk = NULL;
  uint8_t*  lineStep  = NULL;

  lineArray = new uint8_t*[linesPerFrame];
  if ( NULL == lineArray )
  {
    ESP_LOGE(TAG, ""Frame lines array allocation fail"");
    ESP_ERROR_CHECK(ESP_FAIL);
  }

  for (uint8_t chunk = 0; chunk < chunksPerFrame; chunk++)
  {
    lineChunk = new uint8_t[chunkSize];
    if ( NULL == lineChunk )
    {
      ESP_LOGE(TAG, ""Frame buffer chunk allocation fail"");
      ESP_ERROR_CHECK(ESP_FAIL);
    }
    lineStep = lineChunk;
    for (uint8_t lineIndex = 0; lineIndex < linesPerChunk; lineIndex++)
    {
      lineArray[(chunk * linesPerChunk) + lineIndex] = lineStep;
      lineStep += bytesPerLine;
    }
  }

  return lineArray;
}

/*
   @brief Free memory allocated by frameBufferAlloc();
*/
void ESP_8_BIT_composite::frameBufferFree(uint8_t** lineArray)
{
  for (uint8_t chunk = 0; chunk < chunksPerFrame; chunk++)
  {
    free(lineArray[chunk * linesPerChunk]);
  }
  free(lineArray);
}

/*
   @brief Wait for current frame to finish rendering
*/
void ESP_8_BIT_composite::waitForFrame()
{
  instance_check();

  _swapReady = true;

  video_sync();
}

/*
   @brief Retrieve pointer to frame buffer lines array
*/
uint8_t** ESP_8_BIT_composite::getFrameBufferLines()
{
  instance_check();

  return _backBuffer;
}

/*
   @brief Number of frames sent to screen
*/
uint32_t ESP_8_BIT_composite::getRenderedFrameCount()
{
  return _frame_counter;
}

/*
   @brief Number of buffer swaps performed
*/
uint32_t ESP_8_BIT_composite::getBufferSwapCount()
{
  return _swap_counter;
}
",16157,True,3094.6589353217746,median
"//******************************************************************************
// Copyright (c) Microsoft Corporation.  All rights reserved.
// ttsmarkup.cpp
//
//******************************************************************************

#include ""TTSComp.h""

//******************************************************************************
//***** Internal Functions
//******************************************************************************
#include ""f0.h""
int
ComputeF0 (float* data, int nData, int sampFreq, int minF0, int maxF0, int feaSampFreq, 
           float** f0, int* nF0, float **pRms, int *nRms)
{
  char parStr[128];
  F0Data f0Obj = NULL;
  F0Out f0Frame;
  int buffSize;
  int buffStep;
  int nFrames;
  int remainder;
  int nOutput;
  int outSampNum;
  int i;
  int j;

//  assert (data);
 // assert (nData>0);
 // assert (sampFreq);
 // assert (feaSampFreq);
 // assert (f0);

  /*
   * Create and initialize the f0 object
   */
  if ((f0Obj = F0_NewF0Obj ()) == NULL) {
    goto error;
  }

  sprintf (parStr ,""frame_step=%f"", 1.0/feaSampFreq);
  if (!F0_ParseParameter (f0Obj, parStr)) {
    goto error;
  }
  
  sprintf (parStr ,""min_f0=%f"", (float)minF0);
  if (!F0_ParseParameter (f0Obj, parStr)) {
    goto error;
  }

  sprintf (parStr ,""max_f0=%f"", (float)maxF0);
  if (!F0_ParseParameter (f0Obj, parStr)) {
    goto error;
  }

  if (!F0_Init (f0Obj, sampFreq, &buffSize, &buffStep)) {
    goto error;
  }

  /*
   * Prepare memory for output
   */
  *nF0 = *nRms = (int) (((nData / (float)sampFreq) * feaSampFreq) + 0.5);

  *f0 = NULL;
  *pRms = NULL;
  if ( (*f0 = (float *) malloc(*nF0 * sizeof(**f0))) == NULL) 
  {
    goto error;
  }
  if ( (*pRms = (float *) malloc(*nRms * sizeof(**pRms))) == NULL) 
  {
    goto error;
  }

  /*
   * Start processing
   */
  nFrames = (nData - buffSize) / buffStep + 1;
  remainder = nData - nFrames*buffStep;

  outSampNum = 0;
   
  /* Iterate over number of frames*/
  for (i = 0; i<nFrames; i++) {
  
    if ( !F0_AddDataFrame (f0Obj, data + i*buffStep, buffSize) ) {
      goto error;
    }

    nOutput = F0_OutputLength (f0Obj);
    for (j=0; j<nOutput; j++ ) 
	{
      f0Frame = F0_GetOutputFrame (f0Obj, j);
      (*f0)[outSampNum] = f0Frame.f0;
      (*pRms)[outSampNum] = f0Frame.rms;
      outSampNum++;
    }
  }

  /* Remaining samples */
  if ( !F0_AddDataFrame (f0Obj, data + nFrames*buffStep, remainder) ) {
    goto error;
  }

  nOutput = F0_OutputLength (f0Obj);
  for (i=0; i<nOutput; i++ ) 
  {
    f0Frame = F0_GetOutputFrame (f0Obj, i);
    (*f0)[outSampNum]  = f0Frame.f0;
    (*pRms)[outSampNum] = f0Frame.rms;
    outSampNum++;
  }
  
  for (i=outSampNum; i< *nF0; i++) 
  {
    (*f0)[i]  = f0Frame.f0;
    (*pRms)[i]  = f0Frame.rms;
  }

  F0_DeleteF0Obj (&f0Obj);
  return 1;

error:
  if (f0Obj) 
  {
    F0_DeleteF0Obj (&f0Obj);
  }
  if( *f0 )
  {
	  free( *f0 );
  }
  if( *pRms )
  {
	  free( *pRms );
  }

  return 0;
}





//******************************************************************************
//***** TestProc()'s
//******************************************************************************

//********************************************************************************
TESTPROCAPI t_XMLBookmark(UINT uMsg, TPPARAM tpParam, LPFUNCTION_TABLE_ENTRY lpFTE) 
{
	//This test Speaks with CONTEXT tag. 

	// Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;
	
	CComPtr<ISpVoice>           cpLocalVoice;

	// Create the SAPI voice
    DOCHECKHRGOTO (hr = cpLocalVoice.CoCreateInstance( CLSID_SpVoice ););

	tpr = t_XMLBookmark_Test(uMsg, tpParam, lpFTE, cpLocalVoice, false);

EXIT:
	return tpr;
}
//******************************************************************************** 
TESTPROCAPI t_XMLBookmark_Test(UINT uMsg, 
								 TPPARAM tpParam, 
								 LPFUNCTION_TABLE_ENTRY lpFTE,
								 ISpVoice *cpVoice,
								 bool bCalledByMulti)
{
// This test passes a Bookmark through XML marked up text to a TTS engine and checks 
// to make sure a SPFEI_BOOKMARK event has fired.

    // Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    HRESULT                         hr = S_OK;
    int                             tpr = TPR_PASS;
 
    BOOL                            bGetEvents = true;
    WCHAR                           szwSpeakStr[MAX_PATH]=L"""";
    WCHAR							szwDebug[MAX_PATH]=L"""";
	DWORD							dwEventsRetrieved = 0;
	WCHAR							szwBmk[MAX_PATH]=L"""";
   
    

    if( SUCCEEDED( hr ) )
    {
		hr = cpVoice->SetNotifyWin32Event();
    }
    
    if( SUCCEEDED( hr ) )
    {
        hr = cpVoice->SetInterest( SPFEI(SPEI_TTS_BOOKMARK), SPFEI(SPEI_TTS_BOOKMARK) );  
    }
    
	//clean up the event queue
	while( hr == S_OK  )
	{
		SPEVENT			Event;
						
		hr = cpVoice->GetEvents (1, &Event, NULL);
	}
	CHECKHRId( hr, tpr, IDS_STRING120 );

    if( SUCCEEDED( hr ) )
    {
        GetWStrFromRes( IDS_STRING20, szwSpeakStr );
        hr = cpVoice->Speak( szwSpeakStr, SPF_ASYNC | SPF_IS_XML, NULL );  
    }

    if( SUCCEEDED( hr ) )
    {
        hr = cpVoice->WaitUntilDone( TTS_WAITTIME );
		CHECKASSERTGOTOIdEx( (hr == S_OK), tpr, IDS_STRING61, "" in t_XMLBookmarkTest"");
    }

	while( hr == S_OK  )
	{
		SPEVENT			Event;
						
		hr = cpVoice->GetEvents (1, &Event, NULL);
	
		if( hr == S_OK )
		{
			// Record the events retrieved in dwFlagsRetrieved
			dwEventsRetrieved |= (DWORD)Event.eEventId;	

			if (Event.eEventId == SPEI_TTS_BOOKMARK )
			{
				//swprintf( szwBmk, L""%s, %d"", (WCHAR*)Event.lParam, Event.wParam );
				//g_pKato->Comment(10, szwBmk);

				//verify bookmark string (lparam and wparam)
				GetWStrFromRes( IDS_STRING21, szwDebug );
				CHECKASSERTGOTOId(( !wcscmp( (WCHAR*)Event.lParam, szwDebug ) ), tpr, IDS_STRING22); 
				CHECKASSERTGOTOId(( Event.wParam == _wtol(szwDebug) ), tpr, IDS_STRING22); 						

				break;		
			}
		}

	}
 

    // Logging info
    CHECKHRId( hr, tpr, IDS_STRING22 );
		
	// Make sure correct events were retrieved
	CHECKASSERTGOTOId(((dwEventsRetrieved & SPEI_TTS_BOOKMARK) == SPEI_TTS_BOOKMARK), tpr, IDS_STRING22);


EXIT:    

    return tpr;
}
//********************************************************************************
TESTPROCAPI t_XMLSilence(UINT uMsg, TPPARAM tpParam, LPFUNCTION_TABLE_ENTRY lpFTE) 
{
	//This test Speaks with CONTEXT tag. 

	// Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;
	
	CComPtr<ISpVoice>           cpLocalVoice;

	// Create the SAPI voice
    DOCHECKHRGOTO (hr = cpLocalVoice.CoCreateInstance( CLSID_SpVoice ););

	tpr = t_XMLSilence_Test(uMsg, tpParam, lpFTE, cpLocalVoice, false);

EXIT:
	return tpr;
}
//******************************************************************************** 
TESTPROCAPI t_XMLSilence_Test(UINT uMsg, 
								 TPPARAM tpParam, 
								 LPFUNCTION_TABLE_ENTRY lpFTE,
								 ISpVoice *cpVoice,
								 bool bCalledByMulti)
{
// This test speaks 2 streams. One with a Silence pause and one without. It analyzes
//the two streams to make sure a change has occured. This tests SILENCE tag.

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;
        
    // Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }


    CComPtr<ISpStream>          cpStream1;
    CComPtr<ISpStream>          cpStream2;
    STATSTG                     Stat;
    ULONG                       cSamples1=0, cSamples2=0;
    WCHAR                       szwSpeakStr[MAX_PATH]=L"""";
    WCHAR                       szwDebug[MAX_PATH]=L"""";
	const char					* TEST_TOPIC = """";

	//======================================================================
    	TEST_TOPIC = ""Initialization"";
	//======================================================================
 
	CSpStreamFormat				NewFmt(SPSF_22kHz16BitMono, &hr);
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING84, TEST_TOPIC );  

	//======================================================================
    	TEST_TOPIC = ""Stream 1 with no SILENCE tag"";
	//======================================================================
 
    // Create stream #1
    hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream1 ); 
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING81,  TEST_TOPIC);  
	
    // Set the default output format
	hr = cpVoice->SetOutput( cpStream1, TRUE);
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING60,  TEST_TOPIC);
	       
	hr = GetWStrFromRes( IDS_STRING23, szwSpeakStr );
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING83,  TEST_TOPIC);
	
	hr = cpVoice->Speak( szwSpeakStr,  SPF_IS_XML, NULL );
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING13,  TEST_TOPIC);
      
    // Get stream size
	hr = cpStream1->Stat( &Stat, STATFLAG_NONAME );
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING90, TEST_TOPIC );

	cSamples1 = (ULONG)Stat.cbSize.QuadPart / sizeof(short);
    CHECKASSERTGOTOIdEx((cSamples1 > 0), tpr, IDS_STRING25, TEST_TOPIC );

 	//======================================================================
    	TEST_TOPIC = ""Stream 2 with SILENCE tag"";
	//======================================================================

    // Create stream #1
    hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream2 ); 
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING81,  TEST_TOPIC);  
	
    // Set the default output format
	hr = cpVoice->SetOutput( cpStream2, TRUE);
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING60,  TEST_TOPIC);
	       
	hr = GetWStrFromRes( IDS_STRING24, szwSpeakStr );
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING83,  TEST_TOPIC);
	
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING13,  TEST_TOPIC);
      
    // Get stream size
	hr = cpStream2->Stat( &Stat, STATFLAG_NONAME );
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING90, TEST_TOPIC );

	cSamples2 = (ULONG)Stat.cbSize.QuadPart / sizeof(short);
    CHECKASSERTGOTOIdEx((cSamples2 > 0), tpr, IDS_STRING25, TEST_TOPIC );

    // Now compare the length of the 2 streams
    // Note - check to ensure cSamples2 is at least twice greater than cSamples1.
	CHECKASSERTId((cSamples2 > 2 * cSamples1), tpr, IDS_STRING25);

EXIT:    
    return tpr;
}
//********************************************************************************
TESTPROCAPI t_XMLSpell(UINT uMsg, TPPARAM tpParam, LPFUNCTION_TABLE_ENTRY lpFTE) 
{
	//This test Speaks with CONTEXT tag. 

	// Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;
	
	CComPtr<ISpVoice>           cpLocalVoice;

	// Create the SAPI voice
    DOCHECKHRGOTO (hr = cpLocalVoice.CoCreateInstance( CLSID_SpVoice ););

	tpr = t_XMLSpell_Test(uMsg, tpParam, lpFTE, cpLocalVoice, false);

EXIT:
	return tpr;
}
//******************************************************************************** 
TESTPROCAPI t_XMLSpell_Test(UINT uMsg, 
								 TPPARAM tpParam, 
								 LPFUNCTION_TABLE_ENTRY lpFTE,
								 ISpVoice *cpVoice,
								 bool bCalledByMulti)
{
// This test generates two streams. One that says English as a single word and one that
// spells it out. It analyzes the produced .wav forms to make sure that the second streams
// overall size is greater.

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;
        
    // Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    CComPtr<ISpStream>          cpStream1;
    CComPtr<ISpStream>          cpStream2;
    STATSTG                     Stat;
	LANGID                      LangID;
    ULONG                       cSamples1=0, cSamples2=0;
    WCHAR                       szwSpeakStr[MAX_PATH]=L"""";
    WCHAR                       szwDebug[MAX_PATH]=L"""";
	const char					* TEST_TOPIC = """";

	//======================================================================
    	TEST_TOPIC = ""Initialization"";
	//======================================================================
 
	CSpStreamFormat				NewFmt(SPSF_22kHz16BitMono, &hr);
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING84, TEST_TOPIC );  

	DOCHECKHRGOTO( hr = SpGetLanguageIdFromDefaultVoice(&LangID); ); 

	//======================================================================
    	TEST_TOPIC = ""Stream 1 with no Spell tag"";
	//======================================================================
 
    // Create stream #1
    hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream1 ); 
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING81,  TEST_TOPIC);  
	
    // Set the default output format
	hr = cpVoice->SetOutput( cpStream1, TRUE);
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING60,  TEST_TOPIC);
	       
	hr = GetWStrFromRes( IDS_STRING26, szwSpeakStr );
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING83,  TEST_TOPIC);
	
	hr = cpVoice->Speak( szwSpeakStr,  SPF_IS_XML, NULL );
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING13,  TEST_TOPIC);
      
    // Get stream size
	hr = cpStream1->Stat( &Stat, STATFLAG_NONAME );
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING90, TEST_TOPIC );

	cSamples1 = (ULONG)Stat.cbSize.QuadPart / sizeof(short);

 	//======================================================================
    	TEST_TOPIC = ""Stream 2 with Spell tag"";
	//======================================================================

    // Create stream #2
    hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream2 ); 
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING81,  TEST_TOPIC);  
	
    // Set the default output format
	hr = cpVoice->SetOutput( cpStream2, TRUE);
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING60,  TEST_TOPIC);
	      
	hr = GetWStrFromRes( IDS_STRING27, szwSpeakStr );
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING83,  TEST_TOPIC);
	
	hr = cpVoice->Speak( szwSpeakStr,  SPF_IS_XML, NULL );
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING13,  TEST_TOPIC);
      
    // Get stream size
	hr = cpStream2->Stat( &Stat, STATFLAG_NONAME );
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING90, TEST_TOPIC );

	cSamples2 = (ULONG)Stat.cbSize.QuadPart / sizeof(short);

	//For Chinese/Japanese TTS Engines, the test ignores result check since 
	//Spell tag can be ignored in those languages

	if ( ( LangID != 2052 ) && ( LangID != 1041 ))
	{
		CHECKASSERTGOTOIdEx((cSamples2 != 0), tpr, IDS_STRING28, TEST_TOPIC );
		CHECKASSERTGOTOIdEx((cSamples1 != 0), tpr, IDS_STRING28, TEST_TOPIC );

		// Now compare the values from the 2 streams.
		// Note - check to ensure cSamples2 is at least 4/3 greater than cSamples1.
		CHECKASSERTId(((3 * cSamples2 )> (4 * cSamples1)), tpr, IDS_STRING28);
    }
EXIT:  
    return tpr;
}
//********************************************************************************
TESTPROCAPI t_XMLPronounce(UINT uMsg, TPPARAM tpParam, LPFUNCTION_TABLE_ENTRY lpFTE) 
{
	//This test Speaks with CONTEXT tag. 

	// Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;
	
	CComPtr<ISpVoice>           cpLocalVoice;

	// Create the SAPI voice
    DOCHECKHRGOTO (hr = cpLocalVoice.CoCreateInstance( CLSID_SpVoice ););

	tpr = t_XMLPronounce_Test(uMsg, tpParam, lpFTE, cpLocalVoice, false);

EXIT:
	return tpr;
}
//******************************************************************************** 
TESTPROCAPI t_XMLPronounce_Test(UINT uMsg, 
								 TPPARAM tpParam, 
								 LPFUNCTION_TABLE_ENTRY lpFTE,
								 ISpVoice *cpVoice,
								 bool bCalledByMulti)
{
// This test generates two streams. One that says ""a"" as a single word. The next stream
// says ""a"" but tells the engine to pronounce it as a random long word. It analyzes the 
// produced .wav forms to make sure that the second stream's overall size is greater.

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;
        
    // Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    CComPtr<ISpStream>          cpStream1;
    CComPtr<ISpStream>          cpStream2;
    STATSTG                     Stat;
    ULONG                       cSamples1=0, cSamples2=0;
    WCHAR                       szwSpeakStr[MAX_PATH]=L"""";
    WCHAR                       szwDebug[MAX_PATH]=L"""";
	const char					* TEST_TOPIC = """";

	//======================================================================
    	TEST_TOPIC = ""Initialization"";
	//======================================================================
 
	CSpStreamFormat				NewFmt(SPSF_22kHz16BitMono, &hr);
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING84, TEST_TOPIC );  

	//======================================================================
    	TEST_TOPIC = ""Stream 1 with no PRON tag"";
	//======================================================================
 
    // Create stream #1
    hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream1 ); 
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING81,  TEST_TOPIC);  
	
    // Set the default output format
	hr = cpVoice->SetOutput( cpStream1, TRUE);
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING60,  TEST_TOPIC);
	
	// short string        
	hr = GetWStrFromRes( IDS_STRING56, szwSpeakStr );
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING83,  TEST_TOPIC);
	
	hr = cpVoice->Speak( szwSpeakStr,  SPF_IS_XML, NULL );
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING13,  TEST_TOPIC);
      
    // Get stream size
	hr = cpStream1->Stat( &Stat, STATFLAG_NONAME );
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING90, TEST_TOPIC );

	cSamples1 = (ULONG)Stat.cbSize.QuadPart / sizeof(short);
    CHECKASSERTGOTOIdEx((cSamples1 != 0), tpr, IDS_STRING29, TEST_TOPIC );

 	//======================================================================
    	TEST_TOPIC = ""Stream 2 with PRON tag"";
	//======================================================================

    // Create stream #2
    hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream2 ); 
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING81,  TEST_TOPIC);  
	
    // Set the default output format
	hr = cpVoice->SetOutput( cpStream2, TRUE);
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING60,  TEST_TOPIC);
	
    // short string pronounced as a long string               
	hr = GetWStrFromRes( IDS_STRING57, szwSpeakStr );
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING83,  TEST_TOPIC);
	
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING13,  TEST_TOPIC);
      
    // Get stream size
	hr = cpStream2->Stat( &Stat, STATFLAG_NONAME );
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING90, TEST_TOPIC );

	cSamples2 = (ULONG)Stat.cbSize.QuadPart / sizeof(short);
    CHECKASSERTGOTOIdEx((cSamples2 != 0), tpr, IDS_STRING29, TEST_TOPIC );
  
    // Now compare the values from the 2 streams
    // Note - check to ensure cSamples2 is at least twice greater than cSamples1.
	CHECKASSERTId((cSamples2> (2 * cSamples1)), tpr, IDS_STRING29);

EXIT:    
    return tpr;
}
//********************************************************************************
TESTPROCAPI t_XMLRate(UINT uMsg, TPPARAM tpParam, LPFUNCTION_TABLE_ENTRY lpFTE) 
{
	//This test Speaks with CONTEXT tag. 

	// Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;
	
	CComPtr<ISpVoice>           cpLocalVoice;

	// Create the SAPI voice
    DOCHECKHRGOTO (hr = cpLocalVoice.CoCreateInstance( CLSID_SpVoice ););

	tpr = t_XMLRate_Test(uMsg, tpParam, lpFTE, cpLocalVoice, false);

EXIT:
	return tpr;
}
//******************************************************************************** 
TESTPROCAPI t_XMLRate_Test(UINT uMsg, 
								 TPPARAM tpParam, 
								 LPFUNCTION_TABLE_ENTRY lpFTE,
								 ISpVoice *cpVoice,
								 bool bCalledByMulti)
{
// This test changes the rate of a TTS engine twice through XML and analyzes the 
// .wav form to make sure a change has occured.

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;
        
    // Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    CComPtr<ISpStream>          cpStream1;
    CComPtr<ISpStream>          cpStream2;
    STATSTG                     Stat;
    ULONG                       cSamples1=0, cSamples2=0;
    WCHAR                       szwSpeakStr[MAX_PATH]=L"""";
    WCHAR                       szwDebug[MAX_PATH]=L"""";
	const char					* TEST_TOPIC = """";

	//======================================================================
    	TEST_TOPIC = ""Initialization"";
	//======================================================================
 
	CSpStreamFormat				NewFmt(SPSF_22kHz16BitMono, &hr);
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING84, TEST_TOPIC );  

	//======================================================================
    	TEST_TOPIC = ""Stream 1 with rate set to -5"";
	//======================================================================
 
    // Create stream #1
    hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream1 ); 
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING81,  TEST_TOPIC);  
	
    // Set the default output format
	hr = cpVoice->SetOutput( cpStream1, TRUE);
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING60,  TEST_TOPIC);

	hr = GetWStrFromRes( IDS_STRING30, szwSpeakStr );
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING83,  TEST_TOPIC);
	
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING13,  TEST_TOPIC);
      
    // Get stream size
	hr = cpStream1->Stat( &Stat, STATFLAG_NONAME );
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING90, TEST_TOPIC );

	cSamples1 = (ULONG)Stat.cbSize.QuadPart / sizeof(short);
    CHECKASSERTGOTOIdEx((cSamples1 != 0), tpr, IDS_STRING32, TEST_TOPIC );

 	//======================================================================
    	TEST_TOPIC = ""Stream 2 with rate set to 5"";
	//======================================================================
    
    // Create stream #2
	hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream2 );
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING81,  TEST_TOPIC); 
        
    // Set the default output format
	hr = cpVoice->SetOutput( cpStream2, TRUE);
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING60,  TEST_TOPIC);

	hr = GetWStrFromRes( IDS_STRING31, szwSpeakStr );
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING83,  TEST_TOPIC);

    hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
   	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING13,  TEST_TOPIC);

    // Get stream size
	hr = cpStream2->Stat( &Stat, STATFLAG_NONAME );
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING90, TEST_TOPIC );

    cSamples2 = (ULONG)Stat.cbSize.QuadPart / sizeof(WCHAR);
    CHECKASSERTGOTOIdEx((cSamples2 != 0), tpr, IDS_STRING32, TEST_TOPIC );
    
    // Now compare the values from the 2 streams
	// 1. First check ensures low rate has bigger cSamples than higher rate
    // 2. Secondly check ensures cSamples1 and cSamples2 has enough distance
	//
    CHECKASSERTId((cSamples1  > cSamples2 ), tpr, IDS_STRING32);

EXIT:
 
    return tpr;
}
//********************************************************************************
TESTPROCAPI t_XMLVolume(UINT uMsg, TPPARAM tpParam, LPFUNCTION_TABLE_ENTRY lpFTE) 
{
	//This test Speaks with CONTEXT tag. 

	// Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;
	
	CComPtr<ISpVoice>           cpLocalVoice;

	// Create the SAPI voice
    DOCHECKHRGOTO (hr = cpLocalVoice.CoCreateInstance( CLSID_SpVoice ););

	tpr = t_XMLVolume_Test(uMsg, tpParam, lpFTE, cpLocalVoice, false);

EXIT:
	return tpr;
}
//******************************************************************************** 
TESTPROCAPI t_XMLVolume_Test(UINT uMsg, 
								 TPPARAM tpParam, 
								 LPFUNCTION_TABLE_ENTRY lpFTE,
								 ISpVoice *cpVoice,
								 bool bCalledByMulti)
{
// This test changes the volume of a TTS engine twice through XML and analyzes the 
// .wav form to make sure a change has occured.

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;
        
    // Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    CComPtr<ISpStream>          cpStream1;
    CComPtr<ISpStream>          cpStream2;
    ULONG                       cSamples=0;
	ULONG						ulRatio=0;
    WCHAR                       szwSpeakStr[MAX_PATH]=L"""";
	ULONG						totalAmp1 = 0, totalAmp2 = 0;
    WCHAR                       szwDebug[MAX_PATH]=L"""";
	const char					* TEST_TOPIC = """";

    CSpStreamFormat				NewFmt(SPSF_22kHz16BitMono, &hr);
    CHECKHRGOTOId( hr, tpr, IDS_STRING84 );	

	//======================================================================
    	TEST_TOPIC = ""Stream 1 with Volume 100"";
	//======================================================================
 
	//*** First stream with volume set to 100

    // Create stream #1
    hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream1 );
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING81,  TEST_TOPIC);	
        
    // Set the default output format
    hr = cpVoice->SetOutput( cpStream1, TRUE);
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING60,  TEST_TOPIC);	

    hr = GetWStrFromRes( IDS_STRING33, szwSpeakStr );
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING83,  TEST_TOPIC);	
 
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL ); 
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING13,  TEST_TOPIC);	

    LARGE_INTEGER l;
    l.QuadPart = 0;

    // Reset stream to beginning
    hr = cpStream1->Seek( l, SEEK_SET, NULL );
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING79,  TEST_TOPIC);	

	// get the sum of the amplitude from the stream 1
    hr =  GetAmpFromSamples (cpStream1, &totalAmp1 ); 
 	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING82, TEST_TOPIC );	

	//======================================================================
    	TEST_TOPIC = ""Stream 2 with Volume 1"";
	//======================================================================
 	
    //*** Second stream with volume set to 1

    // Create stream #2
    hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream2 );
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING81,  TEST_TOPIC);	
  
    // Set the default output format
    hr = cpVoice->SetOutput( cpStream2, TRUE);
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING60,  TEST_TOPIC);
    
    hr = GetWStrFromRes( IDS_STRING34, szwSpeakStr );
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING83,  TEST_TOPIC);

    hr = cpVoice->Speak( szwSpeakStr,  SPF_IS_XML, NULL ); 
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING13,  TEST_TOPIC);	

    // Reset stream to beginning
    hr = cpStream2->Seek( l, SEEK_SET, NULL );
    CHECKHRGOTOIdEx( hr, tpr, IDS_STRING79,  TEST_TOPIC);

	// get the sum of the amplitude from the stream 1
    hr =  GetAmpFromSamples (cpStream2, &totalAmp2 ); 
 	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING82, TEST_TOPIC );	

	//Make sure the amplitudes of stream1 and stream2 are greater than 0 
	CHECKASSERTGOTOId( (totalAmp1 > 0), tpr, IDS_STRING35 );		
	CHECKASSERTGOTOId( (totalAmp2 > 0), tpr, IDS_STRING35 );
		
    // Note - The test assumes that the overall amplitude from stream 1 will
	//		  be at least 3 times that of stream 2
     
	ulRatio = totalAmp1/totalAmp2;
        
	CHECKASSERTId( (ulRatio>1), tpr, IDS_STRING35 );
 
EXIT:
    
    return tpr;
}

//********************************************************************************
TESTPROCAPI t_XMLPitch(UINT uMsg, TPPARAM tpParam, LPFUNCTION_TABLE_ENTRY lpFTE) 
{
	//This test Speaks with CONTEXT tag. 

	// Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;
	
	CComPtr<ISpVoice>           cpLocalVoice;

	// Create the SAPI voice
    DOCHECKHRGOTO (hr = cpLocalVoice.CoCreateInstance( CLSID_SpVoice ););

	tpr = t_XMLPitch_Test(uMsg, tpParam, lpFTE, cpLocalVoice, false);

EXIT:
	return tpr;
}
//******************************************************************************** 
TESTPROCAPI t_XMLPitch_Test(UINT uMsg, 
								 TPPARAM tpParam, 
								 LPFUNCTION_TABLE_ENTRY lpFTE,
								 ISpVoice *cpVoice,
								 bool bCalledByMulti)
{
// This test changes the pitch of a TTS engine twice through XML and analyzes the 
// .wav form to make sure a change has occured. It first speaks a sentence at 
// normal pitch and finds the average of the positive amplitude. The average positive
// amplitude is then used as a threshhold above which peak detection is measured. It
// is expected that a higher pitch wav form will have more peaks above the threshhold
// then a lower pitch wav form will.
// NOTE - wav samples are run through a low frequency filter to generate a smother
// wav form.

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;
        
    // Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }


    CComPtr<ISpStream>          cpStream1;
    CComPtr<ISpStream>          cpStream2;
	STATSTG                     Stat;
    ULONG                       cSamples = 0;
    WCHAR                       szwSpeakStr[MAX_PATH]=L"""";
    WCHAR                       szwDebug[MAX_PATH]=L"""";
	ULONG						freq1=0, freq2=0;
	float						fratio = 0;
	const char					* TEST_TOPIC = """";

	//======================================================================
    	TEST_TOPIC = ""Initialization"";
	//======================================================================
 
	CSpStreamFormat				NewFmt(SPSF_22kHz16BitMono, &hr); //sampFreq = 22050;
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING84, TEST_TOPIC );  

	hr = cpVoice->SetVolume( 100 );
	CHECKHRIdEx( hr, tpr, IDS_STRING18,  TEST_TOPIC);

	hr = cpVoice->SetRate( 0 );
	CHECKHRIdEx( hr, tpr, IDS_STRING16,  TEST_TOPIC);  

	//======================================================================
    	TEST_TOPIC = ""Stream # 1 with low pitch"";
	//======================================================================

    // Create stream #1  with low pitch 
    hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream1 );
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING81, TEST_TOPIC );   
       
    // Set the default output format
    hr = cpVoice->SetOutput( cpStream1, TRUE);
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING60, TEST_TOPIC );

	hr = GetWStrFromRes( IDS_STRING37, szwSpeakStr );
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING83, TEST_TOPIC );  

    hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING13, TEST_TOPIC );

    // Get stream size
	hr = cpStream1->Stat( &Stat, STATFLAG_NONAME );
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING90, TEST_TOPIC );

	cSamples = (ULONG)Stat.cbSize.QuadPart / sizeof(short);
    CHECKASSERTGOTOIdEx((cSamples != 0), tpr, IDS_STRING39, TEST_TOPIC );
   
	LARGE_INTEGER l;
    l.QuadPart = 0;

    // Reset stream to beginning
	hr = cpStream1->Seek( l, SEEK_SET, NULL );
   	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING79, TEST_TOPIC );

	hr = GetFreqFromSamples (cpStream1, 22050, cSamples, &freq1);
  	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING91, TEST_TOPIC );

	//======================================================================
    	TEST_TOPIC = ""Stream # 2 with high pitch"";
	//======================================================================

    // Create stream #2 with high pitch
    hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream2 );
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING81, TEST_TOPIC );   
      
    // Set the default output format
    hr = cpVoice->SetOutput( cpStream2, TRUE);
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING60, TEST_TOPIC );
    
    hr = GetWStrFromRes( IDS_STRING38, szwSpeakStr );
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING83, TEST_TOPIC );  

    hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
   	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING13, TEST_TOPIC ); 

    // Get stream size
    hr = cpStream2->Stat( &Stat, STATFLAG_NONAME );
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING90, TEST_TOPIC );

	cSamples = (ULONG)Stat.cbSize.QuadPart / sizeof(SHORT);
    CHECKASSERTGOTOIdEx((cSamples != 0), tpr, IDS_STRING39, TEST_TOPIC );  
    
    // Reset stream to beginning
    hr = cpStream2->Seek( l, SEEK_SET, NULL );
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING79, TEST_TOPIC );
	
	hr = GetFreqFromSamples (cpStream2, 22050, cSamples, &freq2);
  	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING91, TEST_TOPIC );

	{
		//debug 
		TCHAR    szDInfo[MAX_PATH]=TEXT("""");
		_stprintf( szDInfo, TEXT(""freq1 = %d, freq2 = %d""), freq1, freq2 );
		g_pKato->Comment(10, szDInfo);
	}

	// Now compare the frequencies of the audio output streams
    // Note - Average freqencey with high pitch has at least 1.2 times higher than 
	// low pitch
	CHECKASSERTId((freq1 > 0), tpr, IDS_STRING39 ); 
	CHECKASSERTId((freq2 > 0), tpr, IDS_STRING39 ); 
	fratio = (float)freq2/(float)freq1;
	CHECKASSERTId((fratio > 1.2 ), tpr, IDS_STRING39 ); 
 
EXIT:
    
    return tpr;
}

//***************************************************************************************
TESTPROCAPI t_XMLNonSapiTagsTest(UINT uMsg, TPPARAM tpParam, LPFUNCTION_TABLE_ENTRY lpFTE) 
{
	//This test Speaks with an arbitrary non-sapi tag. In this case, SAPI supplys the
	//SPVA_ParseUnknownTag text fragment state to the tts engine.

	// Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;
    CComPtr<ISpVoice>           cpVoice; 
	CComPtr<ISpStream>          cpStream;
	WCHAR                       szwSpeakStr[MAX_PATH]=L"""";

	CSpStreamFormat				NewFmt(SPSF_22kHz16BitMono, &hr);
	CHECKHRGOTOId(hr, tpr, IDS_STRING84);  

	//create a SAPI voice
	hr = cpVoice.CoCreateInstance( CLSID_SpVoice ); 
	CHECKHRGOTOId( hr, tpr, IDS_STRING85 );	

	hr = GetWStrFromRes( IDS_STRING67, szwSpeakStr );
	CHECKHRGOTOId(hr, tpr, IDS_STRING83);  

	// Create a generic stream to send the audio data to so we don't have to listen to it
    hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream );
    CHECKHRGOTOId(hr, tpr, IDS_STRING81 ); 
        
    // Set the default output format
    hr = cpVoice->SetOutput( cpStream, TRUE);
    CHECKHRGOTOId(hr, tpr, IDS_STRING60 ); 

    hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRId(hr, tpr, IDS_STRING13);
		
EXIT:
    return tpr;
}

//*********************************************************************************
TESTPROCAPI t_XMLEmphTest(UINT uMsg, TPPARAM tpParam, LPFUNCTION_TABLE_ENTRY lpFTE) 
{
	//This test Speaks with EMPH tag. Test uses Pitch, Rate and volume to measure
	//the output streams. The test assume that the output stream of EMPH is different
	//in Rate, or Volume, or pitch from one without emph. If engines implement EMPH in
	//other different way, rather than use pitch, rate, or volume, then this test will
	//fail. And the test result will be ""Not Supported"".

	// Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_SUPPORTED;
    CComPtr<ISpVoice>           cpVoice;   
    CComPtr<ISpStream>          cpStream1;
    CComPtr<ISpStream>          cpStream2;
	ULONG						ulRatio=0;
	STATSTG                     Stat;
    ULONG                       cSamples1=0, cSamples2=0;
    WCHAR                       szwSpeakStr[MAX_PATH]=L"""";
	ULONG						totalAmp1 = 0, totalAmp2 = 0;
	ULONG						freq1=0, freq2=0;

	const char					* TEST_TOPIC = """";

	//======================================================================
    	TEST_TOPIC = ""Initialization"";
	//======================================================================
 
    CSpStreamFormat				NewFmt(SPSF_22kHz16BitMono, &hr);
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING84, TEST_TOPIC );  

	hr = GetWStrFromRes( IDS_STRING69, szwSpeakStr );
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING83, TEST_TOPIC );  

    // Create the SAPI voice
    hr = cpVoice.CoCreateInstance( CLSID_SpVoice ); 
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING85, TEST_TOPIC );  

	//======================================================================
    	TEST_TOPIC = ""Stream #1 without Emph"";
	//======================================================================
 
    // Create stream #1
    hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream1 );
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING81, TEST_TOPIC );   
        
    // Set the output format
    hr = cpVoice->SetOutput( cpStream1, TRUE);
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING60, TEST_TOPIC );

	//no Emph
    hr = GetWStrFromRes( IDS_STRING68, szwSpeakStr );
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING83, TEST_TOPIC );

    hr = cpVoice->Speak( szwSpeakStr,  SPF_IS_XML, NULL ); 
   	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING13, TEST_TOPIC );
      
	// Get stream size
    hr = cpStream1->Stat( &Stat, STATFLAG_NONAME ); 
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING90,  TEST_TOPIC);

	cSamples1 = (ULONG)Stat.cbSize.QuadPart / sizeof(SHORT);

    LARGE_INTEGER l;
    l.QuadPart = 0;

    // Reset stream to beginning
    hr = cpStream1->Seek( l, SEEK_SET, NULL );
 	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING79, TEST_TOPIC );

	// get the sum of the amplitude from the stream 1
    hr =  GetAmpFromSamples (cpStream1, &totalAmp1 ); 
 	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING82, TEST_TOPIC );	

	// Reset stream to beginning again
    hr = cpStream1->Seek( l, SEEK_SET, NULL );
 	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING79, TEST_TOPIC );

	//get frequency
	hr = GetFreqFromSamples (cpStream1, 22050, cSamples1, &freq1);
  	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING91, TEST_TOPIC );

	//======================================================================
    	TEST_TOPIC = ""Stream #2 with Emph"";
	//======================================================================
 
    // Create stream #2
    hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream2 );
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING81, TEST_TOPIC );   
        
    // Set the output format
    hr = cpVoice->SetOutput( cpStream2, TRUE);
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING60, TEST_TOPIC );	

    GetWStrFromRes( IDS_STRING69, szwSpeakStr );
    hr = cpVoice->Speak( szwSpeakStr,  SPF_IS_XML, NULL ); 
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING13, TEST_TOPIC );	
    
	 // Get stream size
    hr = cpStream2->Stat( &Stat, STATFLAG_NONAME ); 
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING90,  TEST_TOPIC);

	cSamples2 = (ULONG)Stat.cbSize.QuadPart / sizeof(SHORT);

    // Reset stream to beginning  
    hr = cpStream2->Seek( l, SEEK_SET, NULL );   
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING79, TEST_TOPIC );	

	// get the sum of the amplitude from the stream 2
    hr =  GetAmpFromSamples (cpStream2, &totalAmp2 ); 
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING82 , TEST_TOPIC );	

	// Reset stream to beginning again
    hr = cpStream2->Seek( l, SEEK_SET, NULL );
 	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING79, TEST_TOPIC );

	hr = GetFreqFromSamples (cpStream2, 22050, cSamples2, &freq2);
  	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING91, TEST_TOPIC );

	//Compare the two streams by Pitch, volume, and Rate.
	//The output streams should be different in pitch, or volume, or Rate.

	//Rate measurement
 
	CHECKISSUPPORTEDId( (cSamples2 > 0), tpr, IDS_STRING70 );		
	CHECKISSUPPORTEDId( (cSamples1 > 0), tpr, IDS_STRING70 );

	//Volume measurement
	CHECKISSUPPORTEDId( (totalAmp1 > 0), tpr, IDS_STRING70 );		
	CHECKISSUPPORTEDId( (totalAmp2 > 0), tpr, IDS_STRING70 );		 

	// Pitch measurement
	CHECKISSUPPORTEDId( (freq2 > 0), tpr, IDS_STRING70 );		
	CHECKISSUPPORTEDId( (freq1 > 0), tpr, IDS_STRING70 );

	CHECKISSUPPORTEDId( (freq2 != freq1 ) || (cSamples2 != cSamples1 ) || (totalAmp2 != totalAmp1) , tpr, IDS_STRING70 );

EXIT:      
	return tpr;
}

//********************************************************************************
TESTPROCAPI t_XMLContext(UINT uMsg, TPPARAM tpParam, LPFUNCTION_TABLE_ENTRY lpFTE) 
{
	//This test Speaks with CONTEXT tag. 

	// Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;
	
	CComPtr<ISpVoice>           cpLocalVoice;

	// Create the SAPI voice
    DOCHECKHRGOTO (hr = cpLocalVoice.CoCreateInstance( CLSID_SpVoice ););

	tpr = t_XMLContext_Test(uMsg, tpParam, lpFTE, cpLocalVoice, false);

EXIT:
	return tpr;
}

//********************************************************************************
TESTPROCAPI t_XMLContext_Test(UINT uMsg, 
								 TPPARAM tpParam, 
								 LPFUNCTION_TABLE_ENTRY lpFTE,
								 ISpVoice *cpVoice,
								 bool bCalledByMulti) 
{
	//This test Speaks with CONTEXT tag. 

	// Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;

	CComPtr<ISpStream>			cpStream;
	const char					* TEST_TOPIC = """";
	WCHAR						szwSpeakStr[1024]=L"""";

	//======================================================================
    	TEST_TOPIC = ""Context: Initialization"";
	//======================================================================

    CSpStreamFormat				NewFmt(SPSF_22kHz16BitMono, &hr);
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING84, TEST_TOPIC );  

	// Create stream 
    hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream );
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING81, TEST_TOPIC );   
        
    // Set the output format
    hr = cpVoice->SetOutput( cpStream, TRUE);
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING60, TEST_TOPIC );	

	//======================================================================
    	TEST_TOPIC = ""Context: Test#1a - date_mdy"";
	//======================================================================

	//Date in mdy format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING99, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );	

	//======================================================================
    	TEST_TOPIC = ""Context: Test#1b - date_dmy"";
	//======================================================================

	//Date in date_dmy format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING100, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );	

	//======================================================================
    	TEST_TOPIC = ""Context: Test#1c - date_ymd"";
	//======================================================================

	//Date in date_ymd format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING101, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );	

	//======================================================================
    	TEST_TOPIC = ""Context: Test#2a - date_ym"";
	//======================================================================

	//Date in date_ym format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING102, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );

	//======================================================================
    	TEST_TOPIC = ""Context: Test#2b - date_my"";
	//======================================================================

	//Date in date_my format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING103, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );

	//======================================================================
    	TEST_TOPIC = ""Context: Test#2c - date_dm"";
	//======================================================================

	//Date in date_dm format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING104, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );

	//======================================================================
    	TEST_TOPIC = ""Context: Test#2d - date_md"";
	//======================================================================

	//Date in date_md format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING105, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );

	//======================================================================
    	TEST_TOPIC = ""Context: Test#2e - date_md"";
	//======================================================================

	//Date in date_year format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING106, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );	

	//======================================================================
    	TEST_TOPIC = ""Context: Test#3 - time"";
	//======================================================================

	//Time in time_hms format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING107, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );
  
	//======================================================================
    	TEST_TOPIC = ""Context: Test#4a - number_cardinal"";
	//======================================================================

	//Number in number_cardinal format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING108, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );

	//======================================================================
    	TEST_TOPIC = ""Context: Test#4b - number_digit"";
	//======================================================================

	//Number in number_digit format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING109, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );
	
	//======================================================================
    	TEST_TOPIC = ""Context: Test#4c - number_fraction"";
	//======================================================================

	//Number in number_fraction format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING110, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );

	//======================================================================
    	TEST_TOPIC = ""Context: Test#4d - number_decimal"";
	//======================================================================

	//Number in number_decimal format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING111, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );	

	//======================================================================
    	TEST_TOPIC = ""Context: Test#5 - phone_number"";
	//======================================================================

	// phone_number format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING112, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );

	//======================================================================
    	TEST_TOPIC = ""Context: Test#6 - currency"";
	//======================================================================

	// currency format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING113, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );

	//======================================================================
    	TEST_TOPIC = ""Context: Test#7 - web"";
	//======================================================================

	// web format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING114, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );
	
	//======================================================================
    	TEST_TOPIC = ""Context: Test#8 - email_address"";
	//======================================================================

	// email address format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING115, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );	

	//======================================================================
    	TEST_TOPIC = ""Context: Test#9 - address"";
	//======================================================================

	// address format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING116, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );

	//======================================================================
    	TEST_TOPIC = ""Context: Test#10 - address_postal"";
	//======================================================================

	// address postal format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING117, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );

	//======================================================================
    	TEST_TOPIC = ""Context: Test#11 - my context tests"";
	//======================================================================
	// 
	// ms context format
	DOCHECKHRGOTO( hr = GetWStrFromRes( IDS_STRING118, szwSpeakStr ););
	hr = cpVoice->Speak( szwSpeakStr, SPF_IS_XML, NULL );
	CHECKHRIdEx( hr, tpr, IDS_STRING13, TEST_TOPIC );

EXIT:
	return tpr;
}

//*************************************************************************************
TESTPROCAPI t_XMLPartOfSpTest(UINT uMsg, TPPARAM tpParam, LPFUNCTION_TABLE_ENTRY lpFTE) 
{
	//This test is trying to Speak with PartOfSP tags. 
	//Currently it is in the feature list. The test result will be ""Supported""
	// or ""Unsupported"".
	
	// Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }

    HRESULT							hr = S_OK;
	int								tpr = TPR_SUPPORTED;

    CComPtr<ISpVoice>				cpVoice;    
    CComPtr<ISpContainerLexicon>	cpConlexicon;
	LANGID                          LangID;
    ULONG							cSamples1=0, cSamples2=0;
	WCHAR							szwSpeakStrNoun[MAX_PATH]=L"""";
	WCHAR							szwSpeakStrVerb[MAX_PATH]=L"""";
	WCHAR							szNewWord[MAX_PATH]=L"""";
	WCHAR							szwSpeakstr[MAX_PATH]=L"""";
	WCHAR							szVPronunciation[MAX_PATH]=L"""";
	WCHAR							szNPronunciation[MAX_PATH]=L"""";

	const char						* TEST_TOPIC = """";

	//======================================================================
    	TEST_TOPIC = ""Initialization"";
	//======================================================================
 
	hr = GetWStrFromRes( IDS_STRING76, szNewWord );
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING83, TEST_TOPIC);

	DOCHECKHRGOTO( hr = SpGetLanguageIdFromDefaultVoice(&LangID); ); 

	//create a SAPI voice
	hr = cpVoice.CoCreateInstance( CLSID_SpVoice ); 
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING85, TEST_TOPIC );  
	
	hr = cpConlexicon.CoCreateInstance(CLSID_SpLexicon);
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING85, TEST_TOPIC );  

	//======================================================================
    	TEST_TOPIC = ""Add verb pronunciation to a word"";
	//======================================================================

	hr = GetWStrFromRes( IDS_STRING48, szwSpeakStrVerb );
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING83, TEST_TOPIC);

	//get phoneid
	hr = TTSSymToPhoneId ( LangID, szwSpeakStrVerb, szVPronunciation);
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING77, TEST_TOPIC );  

	hr = cpConlexicon->RemovePronunciation(szNewWord, LangID, SPPS_Verb, szVPronunciation);
	CHECKHRALTGOTOIdEx( hr, SPERR_NOT_IN_LEX,  tpr, IDS_STRING89, TEST_TOPIC);

	//Assign the verb pronunciation of the new word
    hr = cpConlexicon->AddPronunciation(szNewWord, LangID, SPPS_Verb, szVPronunciation);
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING87, TEST_TOPIC );  
	
	//======================================================================
    	TEST_TOPIC = ""Add noun pronunciation to a word"";
	//======================================================================

	hr = GetWStrFromRes( IDS_STRING52, szwSpeakStrNoun );
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING83, TEST_TOPIC);

	//get phoneid 
	hr = TTSSymToPhoneId ( LangID, szwSpeakStrNoun, szNPronunciation);
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING77, TEST_TOPIC );  
	
	hr = cpConlexicon->RemovePronunciation(szNewWord, LangID, SPPS_Noun, szNPronunciation);
	CHECKHRALTGOTOIdEx( hr, SPERR_NOT_IN_LEX,  tpr, IDS_STRING89, TEST_TOPIC);

	//add the word in noun pronunciation  to Lexicon
    hr = cpConlexicon->AddPronunciation(szNewWord, LangID, SPPS_Noun, szNPronunciation);
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING87, TEST_TOPIC );  

	//======================================================================
    	TEST_TOPIC = ""Speak two streams with PartOfSp"";
	//======================================================================

	//speak two streams
	hr = GetWStrFromRes( IDS_STRING49, szwSpeakstr );
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING83, TEST_TOPIC);

	swprintf( szwSpeakStrNoun, szwSpeakstr, szNewWord );

	hr = GetWStrFromRes( IDS_STRING50, szwSpeakstr );
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING83, TEST_TOPIC);

	swprintf( szwSpeakStrVerb, szwSpeakstr, szNewWord );

	hr = t_SpeakTwoStreams(cpVoice, szwSpeakStrNoun, szwSpeakStrVerb, cSamples1, cSamples2);
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING88, TEST_TOPIC);

	hr = cpConlexicon->RemovePronunciation(szNewWord, LangID, SPPS_Noun, szNPronunciation);
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING89, TEST_TOPIC);

	hr = cpConlexicon->RemovePronunciation(szNewWord, LangID, SPPS_Verb, szVPronunciation);
	CHECKHRGOTOIdEx( hr, tpr, IDS_STRING89, TEST_TOPIC);

	CHECKISSUPPORTEDId((cSamples1 > 0 ), tpr, IDS_STRING51);
   	CHECKISSUPPORTEDId((cSamples2 > 0 ), tpr, IDS_STRING51);

	//This test assumes that second stream should be twice shorter than the first one. 
	CHECKISSUPPORTEDId( ( 2* cSamples2 < cSamples1), tpr, IDS_STRING51);

EXIT:
    return tpr;
}

//**************************************************************************************
TESTPROCAPI t_XMLSAPIMarkup_Test(UINT uMsg, 
								 TPPARAM tpParam, 
								 LPFUNCTION_TABLE_ENTRY lpFTE,
								 ISpVoice *cpVoice,
								 bool bCalledByMulti)
{
	// This test expects TTS engines to handle all possible spec'ed out combinations 
	//of the XML tags.


    HRESULT                     hr = S_OK;
    int                         tpr = TPR_PASS;
        
    // Message check
    if (uMsg != TPM_EXECUTE) 
    { 
        return TPR_NOT_HANDLED;
    }
    else if(lpFTE) // called by SpComp directly. It is NULL in multiInstance test.
    {
        srand(reinterpret_cast<LPTPS_EXECUTE>(tpParam)->dwRandomSeed);
    }

    CComPtr<ISpStream>          cpStream;
  
    WCHAR                       szwSpeakStr[MAX_PATH]=L"""";
    WCHAR                       szwXMLString[MAX_PATH]=L"""";  
	const char					* TEST_TOPIC = """";

    CSpStreamFormat				NewFmt(SPSF_22kHz16BitMono, &hr);
	CHECKHRGOTOId(hr, tpr, IDS_STRING84);  

	//======================================================================
    	TEST_TOPIC = ""Markup Test: Initialization"";
	//======================================================================

    // Create a generic stream to send the audio data to so we don't have to listen to it
    hr = SPCreateStreamOnHGlobal( NULL, true, NewFmt.FormatId(), NewFmt.WaveFormatExPtr(), &cpStream );
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING81, TEST_TOPIC);
        
    // Set the default output format
    hr = cpVoice->SetOutput( cpStream, TRUE);
    CHECKHRGOTOIdEx(hr, tpr, IDS_STRING60, TEST_TOPIC);

	//======================================================================
    	TEST_TOPIC = ""Markup Test: Bookmark"";
	//======================================================================

	// Bookmark
	DOCHECKHRGOTO (hr = GetWStrFromRes( IDS_STRING8, szwXMLString ););
    hr = cpVoice->Speak( szwXMLString,  SPF_ASYNC | SPF_IS_XML, NULL );
	CHECKHRIdEx(hr, tpr, IDS_STRING13, TEST_TOPIC);

	//======================================================================
    	TEST_TOPIC = ""Markup Test: Silence"";
	//======================================================================

    // Silence
    DOCHECKHRGOTO (hr = GetWStrFromRes( IDS_STRING41, szwSpeakStr ););
    swprintf( szwXMLString, szwSpeakStr, GET_RANDOM(0, 2000) );
    hr = cpVoice->Speak( szwXMLString,  SPF_ASYNC | SPF_IS_XML, NULL );
	CHECKHRIdEx(hr, tpr, IDS_STRING13, TEST_TOPIC);
  
	//======================================================================
    	TEST_TOPIC = ""Markup Test: Spell"";
	//======================================================================

    // Spell    
    DOCHECKHRGOTO (hr = GetWStrFromRes( IDS_STRING27, szwXMLString ););
    hr = cpVoice->Speak( szwXMLString,  SPF_ASYNC | SPF_IS_XML, NULL );
	CHECKHRIdEx(hr, tpr, IDS_STRING13, TEST_TOPIC);
    
	//======================================================================
    	TEST_TOPIC = ""Markup Test: Pron"";
	//======================================================================

	// Pronounce
        
	DOCHECKHRGOTO (hr = GetWStrFromRes( IDS_STRING43, szwXMLString ););
    hr = cpVoice->Speak( szwXMLString,  SPF_ASYNC | SPF_IS_XML, NULL );
	CHECKHRIdEx(hr, tpr, IDS_STRING13, TEST_TOPIC);

	//======================================================================
    	TEST_TOPIC = ""Markup Test: Rate"";
	//======================================================================

    // Rate
    DOCHECKHRGOTO (hr = GetWStrFromRes( IDS_STRING44, szwSpeakStr ););
    swprintf( szwXMLString, szwSpeakStr, GET_RANDOM(-10, 10) );
    hr = cpVoice->Speak( szwXMLString,  SPF_ASYNC | SPF_IS_XML, NULL );
	CHECKHRIdEx(hr, tpr, IDS_STRING13, TEST_TOPIC);
	//======================================================================
    	TEST_TOPIC = ""Markup Test: Volume"";
	//======================================================================

    // Volume
    DOCHECKHRGOTO (hr = GetWStrFromRes( IDS_STRING45, szwSpeakStr ););
    swprintf( szwXMLString, szwSpeakStr, GET_RANDOM(0, 100) );
    hr = cpVoice->Speak( szwXMLString,  SPF_ASYNC | SPF_IS_XML, NULL );
	CHECKHRIdEx(hr, tpr, IDS_STRING13, TEST_TOPIC);

	//======================================================================
    	TEST_TOPIC = ""Markup Test: Pitch"";
	//======================================================================

    // Pitch
    DOCHECKHRGOTO (hr = GetWStrFromRes( IDS_STRING46, szwSpeakStr ););
    swprintf( szwXMLString, szwSpeakStr, GET_RANDOM(-10, 10) );
    hr = cpVoice->Speak( szwXMLString,  SPF_ASYNC | SPF_IS_XML, NULL );
	CHECKHRIdEx(hr, tpr, IDS_STRING13, TEST_TOPIC);

	//======================================================================
    	TEST_TOPIC = ""Markup Test: Non-Sapi"";
	//======================================================================
	//Non-Sapi
	DOCHECKHRGOTO (hr = GetWStrFromRes( IDS_STRING67, szwXMLString ););
	hr = cpVoice->Speak( szwXMLString,  SPF_ASYNC | SPF_IS_XML, NULL );
	CHECKHRIdEx(hr, tpr, IDS_STRING13, TEST_TOPIC);
	
	//======================================================================
    	TEST_TOPIC = ""Markup Test: Context"";
	//======================================================================

	//Context
	DOCHECKHRGOTO (hr = GetWStrFromRes( IDS_STRING119, szwXMLString ););
	hr = cpVoice->Speak( szwXMLString,  SPF_ASYNC | SPF_IS_XML, NULL );
	CHECKHRIdEx(hr, tpr, IDS_STRING13, TEST_TOPIC);

	hr = cpVoice->WaitUntilDone( TTS_WAITTIME );
	CHECKHRGOTOIdEx(hr, tpr, IDS_STRING61, "" in t_XMLBookmarkTest"");


EXIT:
    return tpr;
}



",16223,True,4106.537424526916,median
"/******************************************************************************
 * The MIT License (MIT)
 *
 * Copyright (c) 2021-2022 Baldur Karlsson
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the ""Software""), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 ******************************************************************************/

#include ""dxbc_bytecode.h""
#include ""core/settings.h""
#include ""dxbc_bytecode_ops.h""

#include ""driver/ihv/nv/nvapi_wrapper.h""

RDOC_EXTERN_CONFIG(bool, DXBC_Disassembly_FriendlyNaming);

namespace DXBCBytecode
{
namespace AMDInstruction
{
// ha ha these are different :(
enum class DX11Op
{
  Readfirstlane = 0x01,
  Readlane = 0x02,
  LaneId = 0x03,
  Swizzle = 0x04,
  Ballot = 0x05,
  MBCnt = 0x06,
  Min3U = 0x08,
  Min3F = 0x09,
  Med3U = 0x0a,
  Med3F = 0x0b,
  Max3U = 0x0c,
  Max3F = 0x0d,
  BaryCoord = 0x0e,
  VtxParam = 0x0f,
  ViewportIndex = 0x10,
  RtArraySlice = 0x11,
  WaveReduce = 0x12,
  WaveScan = 0x13,
  DrawIndex = 0x17,
  AtomicU64 = 0x18,
  GetWaveSize = 0x19,
  BaseInstance = 0x1a,
  BaseVertex = 0x1b,
};

enum class DX12Op
{
  Readfirstlane = 0x01,
  Readlane = 0x02,
  LaneId = 0x03,
  Swizzle = 0x04,
  Ballot = 0x05,
  MBCnt = 0x06,
  Min3U = 0x07,
  Min3F = 0x08,
  Med3U = 0x09,
  Med3F = 0x0a,
  Max3U = 0x0b,
  Max3F = 0x0c,
  BaryCoord = 0x0d,
  VtxParam = 0x0e,
  ViewportIndex = 0x10,    // DX11 only
  RtArraySlice = 0x11,     // DX11 only
  WaveReduce = 0x12,
  WaveScan = 0x13,
  LoadDwAtAddr = 0x14,
  DrawIndex = 0x17,
  AtomicU64 = 0x18,
  GetWaveSize = 0x19,
  BaseInstance = 0x1a,
  BaseVertex = 0x1b,
};

DX12Op convert(DX11Op op)
{
  switch(op)
  {
    // convert opcodes that don't match up
    case DX11Op::Min3U: return DX12Op::Min3U;
    case DX11Op::Min3F: return DX12Op::Min3F;
    case DX11Op::Med3U: return DX12Op::Med3U;
    case DX11Op::Med3F: return DX12Op::Med3F;
    case DX11Op::Max3U: return DX12Op::Max3U;
    case DX11Op::Max3F: return DX12Op::Max3F;
    case DX11Op::BaryCoord: return DX12Op::BaryCoord;
    case DX11Op::VtxParam:
      return DX12Op::VtxParam;
    // others match up exactly
    default: return DX12Op(op);
  }
}

enum BaryInterpMode
{
  LinearCenter = 1,
  LinearCentroid = 2,
  LinearSample = 3,
  PerspCenter = 4,
  PerspCentroid = 5,
  PerspSample = 6,
  PerspPullModel = 7,
};

enum SwizzleMask
{
  SwapX1 = 0x041f,
  SwapX2 = 0x081f,
  SwapX4 = 0x101f,
  SwapX8 = 0x201f,
  SwapX16 = 0x401f,
  ReverseX4 = 0x0c1f,
  ReverseX8 = 0x1c1f,
  ReverseX16 = 0x3c1f,
  ReverseX32 = 0x7c1f,
  BCastX2 = 0x003e,
  BCastX4 = 0x003c,
  BCastX8 = 0x0038,
  BCastX16 = 0x0030,
  BCastX32 = 0x0020,
};

enum AMDAtomic
{
  Min = 0x01,
  Max = 0x02,
  And = 0x03,
  Or = 0x04,
  Xor = 0x05,
  Add = 0x06,
  Xchg = 0x07,
  CmpXchg = 0x08,
};

VendorAtomicOp convert(AMDAtomic op)
{
  switch(op)
  {
    case Min: return ATOMIC_OP_MIN;
    case Max: return ATOMIC_OP_MAX;
    case And: return ATOMIC_OP_AND;
    case Or: return ATOMIC_OP_OR;
    case Xor: return ATOMIC_OP_XOR;
    case Add: return ATOMIC_OP_ADD;
    case Xchg: return ATOMIC_OP_SWAP;
    case CmpXchg: return ATOMIC_OP_CAS;
    default: return ATOMIC_OP_NONE;
  }
}

static MaskedElement<uint32_t, 0xF0000000> Magic;
static MaskedElement<uint32_t, 0x03000000> Phase;
static MaskedElement<uint32_t, 0x00FFFF00> Data;
static MaskedElement<BaryInterpMode, 0x00FFFF00> BaryInterp;
static MaskedElement<SwizzleMask, 0x00FFFF00> SwizzleOp;
static MaskedElement<DX11Op, 0x000000FF> Opcode11;
static MaskedElement<DX12Op, 0x000000FF> Opcode12;

static MaskedElement<uint8_t, 0x00018000> VtxParamComponent;
static MaskedElement<uint32_t, 0x00001F00> VtxParamParameter;
static MaskedElement<uint32_t, 0x00006000> VtxParamVertex;

static MaskedElement<uint8_t, 0x0000FF00> WaveOp;
static MaskedElement<uint32_t, 0x00FF0000> WaveOpFlags;

static MaskedElement<AMDAtomic, 0x0000FF00> AtomicOp;
};

void Program::PostprocessVendorExtensions()
{
  const bool friendly = DXBC_Disassembly_FriendlyNaming();

  uint32_t magicID = ~0U;

  for(size_t i = 0; i < m_Declarations.size(); i++)
  {
    const Declaration &decl = m_Declarations[i];
    if((decl.operand.indices.size() == 1 && decl.operand.indices[0].index == m_ShaderExt.second) ||
       (decl.operand.indices.size() == 3 && decl.operand.indices[1].index == m_ShaderExt.second &&
        decl.space == m_ShaderExt.first))
    {
      magicID = (uint32_t)decl.operand.indices[0].index;
      m_Declarations.erase(i);
      break;
    }
  }

  // now we know the UAV, iterate the instructions looking for patterns to replace.
  //
  // AMD is nice and easy. Every instruction works on a scalar (vector versions repeat for each
  // component) and is encoded into a single InterlockedCompareExchange on the UAV.
  // So we can simply replace them in-place by decoding.
  //
  // NV's are not as nice. They are demarcated by IncrementCounter on the UAV so we know we'll see
  // a linear stream without re-ordering, but they *can* be intermixed with other non-intrinsic
  // instructions. Parameters and data are set by writing to specific offsets within the structure
  //
  // There are two types:
  //
  // Simpler, instructions that work purely on vars and not on resources. Shuffle/ballot/etc
  //
  // These come in the form:
  // index = magicUAV.IncrementCounter()
  // set params and opcode by writing to magicUAV[index].member...
  // retval = magicUAV.IncrementCounter()
  // [optional (see below): retval2 = magicUAV.IncrementCounter()]
  //
  // This type of operand returns the result with the closing IncrementCounter(). There could be
  // multiple results, so numOutputs is set before any, and then that many IncrementCounter() are
  // emitted with each result.
  //
  // More complex, instructions that use UAVs. Mostly atomics
  //
  // index1 = magicUAV.IncrementCounter()
  // magicUAV[index1].markUAV = 1;
  // userUAV[index1] = 0; // or some variation of such
  // index2 = magicUAV.IncrementCounter()
  // set params and opcode as above in magicUAV[index2].member...
  // retval = magicUAV[index2].dst
  //
  // Also note that if the shader doesn't use the return result of an atomic, the dst may never be
  // read!
  //
  // The difficulty then is distinguishing between the two and knowing where the boundaries are.
  // We do this with a simple state machine tracking where we are in an opcode:
  //
  //         +----------> Nothing
  //         |              v
  //         |              |
  //         |      IncrementCounter()
  // Emit instruction       |
  //         |              v
  //         |         Instruction >--write markUAV---> UAV instruction header
  //         |              v                           (wait for other UAV write)
  //         |              |                             v
  //         |              |                             |
  //         |         write opcode    ]                  |
  //         |              |          ]                  |
  //         |              v          ] simple           |
  //         |        Instruction Body ] case             |
  //         |              v          ]                  |
  //         |              |          ]                  |
  //         |      IncrementCounter() ]                  |
  //         |              |                             |
  //         +----<---------+                             |
  //         |                                    IncrementCounter()
  //         |                                            |
  //         |    UAV instruction body <------------------+
  //         |              v
  //         |              |
  //         |         write opcode
  //         |              |
  //         +--------------+
  //
  // so most state transitions are marked by an IncrementCounter(). The exceptions being
  // Instruction where we wait for a write to either markUAV or opcode to move to either simple
  // instruction body or to the UAV instruction header, and UAV instruction body which leaves
  // when we see an opcode write.
  //
  // We assume that markUAV will be written BEFORE the fake UAV write. It's not entirely clear if
  // this is guaranteed to not be re-ordered but it seems to be true and it's implied that NV's
  // driver relies on this. This simplifies tracking since we can use it as a state transition.
  //
  // We also assume that multiple accesses to the UAV don't overlap. This should be guaranteed by
  // the use of the index from the counter being used for access. However we don't actually check
  // the index itself.
  //
  // all src/dst are uint4, others are all uint

  enum class InstructionState
  {
    // if something goes wrong we enter this state and stop patching
    Broken,

    Nothing,

    // this is a state only used for AMD's UAV atomic op, which takes more parameters and uses the
    // operation phases.
    AMDUAVAtomic,

    // this is the state when we're not sure what type we are. Either markUAV is written, in which
    // case we move to UAVInstructionHeader1, or opcode is written, in which case we move to
    // Instruction1Out. We should see one or the other.
    //
    // FP16 UAV instructions (NV_EXTN_OP_FP16_ATOMIC) that operate on float4 resources have two
    // return values. Unfortunately we can't reliably detect this from the bytecode, so what
    // happens is that when we see opode get written if it's NV_EXTN_OP_FP16_ATOMIC then we jump
    // straight to UAVInstructionBody and re-use the UAV instruction header from last time. We
    // know this MUST be a continuation because otherwise NV_EXTN_OP_FP16_ATOMIC is always
    // preceeded by a UAV instruction header (via markUAV).
    InstructionHeader,
    InstructionBody,
    // we move from Instruction1Out to this state when markUAV is written. The next UAV write is
    // used to determine the 'target' UAV.
    // We then move to header2 so we don't consume any other UAV writes.
    UAVInstructionHeader1,
    // here we do nothing but sit and wait for the IncrementCounter() so we can move to the UAV
    // body state
    UAVInstructionHeader2,
    // in this state we aren't sure exactly when to leave it. We wait *at least* until opcode is
    // written, but there may be more instructions after that to read from dst :(
    UAVInstructionBody,
  };

  enum class NvUAVParam
  {
    opcode = 0,
    src0 = 76,
    src1 = 92,
    src2 = 108,
    src3 = 28,
    src4 = 44,
    src5 = 60,
    dst = 124,
    markUAV = 140,
    numOutputs = 144,
  };

  InstructionState state = InstructionState::Nothing;

  NvShaderOpcode nvopcode = NvShaderOpcode::Unknown;
  Operand srcParam[8];
  Operand dstParam[4];
  Operand uavParam;
  int numOutputs = 0, outputsNeeded = 0;

  ToString flags = friendly ? ToString::FriendlyNameRegisters : ToString::None;

  for(size_t i = 0; i < m_Instructions.size(); i++)
  {
    // reserve space for an added instruction so that curOp can stay valid even if we insert a new
    // op. This only actually does work the first time (or after we've inserted a new
    // instruction).
    m_Instructions.reserve(m_Instructions.size() + 1);

    Operation &curOp = m_Instructions[i];

    if(state == InstructionState::Broken)
      break;

    if((curOp.operation == OPCODE_IMM_ATOMIC_CMP_EXCH &&
        curOp.operands[1].indices[0].index == magicID) ||
       (curOp.operation == OPCODE_ATOMIC_CMP_STORE && curOp.operands[0].indices[0].index == magicID))
    {
      // AMD operations where the return value isn't used becomes an atomic_cmp_store instead of
      // imm_atomic_cmp_exch

      const int32_t instructionIndex = curOp.operation == OPCODE_ATOMIC_CMP_STORE ? 1 : 2;
      const int32_t param0Index = instructionIndex + 1;
      const int32_t param1Index = param0Index + 1;

      Operand dstOperand = curOp.operands[0];
      // if we have a store there's no destination, so set it to null
      if(curOp.operation == OPCODE_ATOMIC_CMP_STORE)
      {
        dstOperand = Operand();
        dstOperand.type = TYPE_NULL;
        dstOperand.setComps(0xff, 0xff, 0xff, 0xff);
      }

      // AMD operation
      if(curOp.operands[instructionIndex].type != TYPE_IMMEDIATE32)
      {
        RDCERR(
            ""Expected literal value for AMD extension instruction. Was the shader compiled with ""
            ""optimisations disabled?"");
        state = InstructionState::Broken;
        break;
      }

      uint32_t instruction = curOp.operands[instructionIndex].values[0];

      if(AMDInstruction::Magic.Get(instruction) == 5)
      {
        AMDInstruction::DX12Op amdop;

        if(m_API == GraphicsAPI::D3D11)
          amdop = AMDInstruction::convert(AMDInstruction::Opcode11.Get(instruction));
        else
          amdop = AMDInstruction::Opcode12.Get(instruction);

        uint32_t phase = AMDInstruction::Phase.Get(instruction);
        if(phase == 0)
        {
          srcParam[0] = curOp.operands[param0Index];
          srcParam[1] = curOp.operands[param1Index];
        }
        else if(phase == 1)
        {
          srcParam[2] = curOp.operands[param0Index];
          srcParam[3] = curOp.operands[param1Index];
        }
        else if(phase == 2)
        {
          srcParam[4] = curOp.operands[param0Index];
          srcParam[5] = curOp.operands[param1Index];
        }
        else if(phase == 3)
        {
          srcParam[6] = curOp.operands[param0Index];
          srcParam[7] = curOp.operands[param1Index];
        }

        Operation op;

        switch(amdop)
        {
          case AMDInstruction::DX12Op::Readfirstlane:
          {
            op.operation = OPCODE_AMD_READFIRSTLANE;
            op.operands.resize(2);
            op.operands[0] = dstOperand;
            op.operands[1].name = ""src""_lit;
            op.operands[1] = srcParam[0];
            break;
          }
          case AMDInstruction::DX12Op::Readlane:
          {
            op.operation = OPCODE_AMD_READLANE;
            op.operands.resize(3);
            op.operands[0] = dstOperand;
            op.operands[1].name = ""src""_lit;
            op.operands[1] = srcParam[0];
            // lane is encoded in instruction data
            op.operands[2].name = ""lane""_lit;
            op.operands[2].type = TYPE_IMMEDIATE32;
            op.operands[2].numComponents = NUMCOMPS_1;
            op.operands[2].values[0] = AMDInstruction::Data.Get(instruction);
            break;
          }
          case AMDInstruction::DX12Op::LaneId:
          {
            op.operation = OPCODE_AMD_LANEID;
            op.operands = {dstOperand};
            break;
          }
          case AMDInstruction::DX12Op::Swizzle:
          {
            op.operation = OPCODE_AMD_SWIZZLE;
            op.operands.resize(2);
            op.operands[0] = dstOperand;
            op.operands[1].name = ""src""_lit;
            op.operands[1] = srcParam[0];
            break;
          }
          case AMDInstruction::DX12Op::Ballot:
          {
            if(phase == 0)
            {
              // srcParams already stored, store the dst for phase 0
              dstParam[0] = dstOperand;
            }
            else if(phase == 1)
            {
              op.operation = OPCODE_AMD_BALLOT;
              op.operands.resize(3);
              op.operands[0] = dstParam[0];
              op.operands[1] = dstOperand;
              op.operands[2] = srcParam[0];
              op.operands[2].name = ""predicate""_lit;
            }
            break;
          }
          case AMDInstruction::DX12Op::MBCnt:
          {
            op.operation = OPCODE_AMD_MBCNT;
            op.operands.resize(3);
            op.operands[0] = dstOperand;
            op.operands[1] = srcParam[0];
            op.operands[2] = srcParam[1];
            break;
          }
          case AMDInstruction::DX12Op::Min3U:
          case AMDInstruction::DX12Op::Min3F:
          case AMDInstruction::DX12Op::Med3U:
          case AMDInstruction::DX12Op::Med3F:
          case AMDInstruction::DX12Op::Max3U:
          case AMDInstruction::DX12Op::Max3F:
          {
            if(phase == 0)
            {
              // don't need the output at all, it's just used to chain the instructions
            }
            else if(phase == 1)
            {
              switch(amdop)
              {
                case AMDInstruction::DX12Op::Min3U: op.operation = OPCODE_AMD_MIN3U; break;
                case AMDInstruction::DX12Op::Min3F: op.operation = OPCODE_AMD_MIN3F; break;
                case AMDInstruction::DX12Op::Med3U: op.operation = OPCODE_AMD_MED3U; break;
                case AMDInstruction::DX12Op::Med3F: op.operation = OPCODE_AMD_MED3F; break;
                case AMDInstruction::DX12Op::Max3U: op.operation = OPCODE_AMD_MAX3U; break;
                case AMDInstruction::DX12Op::Max3F: op.operation = OPCODE_AMD_MAX3F; break;
                default: break;
              }
              op.operands.resize(4);
              op.operands[0] = dstOperand;
              op.operands[1] = srcParam[0];
              op.operands[2] = srcParam[1];
              op.operands[3] = srcParam[2];
            }
            break;
          }
          case AMDInstruction::DX12Op::BaryCoord:
          {
            if(phase == 0)
            {
              // srcParams already stored, store the dst for phase 0
              dstParam[0] = dstOperand;
            }
            else if(phase == 1)
            {
              if(AMDInstruction::BaryInterp.Get(instruction) != AMDInstruction::PerspPullModel)
              {
                // all modes except pull model have two outputs
                op.operation = OPCODE_AMD_BARYCOORD;
                op.operands.resize(2);
                op.operands[0].name = ""i""_lit;
                op.operands[0] = dstParam[0];
                op.operands[0].name = ""j""_lit;
                op.operands[1] = dstOperand;
              }
              else
              {
                dstParam[1] = dstOperand;
              }
            }
            else if(phase == 2)
            {
              // all modes except pull model have two outputs
              op.operation = OPCODE_AMD_BARYCOORD;
              op.operands.resize(3);
              op.operands[0].name = ""invW""_lit;
              op.operands[0] = dstParam[0];
              op.operands[1].name = ""invI""_lit;
              op.operands[1] = dstParam[1];
              op.operands[2].name = ""invJ""_lit;
              op.operands[2] = dstOperand;
            }
            break;
          }
          case AMDInstruction::DX12Op::VtxParam:
          {
            op.operation = OPCODE_AMD_VTXPARAM;
            op.operands.resize(3);
            op.operands[0] = dstOperand;
            // vertexIndex is encoded in instruction data
            op.operands[1].name = ""vertexIndex""_lit;
            op.operands[1].type = TYPE_IMMEDIATE32;
            op.operands[1].numComponents = NUMCOMPS_1;
            op.operands[1].values[0] = AMDInstruction::VtxParamVertex.Get(instruction);

            // decode and pretty-ify the parameter index and component
            op.operands[2].name = ""parameter""_lit;
            op.operands[2].type = TYPE_INPUT;
            op.operands[2].numComponents = NUMCOMPS_1;
            op.operands[2].indices.resize(1);
            op.operands[2].indices[0].absolute = true;
            op.operands[2].indices[0].index = AMDInstruction::VtxParamParameter.Get(instruction);
            op.operands[2].setComps(AMDInstruction::VtxParamComponent.Get(instruction), 0xff, 0xff,
                                    0xff);

            break;
          }
          case AMDInstruction::DX12Op::ViewportIndex:
          {
            op.operation = OPCODE_AMD_GET_VIEWPORTINDEX;
            op.operands = {dstOperand};
            break;
          }
          case AMDInstruction::DX12Op::RtArraySlice:
          {
            op.operation = OPCODE_AMD_GET_RTARRAYSLICE;
            op.operands = {dstOperand};
            break;
          }
          case AMDInstruction::DX12Op::WaveReduce:
          case AMDInstruction::DX12Op::WaveScan:
          {
            if(amdop == AMDInstruction::DX12Op::WaveReduce)
              op.operation = OPCODE_AMD_WAVE_REDUCE;
            else
              op.operation = OPCODE_AMD_WAVE_SCAN;

            op.preciseValues = AMDInstruction::WaveOp.Get(instruction);
            break;
          }
          case AMDInstruction::DX12Op::LoadDwAtAddr:
          {
            if(phase == 0)
            {
              // don't need the output at all, it's just used to chain the instructions
            }
            else if(phase == 1)
            {
              op.operation = OPCODE_AMD_LOADDWATADDR;
              op.operands.resize(4);
              op.operands[0] = dstOperand;
              op.operands[1] = srcParam[0];
              op.operands[1].name = ""gpuVaLoBits""_lit;
              op.operands[2] = srcParam[1];
              op.operands[2].name = ""gpuVaHiBits""_lit;
              op.operands[3] = srcParam[2];
              op.operands[3].name = ""offset""_lit;
            }
            break;
          }
          case AMDInstruction::DX12Op::DrawIndex:
          {
            op.operation = OPCODE_AMD_GET_DRAWINDEX;
            op.operands = {dstOperand};
            break;
          }
          case AMDInstruction::DX12Op::GetWaveSize:
          {
            op.operation = OPCODE_AMD_GET_WAVESIZE;
            op.operands = {dstOperand};
            break;
          }
          case AMDInstruction::DX12Op::BaseInstance:
          {
            op.operation = OPCODE_AMD_GET_BASEINSTANCE;
            op.operands = {dstOperand};
            break;
          }
          case AMDInstruction::DX12Op::BaseVertex:
          {
            op.operation = OPCODE_AMD_GET_BASEVERTEX;
            op.operands = {dstOperand};
            break;
          }
          case AMDInstruction::DX12Op::AtomicU64:
          {
            // if we're in the nothing state, move to the AMD UAV state so we watch for a UAV access
            // and nop it out
            if(state == InstructionState::Nothing)
              state = InstructionState::AMDUAVAtomic;

            VendorAtomicOp atomicop = convert(AMDInstruction::AtomicOp.Get(instruction));
            op.preciseValues = atomicop;

            bool isCAS = (atomicop == ATOMIC_OP_CAS);

            // for CAS we have four phases, only exit the state when we're in phase 3. For all other
            // instructions we have three phases so exit in phase 2.
            if(phase == 3 || (phase == 2 && !isCAS))
            {
              op.operation = OPCODE_AMD_U64_ATOMIC;
              state = InstructionState::Nothing;

              // output values first
              op.operands.push_back(dstParam[0]);
              op.operands.push_back(dstOperand);

              // then the saved UAV
              op.operands.push_back(uavParam);

              // then the address. This is in params [0], [1], [2]. If they all come from the same
              // register we can compact this
              if(srcParam[0].indices == srcParam[1].indices &&
                 srcParam[1].indices == srcParam[2].indices)
              {
                op.operands.push_back(srcParam[0]);
                op.operands.back().setComps(srcParam[0].comps[0], srcParam[1].comps[0],
                                            srcParam[2].comps[0], 0xff);
                op.operands.back().name = ""address""_lit;

                // store in texelOffset whether the parameter is combined (1) or split (2)
                op.texelOffset[0] = 1;
              }
              else
              {
                op.operands.push_back(srcParam[0]);
                op.operands.back().name = ""address.x""_lit;
                op.operands.back().setComps(srcParam[0].comps[0], 0xff, 0xff, 0xff);
                op.operands.push_back(srcParam[1]);
                op.operands.back().name = ""address.y""_lit;
                op.operands.back().setComps(srcParam[1].comps[0], 0xff, 0xff, 0xff);
                op.operands.push_back(srcParam[2]);
                op.operands.back().name = ""address.z""_lit;
                op.operands.back().setComps(srcParam[2].comps[0], 0xff, 0xff, 0xff);

                // store in texelOffset whether the parameter is combined (1) or split (2)
                op.texelOffset[0] = 2;
              }

              // for CAS, the compare value next
              if(isCAS)
              {
                if(srcParam[5].indices == srcParam[6].indices)
                {
                  op.operands.push_back(srcParam[5]);
                  op.operands.back().setComps(srcParam[5].comps[0], srcParam[6].comps[0], 0xff, 0xff);
                  op.operands.back().values[1] = srcParam[6].values[0];
                  op.operands.back().name = ""compare_value""_lit;

                  // store in texelOffset whether the parameter is combined (1) or split (2)
                  op.texelOffset[1] = 1;
                }
                else
                {
                  op.operands.push_back(srcParam[5].reswizzle(0));
                  op.operands.back().name = ""compare_value.x""_lit;
                  op.operands.back().setComps(srcParam[5].comps[0], 0xff, 0xff, 0xff);
                  op.operands.push_back(srcParam[6].reswizzle(0));
                  op.operands.back().name = ""compare_value.y""_lit;
                  op.operands.back().setComps(srcParam[6].comps[0], 0xff, 0xff, 0xff);

                  // store in texelOffset whether the parameter is combined (1) or split (2)
                  op.texelOffset[1] = 2;
                }
              }

              // then the value
              if(srcParam[3].indices == srcParam[4].indices)
              {
                op.operands.push_back(srcParam[3]);
                op.operands.back().setComps(srcParam[3].comps[0], srcParam[4].comps[0], 0xff, 0xff);
                op.operands.back().values[1] = srcParam[4].values[0];
                op.operands.back().name = ""value""_lit;

                // store in texelOffset whether the parameter is combined (1) or split (2)
                op.texelOffset[2] = 1;
              }
              else
              {
                op.operands.push_back(srcParam[3].reswizzle(0));
                op.operands.back().name = ""value.x""_lit;
                op.operands.back().setComps(srcParam[3].comps[0], 0xff, 0xff, 0xff);
                op.operands.push_back(srcParam[4].reswizzle(0));
                op.operands.back().name = ""value.y""_lit;
                op.operands.back().setComps(srcParam[4].comps[0], 0xff, 0xff, 0xff);

                // store in texelOffset whether the parameter is combined (1) or split (2)
                op.texelOffset[2] = 2;
              }
            }

            // phase 0's destination is the first destination
            if(phase == 0)
              dstParam[0] = dstOperand;

            break;
          }
        }

        // if the operation wasn't set we're on an intermediate phase. operands were saved,
        // wait until we have the full operation
        if(op.operation != NUM_REAL_OPCODES)
        {
          op.offset = curOp.offset;
          op.str = ToStr(op.operation);

          if(op.operation == OPCODE_AMD_BARYCOORD)
          {
            switch(AMDInstruction::BaryInterp.Get(instruction))
            {
              case AMDInstruction::LinearCenter: op.str += ""_linear_center""; break;
              case AMDInstruction::LinearCentroid: op.str += ""_linear_centroid""; break;
              case AMDInstruction::LinearSample: op.str += ""_linear_sample""; break;
              case AMDInstruction::PerspCenter: op.str += ""_persp_center""; break;
              case AMDInstruction::PerspCentroid: op.str += ""_persp_centroid""; break;
              case AMDInstruction::PerspSample: op.str += ""_persp_sample""; break;
              case AMDInstruction::PerspPullModel: op.str += ""_persp_pullmodel""; break;
              default: op.str += ""_unknown""; break;
            }
          }
          else if(op.operation == OPCODE_AMD_SWIZZLE)
          {
            switch(AMDInstruction::SwizzleOp.Get(instruction))
            {
              case AMDInstruction::SwapX1: op.str += ""_swap1""; break;
              case AMDInstruction::SwapX2: op.str += ""_swap2""; break;
              case AMDInstruction::SwapX4: op.str += ""_swap4""; break;
              case AMDInstruction::SwapX8: op.str += ""_swap8""; break;
              case AMDInstruction::SwapX16: op.str += ""_swap16""; break;
              case AMDInstruction::ReverseX4: op.str += ""_reverse4""; break;
              case AMDInstruction::ReverseX8: op.str += ""_reverse8""; break;
              case AMDInstruction::ReverseX16: op.str += ""_reverse16:""; break;
              case AMDInstruction::ReverseX32: op.str += ""_reverse32:""; break;
              case AMDInstruction::BCastX2: op.str += ""_bcast2""; break;
              case AMDInstruction::BCastX4: op.str += ""_bcast4""; break;
              case AMDInstruction::BCastX8: op.str += ""_bcast8""; break;
              case AMDInstruction::BCastX16: op.str += ""_bcast16""; break;
              case AMDInstruction::BCastX32: op.str += ""_bcast32""; break;
            }
          }
          else if(op.operation == OPCODE_AMD_WAVE_REDUCE || op.operation == OPCODE_AMD_WAVE_SCAN)
          {
            switch((VendorWaveOp)op.preciseValues)
            {
              default: break;
              case WAVE_OP_ADD_FLOAT: op.str += ""_addf""; break;
              case WAVE_OP_ADD_SINT: op.str += ""_addi""; break;
              case WAVE_OP_ADD_UINT: op.str += ""_addu""; break;
              case WAVE_OP_MUL_FLOAT: op.str += ""_mulf""; break;
              case WAVE_OP_MUL_SINT: op.str += ""_muli""; break;
              case WAVE_OP_MUL_UINT: op.str += ""_mulu""; break;
              case WAVE_OP_MIN_FLOAT: op.str += ""_minf""; break;
              case WAVE_OP_MIN_SINT: op.str += ""_mini""; break;
              case WAVE_OP_MIN_UINT: op.str += ""_minu""; break;
              case WAVE_OP_MAX_FLOAT: op.str += ""_maxf""; break;
              case WAVE_OP_MAX_SINT: op.str += ""_maxi""; break;
              case WAVE_OP_MAX_UINT: op.str += ""_maxu""; break;
              case WAVE_OP_AND: op.str += ""_and""; break;
              case WAVE_OP_OR: op.str += ""_or""; break;
              case WAVE_OP_XOR: op.str += ""_xor""; break;
            }

            if(op.operation == OPCODE_AMD_WAVE_SCAN)
            {
              if(AMDInstruction::WaveOpFlags.Get(instruction) & 0x1)
                op.str += ""_incl"";
              if(AMDInstruction::WaveOpFlags.Get(instruction) & 0x2)
                op.str += ""_excl"";
            }
          }

          for(size_t a = 0; a < op.operands.size(); a++)
          {
            if(a == 0)
              op.str += "" "";
            else
              op.str += "", "";
            op.str += op.operands[a].toString(m_Reflection, flags | ToString::ShowSwizzle);
          }

          m_Instructions.insert(i + 1, op);
        }
      }
      else
      {
        RDCERR(""Expected magic value of 5 in encoded AMD instruction %x"", instruction);
        state = InstructionState::Broken;
        break;
      }

      if(state == InstructionState::Broken)
        continue;

      // remove this operation, but keep the old operation so we can undo this if things go
      // wrong
      curOp.stride = curOp.operation;
      curOp.operation = OPCODE_VENDOR_REMOVED;
      RDCCOMPILE_ASSERT(sizeof(curOp.stride) >= sizeof(curOp.operation),
                        ""Hackily assuming stride is big enough to hold an operation"");
    }
    else if(curOp.operation == OPCODE_IMM_ATOMIC_ALLOC &&
            curOp.operands[1].indices[0].index == magicID)
    {
      // NV IncrementCounter()
      switch(state)
      {
        case InstructionState::Broken:
        case InstructionState::AMDUAVAtomic:
          break;
        // in Nothing an increment marks the beginning of an instruction of some type
        case InstructionState::Nothing:
        {
          state = InstructionState::InstructionHeader;
          break;
        }
        case InstructionState::InstructionHeader:
        {
          // the transition from instruction to any other state should happen via a markUAV or
          // opcode write, not with a counter increment
          RDCERR(
              ""Expected either markUAV or opcode write before counter increment in unknown ""
              ""instruction header!"");
          state = InstructionState::Broken;
          break;
        }
        case InstructionState::InstructionBody:
        {
          outputsNeeded--;
          if(outputsNeeded <= 0)
          {
            // once we've emitted all outputs, move to Nothing state
            state = InstructionState::Nothing;

            // and emit vendor instruction
            Operation op;

            switch(nvopcode)
            {
              case NvShaderOpcode::Shuffle:
              case NvShaderOpcode::ShuffleUp:
              case NvShaderOpcode::ShuffleDown:
              case NvShaderOpcode::ShuffleXor:
              {
                if(nvopcode == NvShaderOpcode::Shuffle)
                  op.operation = OPCODE_NV_SHUFFLE;
                else if(nvopcode == NvShaderOpcode::ShuffleUp)
                  op.operation = OPCODE_NV_SHUFFLE_UP;
                else if(nvopcode == NvShaderOpcode::ShuffleDown)
                  op.operation = OPCODE_NV_SHUFFLE_DOWN;
                else if(nvopcode == NvShaderOpcode::ShuffleXor)
                  op.operation = OPCODE_NV_SHUFFLE_XOR;

                op.operands.resize(4);
                op.operands[0] = curOp.operands[0];

                op.operands[1].name = ""value""_lit;
                op.operands[1] = srcParam[0].reswizzle(0);
                if(nvopcode == NvShaderOpcode::Shuffle)
                  op.operands[2].name = ""srcLane""_lit;
                else if(nvopcode == NvShaderOpcode::ShuffleXor)
                  op.operands[2].name = ""laneMask""_lit;
                else
                  op.operands[2].name = ""delta""_lit;
                op.operands[2] = srcParam[0].reswizzle(1);
                op.operands[3].name = ""width""_lit;
                op.operands[3] = srcParam[0].reswizzle(3);
                break;
              }
              case NvShaderOpcode::VoteAll:
              case NvShaderOpcode::VoteAny:
              case NvShaderOpcode::VoteBallot:
              {
                if(nvopcode == NvShaderOpcode::VoteAll)
                  op.operation = OPCODE_NV_VOTE_ALL;
                else if(nvopcode == NvShaderOpcode::VoteAny)
                  op.operation = OPCODE_NV_VOTE_ANY;
                else if(nvopcode == NvShaderOpcode::VoteBallot)
                  op.operation = OPCODE_NV_VOTE_BALLOT;

                op.operands.resize(2);
                op.operands[0] = curOp.operands[0];
                op.operands[1] = srcParam[0];
                op.operands[1].name = ""predicate""_lit;
                break;
              }
              case NvShaderOpcode::GetLaneId:
              {
                op.operation = OPCODE_NV_GET_LANEID;
                op.operands = {curOp.operands[0]};
                break;
              }
              case NvShaderOpcode::GetSpecial:
              {
                if(srcParam[0].type != TYPE_IMMEDIATE32)
                {
                  RDCERR(""Expected literal value for special subopcode"");
                  state = InstructionState::Broken;
                  break;
                }

                NvShaderSpecial special = (NvShaderSpecial)srcParam[0].values[0];

                if(special == NvShaderSpecial::ThreadLtMask)
                {
                  op.operation = OPCODE_NV_GET_THREADLTMASK;
                }
                else if(special == NvShaderSpecial::FootprintSingleLOD)
                {
                  op.operation = OPCODE_NV_GET_FOOTPRINT_SINGLELOD;
                }
                else
                {
                  RDCERR(""Unexpected special subopcode"");
                  state = InstructionState::Broken;
                  break;
                }
                op.operands = {curOp.operands[0]};
                break;
              }
              case NvShaderOpcode::MatchAny:
              {
                op.operation = OPCODE_NV_MATCH_ANY;
                op.operands.resize(2);
                op.operands[0] = curOp.operands[0];
                op.operands[1] = srcParam[0];
                // we don't need src1, it only indicates the number of components in the value,
                // which we already have
                break;
              }
              case NvShaderOpcode::GetShadingRate:
              {
                op.operation = OPCODE_NV_GET_SHADING_RATE;

                if(dstParam[0].indices == curOp.operands[0].indices &&
                   dstParam[1].indices == curOp.operands[0].indices)
                {
                  op.operands.push_back(curOp.operands[0]);
                  op.operands.back().name = ""result""_lit;

                  // fixup the comps according to the shuffle
                  op.operands.back().setComps(
                      // x
                      dstParam[1].comps[0],
                      // y
                      dstParam[0].comps[0],
                      // z
                      curOp.operands[0].comps[0], 0xff);
                }
                else
                {
                  // these are in reverse order because we read them as numOutputs was decrementing
                  op.operands.push_back(dstParam[1]);
                  op.operands.back().name = ""result.x""_lit;
                  op.operands.push_back(dstParam[0]);
                  op.operands.back().name = ""result.y""_lit;
                  // z is last
                  op.operands.push_back(curOp.operands[0]);
                  op.operands.back().name = ""result.z""_lit;
                }

                break;
              }
              // all footprint ops are very similar
              case NvShaderOpcode::Footprint:
              case NvShaderOpcode::FootprintBias:
              case NvShaderOpcode::FootprintLevel:
              case NvShaderOpcode::FootprintGrad:
              {
                if(nvopcode == NvShaderOpcode::Footprint)
                  op.operation = OPCODE_NV_FOOTPRINT;
                else if(nvopcode == NvShaderOpcode::FootprintBias)
                  op.operation = OPCODE_NV_FOOTPRINT_BIAS;
                else if(nvopcode == NvShaderOpcode::FootprintLevel)
                  op.operation = OPCODE_NV_FOOTPRINT_LEVEL;
                else if(nvopcode == NvShaderOpcode::FootprintGrad)
                  op.operation = OPCODE_NV_FOOTPRINT_GRAD;

                // four output values, could be assigned to different registers depending on packing
                // because they come back as scalars from increment counter. In general we have to
                // have them separately, but see if they all neatly line up into one output first.

                if(dstParam[0].indices == curOp.operands[0].indices &&
                   dstParam[1].indices == curOp.operands[0].indices &&
                   dstParam[2].indices == curOp.operands[0].indices)
                {
                  op.operands.push_back(curOp.operands[0]);
                  op.operands.back().name = ""result""_lit;

                  // fixup the comps according to the shuffle
                  op.operands.back().setComps(
                      // x
                      dstParam[2].comps[0],
                      // y
                      dstParam[1].comps[0],
                      // z
                      dstParam[0].comps[0],
                      // w
                      curOp.operands[0].comps[0]);
                }
                else
                {
                  // these are in reverse order because we read them as numOutputs was decrementing
                  op.operands.push_back(dstParam[2]);
                  op.operands.back().name = ""result.x""_lit;
                  op.operands.push_back(dstParam[1]);
                  op.operands.back().name = ""result.y""_lit;
                  op.operands.push_back(dstParam[0]);
                  op.operands.back().name = ""result.z""_lit;
                  // w is last
                  op.operands.push_back(curOp.operands[0]);
                  op.operands.back().name = ""result.w""_lit;
                }

                // peel out the source parameters
                op.operands.push_back(srcParam[3].reswizzle(0));
                op.operands.back().name = ""texSpace""_lit;
                op.operands.push_back(srcParam[0].reswizzle(0));
                op.operands.back().name = ""texIndex""_lit;
                op.operands.push_back(srcParam[3].reswizzle(1));
                op.operands.back().name = ""smpSpace""_lit;
                op.operands.push_back(srcParam[0].reswizzle(1));
                op.operands.back().name = ""smpIndex""_lit;
                op.operands.push_back(srcParam[3].reswizzle(2));
                op.operands.back().name = ""texType""_lit;
                op.operands.push_back(srcParam[1]);
                op.operands.back().comps[3] = 0xff;    // location is a float3
                op.operands.back().values[3] = 0;
                op.operands.back().name = ""location""_lit;
                op.operands.push_back(srcParam[3].reswizzle(3));
                op.operands.back().name = ""coarse""_lit;
                op.operands.push_back(srcParam[1].reswizzle(3));
                op.operands.back().name = ""gran""_lit;

                if(nvopcode == NvShaderOpcode::FootprintBias)
                {
                  op.operands.push_back(srcParam[2].reswizzle(0));
                  op.operands.back().name = ""bias""_lit;
                }
                else if(nvopcode == NvShaderOpcode::FootprintLevel)
                {
                  op.operands.push_back(srcParam[2].reswizzle(0));
                  op.operands.back().name = ""lodLevel""_lit;
                }
                else if(nvopcode == NvShaderOpcode::FootprintGrad)
                {
                  op.operands.push_back(srcParam[2]);
                  op.operands.back().name = ""ddx""_lit;
                  op.operands.push_back(srcParam[5]);
                  op.operands.back().name = ""ddy""_lit;
                }

                op.operands.push_back(srcParam[4]);
                op.operands.back().name = ""offset""_lit;

                break;
              }
              case NvShaderOpcode::ShuffleGeneric:
              {
                op.operation = OPCODE_NV_SHUFFLE_GENERIC;
                op.operands.resize(5);
                // first output is the actual result
                op.operands[0] = curOp.operands[0];
                // second output is the laneValid we stored previously
                op.operands[1] = dstParam[0];
                op.operands[1].name = ""out laneValid""_lit;

                // we expect the params are packed into srcParam[0]

                op.operands[2] = srcParam[0].reswizzle(0);
                op.operands[2].name = ""value""_lit;
                op.operands[3] = srcParam[0].reswizzle(1);
                op.operands[3].name = ""srcLane""_lit;
                op.operands[4] = srcParam[0].reswizzle(2);
                op.operands[4].name = ""width""_lit;
                break;
              }
              case NvShaderOpcode::VPRSEvalAttribAtSample:
              case NvShaderOpcode::VPRSEvalAttribSnapped:
              {
                if(nvopcode == NvShaderOpcode::VPRSEvalAttribAtSample)
                  op.operation = OPCODE_NV_VPRS_EVAL_ATTRIB_SAMPLE;
                else if(nvopcode == NvShaderOpcode::VPRSEvalAttribSnapped)
                  op.operation = OPCODE_NV_VPRS_EVAL_ATTRIB_SNAPPED;

                // up to four output values, could be assigned to different registers depending on
                // packing because they come back as scalars from increment counter. In general we
                // have to have them separately, but see if they all neatly line up into one output
                // first.

                bool allSameReg = true;

                for(int o = 0; o < numOutputs - 1; o++)
                {
                  if(!(dstParam[o].indices == curOp.operands[0].indices))
                  {
                    allSameReg = false;
                    break;
                  }
                }

                if(allSameReg)
                {
                  op.operands.push_back(curOp.operands[0]);
                  op.operands.back().name = ""result""_lit;

                  for(int o = 0; o < 4; o++)
                  {
                    if(o >= numOutputs)
                      op.operands.back().comps[o] = 0xff;
                    else if(o + 1 == numOutputs)
                      op.operands.back().comps[o] = curOp.operands[0].comps[0];
                    else
                      op.operands.back().comps[o] = dstParam[numOutputs - 2 - o].comps[0];
                  }
                }
                else
                {
                  const char swz[] = ""xyzw"";
                  for(int o = 0; o < numOutputs - 1; o++)
                  {
                    // these are in reverse order because we read them as numOutputs was
                    // decrementing
                    op.operands.push_back(dstParam[numOutputs - 2 - o]);
                    op.operands.back().name = rdcstr(""result."") + swz[o];
                  }
                  op.operands.push_back(curOp.operands[0]);
                  op.operands.back().name = rdcstr(""result."") + swz[numOutputs - 1];
                }

                op.operands.push_back(srcParam[0]);
                op.operands.back().name = ""attrib""_lit;

                if(nvopcode == NvShaderOpcode::VPRSEvalAttribAtSample)
                {
                  op.operands.push_back(srcParam[1]);
                  op.operands.back().name = ""sampleIndex""_lit;
                  op.operands.push_back(srcParam[2]);
                  op.operands.back().name = ""pixelOffset""_lit;
                }
                else if(nvopcode == NvShaderOpcode::VPRSEvalAttribSnapped)
                {
                  op.operands.push_back(srcParam[1]);
                  op.operands.back().name = ""offset""_lit;
                }

                break;
              }
              default:
                RDCERR(""Unexpected non-UAV opcode %d."", nvopcode);
                state = InstructionState::Broken;
                break;
            }

            if(state == InstructionState::Broken)
              break;

            op.offset = curOp.offset;
            op.str = ToStr(op.operation);

            for(size_t a = 0; a < op.operands.size(); a++)
            {
              if(a == 0)
                op.str += "" "";
              else
                op.str += "", "";
              op.str += op.operands[a].toString(m_Reflection, flags | ToString::ShowSwizzle);
            }

            m_Instructions.insert(i + 1, op);
          }
          else
          {
            dstParam[outputsNeeded - 1] = curOp.operands[0];
          }
          break;
        }
        case InstructionState::UAVInstructionHeader1:
        {
          RDCERR(""Expected other UAV write before counter increment in UAV instruction header!"");
          state = InstructionState::Broken;
          break;
        }
        case InstructionState::UAVInstructionHeader2:
        {
          // now that we've gotten the UAV, we can go to the body
          state = InstructionState::UAVInstructionBody;
          break;
        }
        case InstructionState::UAVInstructionBody:
        {
          RDCERR(
              ""Unexpected counter increment while processing UAV instruction body. Expected ""
              ""opcode!"");
          state = InstructionState::Broken;
          break;
        }
      }

      if(state == InstructionState::Broken)
        continue;

      // remove this operation, but keep the old operation so we can undo this if things go
      // wrong
      curOp.stride = curOp.operation;
      curOp.operation = OPCODE_VENDOR_REMOVED;
    }
    else if(curOp.operation == OPCODE_STORE_STRUCTURED &&
            curOp.operands[0].indices[0].index == magicID)
    {
      if(curOp.operands[2].type != TYPE_IMMEDIATE32)
      {
        RDCERR(""Expected literal value for UAV write offset"");
        state = InstructionState::Broken;
        break;
      }

      // NV magic UAV write
      NvUAVParam param = (NvUAVParam)curOp.operands[2].values[0];

      switch(param)
      {
        case NvUAVParam::opcode:
        {
          if(curOp.operands[3].type != TYPE_IMMEDIATE32)
          {
            RDCERR(
                ""Expected literal value being written as opcode. Was the shader compiled with ""
                ""optimisations disabled?"");
            state = InstructionState::Broken;
            break;
          }

          nvopcode = (NvShaderOpcode)curOp.operands[3].values[0];

          // if this is NV_EXTN_OP_FP16_ATOMIC we should have come here in UAVInstructionBody.
          // That we're here now means this is the continuation of an earlier instruction.
          if(state == InstructionState::InstructionHeader && nvopcode == NvShaderOpcode::FP16Atomic)
            state = InstructionState::UAVInstructionBody;

          // if we're in instruction, this is the simple case so move to the output
          if(state == InstructionState::InstructionHeader)
          {
            // if we haven't gotten a number of outputs at all, set it to 1
            if(outputsNeeded <= 0)
              numOutputs = outputsNeeded = 1;
            state = InstructionState::InstructionBody;
          }
          else if(state == InstructionState::UAVInstructionBody)
          {
            // emit the instruction now, writing to the index register (which we know is
            // 'unused'). There might be nothing to read the result value. We'll look out for
            // loads and post-patch it.
            // once we've emitted all outputs, move to Nothing state
            state = InstructionState::Nothing;

            // and emit vendor instruction
            Operation op;
            // write to the index register at first. If there's a subsequent read of dst we'll patch
            // this instruction with the destination for that.
            op.operands.push_back(curOp.operands[1]);
            // also include the UAV we noted elsewhere
            op.operands.push_back(uavParam);

            NvShaderAtomic atomicop = NvShaderAtomic::Unknown;

            switch(nvopcode)
            {
              case NvShaderOpcode::FP16Atomic:
              {
                op.operation = OPCODE_NV_FP16_ATOMIC;

                if(srcParam[2].type != TYPE_IMMEDIATE32)
                {
                  RDCERR(
                      ""Expected literal value as atomic opcode. Was the shader compiled with ""
                      ""optimisations disabled?"");
                  state = InstructionState::Broken;
                  break;
                }

                atomicop = (NvShaderAtomic)srcParam[2].values[0];

                op.operands.push_back(srcParam[0]);
                op.operands.back().name = ""address""_lit;
                op.operands.push_back(srcParam[1]);
                op.operands.back().name = ""value""_lit;

                break;
              }
              case NvShaderOpcode::FP32Atomic:
              {
                op.operation = OPCODE_NV_FP32_ATOMIC;

                if(srcParam[2].type != TYPE_IMMEDIATE32)
                {
                  RDCERR(
                      ""Expected literal value as atomic opcode. Was the shader compiled with ""
                      ""optimisations disabled?"");
                  state = InstructionState::Broken;
                  break;
                }

                atomicop = (NvShaderAtomic)srcParam[2].values[0];

                op.operands.push_back(srcParam[0].reswizzle(0));
                op.operands.back().name = ""byteAddress""_lit;
                op.operands.push_back(srcParam[1].reswizzle(0));
                op.operands.back().name = ""value""_lit;

                break;
              }
              case NvShaderOpcode::U64Atomic:
              {
                op.operation = OPCODE_NV_U64_ATOMIC;

                if(srcParam[2].type != TYPE_IMMEDIATE32)
                {
                  RDCERR(
                      ""Expected literal value as atomic opcode. Was the shader compiled with ""
                      ""optimisations disabled?"");
                  state = InstructionState::Broken;
                  break;
                }

                // insert second dummy return value for high bits
                op.operands.insert(0, curOp.operands[1]);

                // make both of them NULL
                op.operands[0].type = TYPE_NULL;
                op.operands[0].setComps(0xff, 0xff, 0xff, 0xff);
                op.operands[1].type = TYPE_NULL;
                op.operands[1].setComps(0xff, 0xff, 0xff, 0xff);

                atomicop = (NvShaderAtomic)srcParam[2].values[0];

                op.operands.push_back(srcParam[0]);
                op.operands.back().numComponents = NUMCOMPS_1;
                op.operands.back().name = ""address""_lit;

                // store in texelOffset whether the parameter is combined (1) or split (2).
                // on nv we assume the parameters are always combined
                op.texelOffset[0] = 1;
                op.texelOffset[1] = 1;
                op.texelOffset[2] = 1;

                if(atomicop == NvShaderAtomic::CompareAndSwap)
                {
                  op.operands.push_back(srcParam[1]);
                  op.operands.back().numComponents = NUMCOMPS_4;
                  op.operands.back().setComps(srcParam[1].comps[0], srcParam[1].comps[1], 0xff, 0xff);
                  op.operands.back().values[1] = srcParam[1].values[1];
                  op.operands.back().name = ""compareValue""_lit;
                  op.operands.push_back(srcParam[1]);
                  op.operands.back().numComponents = NUMCOMPS_4;
                  op.operands.back().setComps(srcParam[1].comps[2], srcParam[1].comps[3], 0xff, 0xff);
                  op.operands.back().values[1] = srcParam[1].values[3];
                  op.operands.back().name = ""value""_lit;
                }
                else
                {
                  op.operands.push_back(srcParam[1]);
                  op.operands.back().numComponents = NUMCOMPS_4;
                  op.operands.back().setComps(srcParam[1].comps[0], srcParam[1].comps[1], 0xff, 0xff);
                  op.operands.back().values[1] = srcParam[1].values[1];
                  op.operands.back().name = ""value""_lit;
                }

                break;
              }
              default:
                RDCERR(""Unexpected UAV opcode %d."", nvopcode);
                state = InstructionState::Broken;
                break;
            }

            if(state == InstructionState::Broken)
              break;

            if(atomicop == NvShaderAtomic::Unknown)
            {
              RDCERR(""Couldn't determine atomic op"");
              state = InstructionState::Broken;
              break;
            }

            op.offset = curOp.offset;
            op.preciseValues = (uint8_t)atomicop;
            op.str = ToStr(op.operation);

            switch(atomicop)
            {
              case NvShaderAtomic::Unknown: break;
              case NvShaderAtomic::And:
                op.str += ""_and"";
                op.preciseValues = ATOMIC_OP_AND;
                break;
              case NvShaderAtomic::Or:
                op.str += ""_or"";
                op.preciseValues = ATOMIC_OP_OR;
                break;
              case NvShaderAtomic::Xor:
                op.str += ""_xor"";
                op.preciseValues = ATOMIC_OP_XOR;
                break;
              case NvShaderAtomic::Add:
                op.str += ""_add"";
                op.preciseValues = ATOMIC_OP_ADD;
                break;
              case NvShaderAtomic::Max:
                op.str += ""_max"";
                op.preciseValues = ATOMIC_OP_MAX;
                break;
              case NvShaderAtomic::Min:
                op.str += ""_min"";
                op.preciseValues = ATOMIC_OP_MIN;
                break;
              case NvShaderAtomic::Swap:
                op.str += ""_swap"";
                op.preciseValues = ATOMIC_OP_SWAP;
                break;
              case NvShaderAtomic::CompareAndSwap:
                op.str += ""_comp_swap"";
                op.preciseValues = ATOMIC_OP_CAS;
                break;
            }

            for(size_t a = 0; a < op.operands.size(); a++)
            {
              if(a == 0)
                op.str += "" "";
              else
                op.str += "", "";
              op.str += op.operands[a].toString(m_Reflection, flags | ToString::ShowSwizzle);
            }

            m_Instructions.insert(i + 1, op);

            // move into nothing state
            state = InstructionState::Nothing;
          }
          else
          {
            // no other state should be writing an opcode.
            RDCERR(""Writing opcode in unexpected state %d."", state);
            state = InstructionState::Broken;
          }
          break;
        }
        case NvUAVParam::markUAV:
        {
          if(curOp.operands[3].type != TYPE_IMMEDIATE32 || curOp.operands[3].values[0] != 1)
          {
            RDCERR(
                ""Expected literal 1 being written to markUAV. Was the shader compiled with ""
                ""optimisations disabled?"");
            state = InstructionState::Broken;
            break;
          }

          if(state == InstructionState::InstructionHeader)
          {
            // start waiting for the user's UAV write
            state = InstructionState::UAVInstructionHeader1;
          }
          else
          {
            // no other state should be writing an opcode.
            RDCERR(""Writing markUAV in unexpected state %d."", state);
            state = InstructionState::Broken;
          }
          break;
        }
        // store the src params unconditionally, don't care about the state.
        case NvUAVParam::src0:
        {
          srcParam[0] = curOp.operands[3];
          break;
        }
        case NvUAVParam::src1:
        {
          srcParam[1] = curOp.operands[3];
          break;
        }
        case NvUAVParam::src2:
        {
          srcParam[2] = curOp.operands[3];
          break;
        }
        case NvUAVParam::src3:
        {
          srcParam[3] = curOp.operands[3];
          break;
        }
        case NvUAVParam::src4:
        {
          srcParam[4] = curOp.operands[3];
          break;
        }
        case NvUAVParam::src5:
        {
          srcParam[5] = curOp.operands[3];
          break;
        }
        case NvUAVParam::dst:
        {
          RDCERR(""Unexpected store to dst"");
          state = InstructionState::Broken;
          break;
        }
        case NvUAVParam::numOutputs:
        {
          if(curOp.operands[3].type != TYPE_IMMEDIATE32)
          {
            RDCERR(
                ""Expected literal value being written as numOutputs. Was the shader compiled ""
                ""with optimisations disabled?"");
            state = InstructionState::Broken;
            break;
          }

          if(state == InstructionState::InstructionHeader ||
             state == InstructionState::InstructionBody)
          {
            // allow writing number of outputs in either header or body (before or after
            // simple
            // opcode)
            numOutputs = outputsNeeded = (int)curOp.operands[3].values[0];
          }
          else
          {
            // no other state should be writing an opcode.
            RDCERR(""Writing numOutputs in unexpected state %d."", state);
            state = InstructionState::Broken;
          }
          break;
        }
        default:
        {
          RDCERR(""Unexpected offset %u in nvidia magic UAV write."", param);
          state = InstructionState::Broken;
          break;
        }
      }

      if(state == InstructionState::Broken)
        continue;

      // remove this operation, but keep the old operation so we can undo this if things go
      // wrong
      curOp.stride = curOp.operation;
      curOp.operation = OPCODE_VENDOR_REMOVED;
    }
    else if(curOp.operation == OPCODE_LD_STRUCTURED && curOp.operands[3].indices[0].index == magicID)
    {
      // NV magic UAV load. This should only be of dst and only in the Nothing state after
      // we've
      // emitted a UAV instruction.
      if(state == InstructionState::Nothing)
      {
        if(curOp.operands[2].type == TYPE_IMMEDIATE32)
        {
          // NV magic UAV read
          NvUAVParam param = (NvUAVParam)curOp.operands[2].values[0];

          if(param == NvUAVParam::dst)
          {
            // search backwards for the last vendor operation. That's the one we're reading
            // from
            for(size_t j = i; j > 0; j--)
            {
              if(m_Instructions[j].operation >= OPCODE_VENDOR_FIRST)
              {
                // re-emit the instruction writing to the actual output now
                Operation op = m_Instructions[j];
                op.offset = curOp.offset;
                op.operands[0] = curOp.operands[0];
                op.str = ToStr(op.operation);

                // if this is an atomic64, the low/high bits are separate operands
                if(op.operation == OPCODE_NV_U64_ATOMIC)
                {
                  op.operands[1] = curOp.operands[0];
                  op.operands[0].setComps(curOp.operands[0].comps[0], 0xff, 0xff, 0xff);
                  op.operands[1].setComps(curOp.operands[0].comps[1], 0xff, 0xff, 0xff);
                }

                switch((VendorAtomicOp)op.preciseValues)
                {
                  case ATOMIC_OP_NONE: break;
                  case ATOMIC_OP_AND: op.str += ""_and""; break;
                  case ATOMIC_OP_OR: op.str += ""_or""; break;
                  case ATOMIC_OP_XOR: op.str += ""_xor""; break;
                  case ATOMIC_OP_ADD: op.str += ""_add""; break;
                  case ATOMIC_OP_MAX: op.str += ""_max""; break;
                  case ATOMIC_OP_MIN: op.str += ""_min""; break;
                  case ATOMIC_OP_SWAP: op.str += ""_swap""; break;
                  case ATOMIC_OP_CAS: op.str += ""_comp_swap""; break;
                }

                for(size_t a = 0; a < op.operands.size(); a++)
                {
                  if(a == 0)
                    op.str += "" "";
                  else
                    op.str += "", "";
                  op.str += op.operands[a].toString(m_Reflection, flags | ToString::ShowSwizzle);
                }

                m_Instructions.insert(i + 1, op);

                // remove the old one, we've replaced it
                m_Instructions[j].operation = OPCODE_VENDOR_REMOVED;
                // if we break and try to revert this one, keep it removed
                m_Instructions[j].stride = OPCODE_VENDOR_REMOVED;
                // also remove the current one! but back up the original in case something
                // goes
                // wrong
                curOp.stride = curOp.operation;
                curOp.operation = OPCODE_VENDOR_REMOVED;
                break;
              }
            }
          }
          else
          {
            RDCERR(""Unexpected read of UAV at offset %d instead of dst (%d)"", param, NvUAVParam::dst);
            state = InstructionState::Broken;
          }
        }
        else
        {
          RDCERR(""Expected literal value for UAV read offset"");
          state = InstructionState::Broken;
        }
      }
      else
      {
        RDCERR(""Unexpected UAV read in state %d."", state);
        state = InstructionState::Broken;
      }
    }
    else if(state == InstructionState::UAVInstructionHeader1)
    {
      // while we're here the next UAV write is snooped
      if(curOp.operation == OPCODE_STORE_RAW || curOp.operation == OPCODE_STORE_UAV_TYPED)
      {
        uavParam = curOp.operands[0];
        state = InstructionState::UAVInstructionHeader2;

        // remove this operation, but keep the old operation so we can undo this if things go
        // wrong
        curOp.stride = curOp.operation;
        curOp.operation = OPCODE_VENDOR_REMOVED;
      }
    }
    else if(state == InstructionState::AMDUAVAtomic)
    {
      // similarly for AMD we store the UAV referenced, but we don't change state - that happens
      // when we see the appropriate phase instruction.
      if(curOp.operation == OPCODE_STORE_RAW || curOp.operation == OPCODE_STORE_UAV_TYPED)
      {
        uavParam = curOp.operands[0];
        state = InstructionState::UAVInstructionHeader2;

        // remove this operation, but keep the old operation so we can undo this if things go
        // wrong
        curOp.stride = curOp.operation;
        curOp.operation = OPCODE_VENDOR_REMOVED;
      }
    }

    // any other operation we completely ignore
  }

  if(state == InstructionState::Broken)
  {
    // if we broke, restore the operations and remove any added vendor operations
    for(size_t i = 0; i < m_Instructions.size(); i++)
    {
      if(m_Instructions[i].operation == OPCODE_VENDOR_REMOVED)
        m_Instructions[i].operation = (OpcodeType)m_Instructions[i].stride;
      else if(m_Instructions[i].operation >= OPCODE_VENDOR_FIRST)
        m_Instructions[i].operation = OPCODE_VENDOR_REMOVED;
    }
  }

  // erase any OPCODE_VENDOR_REMOVED instructions now
  for(int32_t i = m_Instructions.count() - 1; i >= 0; i--)
  {
    if(m_Instructions[i].operation == OPCODE_VENDOR_REMOVED)
      m_Instructions.erase(i);
  }
}

};    // namespace DXBCBytecode
",16214,True,3409.2156947218605,median
"/**
 * MaNGOS is a full featured server for World of Warcraft, supporting
 * the following clients: 1.12.x, 2.4.3, 3.3.5a, 4.3.4a and 5.4.8
 *
 * Copyright (C) 2005-2016  MaNGOS project <https://getmangos.eu>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * World of Warcraft, and all World of Warcraft or Warcraft art, images,
 * and lore are copyrighted by Blizzard Entertainment, Inc.
 */

#include ""Object.h""
#include ""SharedDefines.h""
#include ""WorldPacket.h""
#include ""Opcodes.h""
#include ""Log.h""
#include ""World.h""
#include ""Creature.h""
#include ""Player.h""
#include ""ObjectMgr.h""
#include ""ObjectGuid.h""
#include ""UpdateData.h""
#include ""UpdateMask.h""
#include ""Util.h""
#include ""MapManager.h""
#include ""Log.h""
#include ""Transports.h""
#include ""TargetedMovementGenerator.h""
#include ""WaypointMovementGenerator.h""
#include ""VMapFactory.h""
#include ""CellImpl.h""
#include ""GridNotifiers.h""
#include ""GridNotifiersImpl.h""
#include ""ObjectPosSelector.h""
#include ""TemporarySummon.h""
#include ""movement/packet_builder.h""
#include ""CreatureLinkingMgr.h""
#include ""Chat.h""
#ifdef ENABLE_ELUNA
#include ""LuaEngine.h""
#include ""ElunaEventMgr.h""
#endif /* ENABLE_ELUNA */

Object::Object()
{
    m_objectTypeId      = TYPEID_OBJECT;
    m_objectType        = TYPEMASK_OBJECT;

    m_uint32Values      = NULL;
    m_valuesCount       = 0;

    m_inWorld           = false;
    m_objectUpdated     = false;
}

Object::~Object()
{
    if (IsInWorld())
    {
        ///- Do NOT call RemoveFromWorld here, if the object is a player it will crash
        sLog.outError(""Object::~Object (GUID: %u TypeId: %u) deleted but still in world!!"", GetGUIDLow(), GetTypeId());
        MANGOS_ASSERT(false);
    }

    if (m_objectUpdated)
    {
        sLog.outError(""Object::~Object (GUID: %u TypeId: %u) deleted but still have updated status!!"", GetGUIDLow(), GetTypeId());
        MANGOS_ASSERT(false);
    }

    delete[] m_uint32Values;
}

void Object::_InitValues()
{
    m_uint32Values = new uint32[ m_valuesCount ];
    memset(m_uint32Values, 0, m_valuesCount * sizeof(uint32));

    m_changedValues.resize(m_valuesCount, false);

    m_objectUpdated = false;
}

void Object::_Create(uint32 guidlow, uint32 entry, HighGuid guidhigh)
{
    if (!m_uint32Values)
        { _InitValues(); }

    ObjectGuid guid = ObjectGuid(guidhigh, entry, guidlow);
    SetGuidValue(OBJECT_FIELD_GUID, guid);
    SetUInt32Value(OBJECT_FIELD_TYPE, m_objectType);
    m_PackGUID.Set(guid);
}

void Object::_ReCreate(uint32 entry)
{
    if (!m_uint32Values)
        { _InitValues(); }

    SetUInt32Value(OBJECT_FIELD_TYPE, m_objectType);
    SetUInt32Value(OBJECT_FIELD_ENTRY, entry);
}

void Object::SetObjectScale(float newScale)
{
    SetFloatValue(OBJECT_FIELD_SCALE_X, newScale);
}

void Object::SendForcedObjectUpdate()
{
    if (!m_inWorld || !m_objectUpdated)
        { return; }

    UpdateDataMapType update_players;

    BuildUpdateData(update_players);
    RemoveFromClientUpdateList();

    WorldPacket packet;                                     // here we allocate a std::vector with a size of 0x10000
    for (UpdateDataMapType::iterator iter = update_players.begin(); iter != update_players.end(); ++iter)
    {
        iter->second.BuildPacket(&packet);
        iter->first->GetSession()->SendPacket(&packet);
        packet.clear();                                     // clean the string
    }
}

void Object::BuildMovementUpdateBlock(UpdateData* data, uint8 flags) const
{
    ByteBuffer buf(500);

    buf << uint8(UPDATETYPE_MOVEMENT);
    buf << GetObjectGuid();

    BuildMovementUpdate(&buf, flags);

    data->AddUpdateBlock(buf);
}

void Object::BuildCreateUpdateBlockForPlayer(UpdateData* data, Player* target) const
{
    if (!target)
        { return; }

    uint8  updatetype   = UPDATETYPE_CREATE_OBJECT;
    uint8 updateFlags  = m_updateFlag;

    /** lower flag1 **/
    if (target == this)                                     // building packet for yourself
        { updateFlags |= UPDATEFLAG_SELF; }

    if (m_isNewObject)
    {
        switch (GetObjectGuid().GetHigh())
        {
            case HighGuid::HIGHGUID_DYNAMICOBJECT:
            case HighGuid::HIGHGUID_CORPSE:
            case HighGuid::HIGHGUID_PLAYER:
            case HighGuid::HIGHGUID_UNIT:
            case HighGuid::HIGHGUID_GAMEOBJECT:
                updatetype = UPDATETYPE_CREATE_OBJECT2;
                break;
            default:
                break;
        }
    }

    // DEBUG_LOG(""BuildCreateUpdate: update-type: %u, object-type: %u got updateFlags: %X"", updatetype, m_objectTypeId, updateFlags);

    ByteBuffer buf(500);
    buf << uint8(updatetype);
    buf << GetPackGUID();
    buf << uint8(m_objectTypeId);

    BuildMovementUpdate(&buf, updateFlags);
    UpdateMask updateMask;
    updateMask.SetCount(m_valuesCount);
    _SetCreateBits(&updateMask, target);
    BuildValuesUpdate(updatetype, &buf, &updateMask, target);
    data->AddUpdateBlock(buf);
}

void Object::SendCreateUpdateToPlayer(Player* player)
{
    // send create update to player
    UpdateData upd;
    WorldPacket packet;

    BuildCreateUpdateBlockForPlayer(&upd, player);
    upd.BuildPacket(&packet);
    player->GetSession()->SendPacket(&packet);
}

void Object::BuildValuesUpdateBlockForPlayer(UpdateData* data, Player* target) const
{
    ByteBuffer buf(500);

    buf << uint8(UPDATETYPE_VALUES);
    buf << GetPackGUID();

    UpdateMask updateMask;
    updateMask.SetCount(m_valuesCount);

    _SetUpdateBits(&updateMask, target);
    BuildValuesUpdate(UPDATETYPE_VALUES, &buf, &updateMask, target);

    data->AddUpdateBlock(buf);
}

void Object::BuildOutOfRangeUpdateBlock(UpdateData* data) const
{
    data->AddOutOfRangeGUID(GetObjectGuid());
}

void Object::DestroyForPlayer(Player* target) const
{
    MANGOS_ASSERT(target);

    WorldPacket data(SMSG_DESTROY_OBJECT, 8);
    data << GetObjectGuid();
    target->GetSession()->SendPacket(&data);
}

void Object::BuildMovementUpdate(ByteBuffer* data, uint8 updateFlags) const
{
    Unit const* unit = NULL;
    uint32 highGuid = 0;
    MovementFlags moveflags = MOVEFLAG_NONE;

    switch (m_objectTypeId)
    {
        case TYPEID_OBJECT:
        case TYPEID_ITEM:
        case TYPEID_CONTAINER:
        case TYPEID_GAMEOBJECT:
        case TYPEID_DYNAMICOBJECT:
        case TYPEID_CORPSE:
            highGuid = uint32(GetObjectGuid().GetHigh());
            break;

        case TYPEID_PLAYER:
            // TODO: this code must not be here
            if (static_cast<Player const*>(this)->GetTransport())
                ((Unit*)this)->m_movementInfo.AddMovementFlag(MOVEFLAG_ONTRANSPORT);
            else
                ((Unit*)this)->m_movementInfo.RemoveMovementFlag(MOVEFLAG_ONTRANSPORT);

        case TYPEID_UNIT:
            unit = static_cast<Unit const*>(this);
            moveflags = unit->m_movementInfo.GetMovementFlags();
            break;

        default:
            break;
    }

    *data << uint8(updateFlags);

    if (updateFlags & UPDATEFLAG_LIVING)
    {
        MANGOS_ASSERT(unit);
        if (unit->IsStopped() && unit->m_movementInfo.HasMovementFlag(MOVEFLAG_SPLINE_ENABLED))
        {
            sLog.outError(""%s is not moving but have spline movement enabled!"", GetGuidStr().c_str());
            ((Unit*)this)->m_movementInfo.RemoveMovementFlag(MovementFlags(MOVEFLAG_SPLINE_ENABLED | MOVEFLAG_FORWARD));
        }

        *data << unit->m_movementInfo;
        // Unit speeds
        *data << float(unit->GetSpeed(MOVE_WALK));
        *data << float(unit->GetSpeed(MOVE_RUN));
        *data << float(unit->GetSpeed(MOVE_RUN_BACK));
        *data << float(unit->GetSpeed(MOVE_SWIM));
        *data << float(unit->GetSpeed(MOVE_SWIM_BACK));
        *data << float(unit->GetSpeed(MOVE_TURN_RATE));

        if (unit->m_movementInfo.HasMovementFlag(MOVEFLAG_SPLINE_ENABLED))
            Movement::PacketBuilder::WriteCreate(*unit->movespline, *data);
    }
    else if (updateFlags & UPDATEFLAG_HAS_POSITION)
    {
        *data << ((WorldObject*)this)->GetPositionX();
        *data << ((WorldObject*)this)->GetPositionY();
        *data << ((WorldObject*)this)->GetPositionZ();
        *data << ((WorldObject*)this)->GetOrientation();
    }

    if (updateFlags & UPDATEFLAG_HIGHGUID)
        *data << highGuid;

    if (updateFlags & UPDATEFLAG_ALL)
        *data << (uint32)0x1;

    if (updateFlags & UPDATEFLAG_FULLGUID)
    {
        if (unit && unit->getVictim())
            *data << unit->getVictim()->GetPackGUID();
        else
            data->appendPackGUID(0);
    }

    if (updateFlags & UPDATEFLAG_TRANSPORT)
        *data << uint32(WorldTimer::getMSTime());
}

void Object::BuildValuesUpdate(uint8 updatetype, ByteBuffer* data, UpdateMask* updateMask, Player* target) const
{
    if (!target)
        { return; }

    bool IsActivateToQuest = false;
    //bool IsPerCasterAuraState = false;

    // this is called for UPDATETYPE_CREATE_OBJECT, UPDATETYPE_CREATE_OBJECT2, UPDATETYPE_VALUES only
    if (isType(TYPEMASK_GAMEOBJECT) && !((GameObject*)this)->IsTransport())
    {
        IsActivateToQuest = ((GameObject*)this)->ActivateToQuest(target) || target->isGameMaster();

        updateMask->SetBit(GAMEOBJECT_DYN_FLAGS);
        if (updatetype == UPDATETYPE_VALUES)
            updateMask->SetBit(GAMEOBJECT_ANIMPROGRESS);
    }

    MANGOS_ASSERT(updateMask && updateMask->GetCount() == m_valuesCount);

    *data << (uint8)updateMask->GetBlockCount();
    data->append(updateMask->GetMask(), updateMask->GetLength());

    // checking the new bit extraction mechanic
//#ifdef _DEBUG
    uint16 ix = 0;
    for (uint16 i = 0; i < m_valuesCount; i++)
    {
        if (updateMask->GetBit(i))
        {
            ix = updateMask->GetNextSetIndex(ix);
            if (i != ix)
                sLog.outError(""ERROR BuildValuesUpdate: new index %u, should be %u for object type %u entry %u"", ix, i, GetTypeId(), GetEntry());
            ++ix;
        }
    }
//#endif

    // 2 specialized loops for speed optimization in non-unit case
    if (isType(TYPEMASK_UNIT))                              // unit (creature/player) case
    {
        uint16 index = 0;
        while ((index = updateMask->GetNextSetIndex(index)) < m_valuesCount)
        {
            if (index == UNIT_NPC_FLAGS)
            {
                uint32 appendValue = m_uint32Values[index];

                if (GetTypeId() == TYPEID_UNIT)
                {
                    if (appendValue & UNIT_NPC_FLAG_TRAINER)
                    {
                        if (!((Creature*)this)->IsTrainerOf(target, false))
                            { appendValue &= ~UNIT_NPC_FLAG_TRAINER; }
                    }

                    if (appendValue & UNIT_NPC_FLAG_STABLEMASTER)
                    {
                        if (target->getClass() != CLASS_HUNTER)
                            { appendValue &= ~UNIT_NPC_FLAG_STABLEMASTER; }
                    }
                }

                *data << uint32(appendValue);
            }
            // FIXME: Some values at server stored in float format but must be sent to client in uint32 format
            else if (index >= UNIT_FIELD_BASEATTACKTIME && index <= UNIT_FIELD_RANGEDATTACKTIME)
            {
                // convert from float to uint32 and send
                *data << uint32(m_floatValues[index] < 0 ? 0 : m_floatValues[index]);
            }

            // there are some float values which may be negative or can't get negative due to other checks
            else if ((index >= PLAYER_FIELD_NEGSTAT0    && index <= PLAYER_FIELD_NEGSTAT4) ||
                        (index >= PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE  && index <= (PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE + 6)) ||
                        (index >= PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE  && index <= (PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE + 6)) ||
                        (index >= PLAYER_FIELD_POSSTAT0    && index <= PLAYER_FIELD_POSSTAT4))
            {
                *data << uint32(m_floatValues[index]);
            }

            // Gamemasters should be always able to select units - remove not selectable flag
            else if (index == UNIT_FIELD_FLAGS && target->isGameMaster())
            {
                *data << (m_uint32Values[index] & ~UNIT_FLAG_NOT_SELECTABLE);
            }
            /* Hide loot animation for players that aren't permitted to loot the corpse */
            else if (index == UNIT_DYNAMIC_FLAGS && GetTypeId() == TYPEID_UNIT)
            {
                uint32 send_value = m_uint32Values[index];
                
                /* Initiate pointer to creature so we can check loot */
                if (Creature* my_creature = (Creature*)this)
                    /* If the creature is NOT fully looted */
                    if (!my_creature->loot.isLooted())
                        /* If the lootable flag is NOT set */
                        if (!(send_value & UNIT_DYNFLAG_LOOTABLE))
                        {
                            /* Update it on the creature */
                            my_creature->SetFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE);
                            /* Update it in the packet */
                            send_value = send_value | UNIT_DYNFLAG_LOOTABLE;
                        }

                /* If we're not allowed to loot the target, destroy the lootable flag */
                if (!target->isAllowedToLoot((Creature*)this))
                    if (send_value & UNIT_DYNFLAG_LOOTABLE)
                        { send_value = send_value & ~UNIT_DYNFLAG_LOOTABLE; }

                /* If we are allowed to loot it and mob is tapped by us, destroy the tapped flag */
                bool is_tapped = target->IsTappedByMeOrMyGroup((Creature*)this);

                /* If the creature has tapped flag but is tapped by us, remove the flag */
                if (send_value & UNIT_DYNFLAG_TAPPED && is_tapped)
                    { send_value = send_value & ~UNIT_DYNFLAG_TAPPED; }

                 // Checking SPELL_AURA_EMPATHY and caster
                if (send_value & UNIT_DYNFLAG_SPECIALINFO && ((Unit*)this)->IsAlive())
                {
                    bool bIsEmpathy = false;
                    bool bIsCaster = false;
                    Unit::AuraList const& mAuraEmpathy = ((Unit*)this)->GetAurasByType(SPELL_AURA_EMPATHY);
                    for (Unit::AuraList::const_iterator itr = mAuraEmpathy.begin(); !bIsCaster && itr != mAuraEmpathy.end(); ++itr)
                    {
                        bIsEmpathy = true; // Empathy by aura set
                        if ((*itr)->GetCasterGuid() == target->GetObjectGuid())
                        bIsCaster = true; // target is the caster of an empathy aura
                    }
                if (bIsEmpathy && !bIsCaster) // Empathy by aura, but target is not the caster
                    send_value &= ~UNIT_DYNFLAG_SPECIALINFO;
                }

                *data << send_value;
            }
            else
            {
                // send in current format (float as float, uint32 as uint32)
                *data << m_uint32Values[index];
            }
            ++index;
        }
    }
    else if (isType(TYPEMASK_GAMEOBJECT))                   // gameobject case
    {
        uint16 index = 0;
        while ((index = updateMask->GetNextSetIndex(index)) < m_valuesCount)
        {
            // send in current format (float as float, uint32 as uint32)
            if (index == GAMEOBJECT_DYN_FLAGS)
            {
                if (IsActivateToQuest)
                {
                    switch (((GameObject*)this)->GetGoType())
                    {
                        case GAMEOBJECT_TYPE_QUESTGIVER:
                        case GAMEOBJECT_TYPE_CHEST:
                        case GAMEOBJECT_TYPE_GENERIC:
                        case GAMEOBJECT_TYPE_SPELL_FOCUS:
                        case GAMEOBJECT_TYPE_GOOBER:
                            *data << uint16(GO_DYNFLAG_LO_ACTIVATE);
                            *data << uint16(0);
                            break;
                        default:
                            *data << uint32(0);         // unknown, not happen.
                            break;
                    }
                }
                else
                    { *data << uint32(0); }                 // disable quest object
            }
            else
                { *data << m_uint32Values[index]; }         // other cases
            ++index;
        }
    }
    else                                                    // other objects case (no special index checks)
    {
        uint16 index = 0;
        while ((index = updateMask->GetNextSetIndex(index)) < m_valuesCount)
        {
            // send in current format (float as float, uint32 as uint32)
            *data << m_uint32Values[index];
            ++index;
        }
    }
}

void Object::ClearUpdateMask(bool remove)
{
    if (m_uint32Values)
    {
        for (uint16 index = 0; index < m_valuesCount; ++index)
            { m_changedValues[index] = false; }
    }

    if (m_objectUpdated)
    {
        if (remove)
            { RemoveFromClientUpdateList(); }
        m_objectUpdated = false;
    }
}

bool Object::LoadValues(const char* data)
{
    if (!m_uint32Values) { _InitValues(); }

    Tokens tokens = StrSplit(data, "" "");

    if (tokens.size() != m_valuesCount)
        { return false; }

    Tokens::iterator iter;
    int index;
    for (iter = tokens.begin(), index = 0; index < m_valuesCount; ++iter, ++index)
    {
        m_uint32Values[index] = atol((*iter).c_str());
    }

    return true;
}

void Object::_SetUpdateBits(UpdateMask* updateMask, Player* /*target*/) const
{
    for (uint16 index = 0; index < m_valuesCount; ++index)
        if (m_changedValues[index])
            { updateMask->SetBit(index); }
}

void Object::_SetCreateBits(UpdateMask* updateMask, Player* /*target*/) const
{
    for (uint16 index = 0; index < m_valuesCount; ++index)
        if (GetUInt32Value(index) != 0)
            { updateMask->SetBit(index); }
}

void Object::SetInt32Value(uint16 index, int32 value)
{
    MANGOS_ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    if (m_int32Values[index] != value)
    {
        m_int32Values[index] = value;
        m_changedValues[index] = true;
        MarkForClientUpdate();
    }
}

void Object::SetUInt32Value(uint16 index, uint32 value)
{
    MANGOS_ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    if (m_uint32Values[index] != value)
    {
        m_uint32Values[index] = value;
        m_changedValues[index] = true;
        MarkForClientUpdate();
    }
}

void Object::UpdateUInt32Value(uint16 index, uint32 value)
{
    MANGOS_ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    m_uint32Values[index] = value;
    m_changedValues[index] = true;
}

void Object::SetUInt64Value(uint16 index, const uint64& value)
{
    MANGOS_ASSERT(index + 1 < m_valuesCount || PrintIndexError(index, true));
    if (*((uint64*) & (m_uint32Values[index])) != value)
    {
        m_uint32Values[index] = *((uint32*)&value);
        m_uint32Values[index + 1] = *(((uint32*)&value) + 1);
        m_changedValues[index] = true;
        m_changedValues[index + 1] = true;
        MarkForClientUpdate();
    }
}

void Object::SetFloatValue(uint16 index, float value)
{
    MANGOS_ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    if (m_floatValues[index] != value)
    {
        m_floatValues[index] = value;
        m_changedValues[index] = true;
        MarkForClientUpdate();
    }
}

void Object::SetByteValue(uint16 index, uint8 offset, uint8 value)
{
    MANGOS_ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    if (offset > 4)
    {
        sLog.outError(""Object::SetByteValue: wrong offset %u"", offset);
        return;
    }

    if (uint8(m_uint32Values[index] >> (offset * 8)) != value)
    {
        m_uint32Values[index] &= ~uint32(uint32(0xFF) << (offset * 8));
        m_uint32Values[index] |= uint32(uint32(value) << (offset * 8));
        m_changedValues[index] = true;
        MarkForClientUpdate();
    }
}

void Object::SetUInt16Value(uint16 index, uint8 offset, uint16 value)
{
    MANGOS_ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    if (offset > 2)
    {
        sLog.outError(""Object::SetUInt16Value: wrong offset %u"", offset);
        return;
    }

    if (uint16(m_uint32Values[index] >> (offset * 16)) != value)
    {
        m_uint32Values[index] &= ~uint32(uint32(0xFFFF) << (offset * 16));
        m_uint32Values[index] |= uint32(uint32(value) << (offset * 16));
        m_changedValues[index] = true;
        MarkForClientUpdate();
    }
}

void Object::SetStatFloatValue(uint16 index, float value)
{
    if (value < 0)
        { value = 0.0f; }

    SetFloatValue(index, value);
}

void Object::SetStatInt32Value(uint16 index, int32 value)
{
    if (value < 0)
        { value = 0; }

    SetUInt32Value(index, uint32(value));
}

void Object::ApplyModUInt32Value(uint16 index, int32 val, bool apply)
{
    int32 cur = GetUInt32Value(index);
    cur += (apply ? val : -val);
    if (cur < 0)
        { cur = 0; }
    SetUInt32Value(index, cur);
}

void Object::ApplyModInt32Value(uint16 index, int32 val, bool apply)
{
    int32 cur = GetInt32Value(index);
    cur += (apply ? val : -val);
    SetInt32Value(index, cur);
}

void Object::ApplyModSignedFloatValue(uint16 index, float  val, bool apply)
{
    float cur = GetFloatValue(index);
    cur += (apply ? val : -val);
    SetFloatValue(index, cur);
}

void Object::ApplyModPositiveFloatValue(uint16 index, float  val, bool apply)
{
    float cur = GetFloatValue(index);
    cur += (apply ? val : -val);
    if (cur < 0)
        { cur = 0; }
    SetFloatValue(index, cur);
}

void Object::MarkFlagUpdateForClient(uint16 index)
{
    MANGOS_ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    m_changedValues[index] = true;
    MarkForClientUpdate();
}

void Object::SetFlag(uint16 index, uint32 newFlag)
{
    MANGOS_ASSERT(index < m_valuesCount || PrintIndexError(index, true));
    uint32 oldval = m_uint32Values[index];
    uint32 newval = oldval | newFlag;

    if (oldval != newval)
    {
        m_uint32Values[index] = newval;
        m_changedValues[index] = true;
        MarkForClientUpdate();
    }
}

void Object::RemoveFlag(uint16 index, uint32 oldFlag)
{
    MANGOS_ASSERT(index < m_valuesCount || PrintIndexError(index, true));
    uint32 oldval = m_uint32Values[index];
    uint32 newval = oldval & ~oldFlag;

    if (oldval != newval)
    {
        m_uint32Values[index] = newval;
        m_changedValues[index] = true;
        MarkForClientUpdate();
    }
}

void Object::RemovePlayerSpecificFlag(uint16 index, uint32 oldFlag, Player* plr)
{
    /* Validate input */
    MANGOS_ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    uint32 oldval, newval;

    /* See if we already have custom flags set for the player */
    if (m_plrSpecificFlags.find(plr->GetGUIDLow()) != m_plrSpecificFlags.end())
        { oldval = m_plrSpecificFlags.find(plr->GetGUIDLow())->second; }
    /* We don't already have flags, get them from the creature */
    else
        { oldval = m_uint32Values[index]; }

    /* Set the new flag */
    newval = oldval & ~oldval;

    /* Make sure they're not the same */
    if (oldval != newval)
    {
        /* Update existing flag */
        m_plrSpecificFlags.find(plr->GetGUIDLow())->second = newval;

        /* Push updates to client */
        MarkForClientUpdate();
    }
}

void Object::SetPlayerSpecificFlag(uint16 index, uint32 newFlag, Player* plr)
{
    /* Validate input */
    MANGOS_ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    uint32 oldval, newval;

    /* See if we already have custom flags set for the player */
    if (m_plrSpecificFlags.find(plr->GetGUIDLow()) != m_plrSpecificFlags.end())
        { oldval = m_plrSpecificFlags.find(plr->GetGUIDLow())->second; }
    /* We don't already have flags, get them from the creature */
    else
        { oldval = m_uint32Values[index]; }

    /* Set the new flag */
    newval = oldval | newFlag;

    /* Make sure they're not the same */
    if (oldval != newval)
    {
        /* Update existing flag */
        m_plrSpecificFlags.find(plr->GetGUIDLow())->second = newval;

        /* Push updates to client */
        MarkForClientUpdate();
    }
}

void Object::SetByteFlag(uint16 index, uint8 offset, uint8 newFlag)
{
    MANGOS_ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    if (offset > 4)
    {
        sLog.outError(""Object::SetByteFlag: wrong offset %u"", offset);
        return;
    }

    if (!(uint8(m_uint32Values[index] >> (offset * 8)) & newFlag))
    {
        m_uint32Values[index] |= uint32(uint32(newFlag) << (offset * 8));
        m_changedValues[index] = true;
        MarkForClientUpdate();
    }
}

void Object::RemoveByteFlag(uint16 index, uint8 offset, uint8 oldFlag)
{
    MANGOS_ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    if (offset > 4)
    {
        sLog.outError(""Object::RemoveByteFlag: wrong offset %u"", offset);
        return;
    }

    if (uint8(m_uint32Values[index] >> (offset * 8)) & oldFlag)
    {
        m_uint32Values[index] &= ~uint32(uint32(oldFlag) << (offset * 8));
        m_changedValues[index] = true;
        MarkForClientUpdate();
    }
}

void Object::SetShortFlag(uint16 index, bool highpart, uint16 newFlag)
{
    MANGOS_ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    if (!(uint16(m_uint32Values[index] >> (highpart ? 16 : 0)) & newFlag))
    {
        m_uint32Values[index] |= uint32(uint32(newFlag) << (highpart ? 16 : 0));
        m_changedValues[index] = true;
        MarkForClientUpdate();
    }
}

void Object::RemoveShortFlag(uint16 index, bool highpart, uint16 oldFlag)
{
    MANGOS_ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    if (uint16(m_uint32Values[index] >> (highpart ? 16 : 0)) & oldFlag)
    {
        m_uint32Values[index] &= ~uint32(uint32(oldFlag) << (highpart ? 16 : 0));
        m_changedValues[index] = true;
        MarkForClientUpdate();
    }
}

bool Object::PrintIndexError(uint32 index, bool set) const
{
    sLog.outError(""Attempt %s nonexistent value field: %u (count: %u) for object typeid: %u type mask: %u"", (set ? ""set value to"" : ""get value from""), index, m_valuesCount, GetTypeId(), m_objectType);

    // ASSERT must fail after function call
    return false;
}

bool Object::PrintEntryError(char const* descr) const
{
    sLog.outError(""Object Type %u, Entry %u (lowguid %u) with invalid call for %s"", GetTypeId(), GetEntry(), GetObjectGuid().GetCounter(), descr);

    // always false for continue assert fail
    return false;
}


void Object::BuildUpdateDataForPlayer(Player* pl, UpdateDataMapType& update_players)
{
    UpdateDataMapType::iterator iter = update_players.find(pl);

    if (iter == update_players.end())
    {
        std::pair<UpdateDataMapType::iterator, bool> p = update_players.insert(UpdateDataMapType::value_type(pl, UpdateData()));
        MANGOS_ASSERT(p.second);
        iter = p.first;
    }

    BuildValuesUpdateBlockForPlayer(&iter->second, iter->first);
}

void Object::AddToClientUpdateList()
{
    sLog.outError(""Unexpected call of Object::AddToClientUpdateList for object (TypeId: %u Update fields: %u)"", GetTypeId(), m_valuesCount);
    MANGOS_ASSERT(false);
}

void Object::RemoveFromClientUpdateList()
{
    sLog.outError(""Unexpected call of Object::RemoveFromClientUpdateList for object (TypeId: %u Update fields: %u)"", GetTypeId(), m_valuesCount);
    MANGOS_ASSERT(false);
}

void Object::BuildUpdateData(UpdateDataMapType& /*update_players */)
{
    sLog.outError(""Unexpected call of Object::BuildUpdateData for object (TypeId: %u Update fields: %u)"", GetTypeId(), m_valuesCount);
    MANGOS_ASSERT(false);
}

void Object::MarkForClientUpdate()
{
    if (m_inWorld)
    {
        if (!m_objectUpdated)
        {
            AddToClientUpdateList();
            m_objectUpdated = true;
        }
    }
}

WorldObject::WorldObject() :
#ifdef ENABLE_ELUNA
    elunaEvents(NULL),
#endif /* ENABLE_ELUNA */
    m_currMap(NULL),
    m_mapId(0), m_InstanceId(0),
    m_isActiveObject(false)
{
}

WorldObject::~WorldObject()
{
#ifdef ENABLE_ELUNA
    delete elunaEvents;
    elunaEvents = NULL;
#endif /* ENABLE_ELUNA */
}

void WorldObject::CleanupsBeforeDelete()
{
    RemoveFromWorld();
}

void WorldObject::Update(uint32 update_diff, uint32 /*time_diff*/)
{
#ifdef ENABLE_ELUNA
    elunaEvents->Update(update_diff);
#endif /* ENABLE_ELUNA */
}

void WorldObject::_Create(uint32 guidlow, HighGuid guidhigh)
{
    Object::_Create(guidlow, 0, guidhigh);
}

void WorldObject::Relocate(float x, float y, float z, float orientation)
{
    m_position.x = x;
    m_position.y = y;
    m_position.z = z;
    m_position.o = MapManager::NormalizeOrientation(orientation);

    if (isType(TYPEMASK_UNIT))
        { ((Unit*)this)->m_movementInfo.ChangePosition(x, y, z, orientation); }
}

void WorldObject::Relocate(float x, float y, float z)
{
    m_position.x = x;
    m_position.y = y;
    m_position.z = z;

    if (isType(TYPEMASK_UNIT))
        { ((Unit*)this)->m_movementInfo.ChangePosition(x, y, z, GetOrientation()); }
}

void WorldObject::SetOrientation(float orientation)
{
    m_position.o = MapManager::NormalizeOrientation(orientation);

    if (isType(TYPEMASK_UNIT))
        { ((Unit*)this)->m_movementInfo.ChangeOrientation(orientation); }
}

uint32 WorldObject::GetZoneId() const
{
    return GetTerrain()->GetZoneId(m_position.x, m_position.y, m_position.z);
}

uint32 WorldObject::GetAreaId() const
{
    return GetTerrain()->GetAreaId(m_position.x, m_position.y, m_position.z);
}

void WorldObject::GetZoneAndAreaId(uint32& zoneid, uint32& areaid) const
{
    GetTerrain()->GetZoneAndAreaId(zoneid, areaid, m_position.x, m_position.y, m_position.z);
}

InstanceData* WorldObject::GetInstanceData() const
{
    return GetMap()->GetInstanceData();
}

// slow
float WorldObject::GetDistance(const WorldObject* obj) const
{
    float dx = GetPositionX() - obj->GetPositionX();
    float dy = GetPositionY() - obj->GetPositionY();
    float dz = GetPositionZ() - obj->GetPositionZ();
    float sizefactor = GetObjectBoundingRadius() + obj->GetObjectBoundingRadius();
    float dist = sqrt((dx * dx) + (dy * dy) + (dz * dz)) - sizefactor;
    return (dist > 0 ? dist : 0);
}

float WorldObject::GetDistance2d(float x, float y) const
{
    float dx = GetPositionX() - x;
    float dy = GetPositionY() - y;
    float sizefactor = GetObjectBoundingRadius();
    float dist = sqrt((dx * dx) + (dy * dy)) - sizefactor;
    return (dist > 0 ? dist : 0);
}

float WorldObject::GetDistance(float x, float y, float z) const
{
    float dx = GetPositionX() - x;
    float dy = GetPositionY() - y;
    float dz = GetPositionZ() - z;
    float sizefactor = GetObjectBoundingRadius();
    float dist = sqrt((dx * dx) + (dy * dy) + (dz * dz)) - sizefactor;
    return (dist > 0 ? dist : 0);
}

float WorldObject::GetDistance2d(const WorldObject* obj) const
{
    float dx = GetPositionX() - obj->GetPositionX();
    float dy = GetPositionY() - obj->GetPositionY();
    float sizefactor = GetObjectBoundingRadius() + obj->GetObjectBoundingRadius();
    float dist = sqrt((dx * dx) + (dy * dy)) - sizefactor;
    return (dist > 0 ? dist : 0);
}

float WorldObject::GetDistanceZ(const WorldObject* obj) const
{
    float dz = fabs(GetPositionZ() - obj->GetPositionZ());
    float sizefactor = GetObjectBoundingRadius() + obj->GetObjectBoundingRadius();
    float dist = dz - sizefactor;
    return (dist > 0 ? dist : 0);
}

bool WorldObject::IsWithinDist3d(float x, float y, float z, float dist2compare) const
{
    float dx = GetPositionX() - x;
    float dy = GetPositionY() - y;
    float dz = GetPositionZ() - z;
    float distsq = dx * dx + dy * dy + dz * dz;

    float sizefactor = GetObjectBoundingRadius();
    float maxdist = dist2compare + sizefactor;

    return distsq < maxdist * maxdist;
}

bool WorldObject::IsWithinDist2d(float x, float y, float dist2compare) const
{
    float dx = GetPositionX() - x;
    float dy = GetPositionY() - y;
    float distsq = dx * dx + dy * dy;

    float sizefactor = GetObjectBoundingRadius();
    float maxdist = dist2compare + sizefactor;

    return distsq < maxdist * maxdist;
}

bool WorldObject::_IsWithinDist(WorldObject const* obj, float dist2compare, bool is3D) const
{
    float dx = GetPositionX() - obj->GetPositionX();
    float dy = GetPositionY() - obj->GetPositionY();
    float distsq = dx * dx + dy * dy;
    if (is3D)
    {
        float dz = GetPositionZ() - obj->GetPositionZ();
        distsq += dz * dz;
    }
    float sizefactor = GetObjectBoundingRadius() + obj->GetObjectBoundingRadius();
    float maxdist = dist2compare + sizefactor;

    return distsq < maxdist * maxdist;
}

bool WorldObject::IsWithinLOSInMap(const WorldObject* obj) const
{
    if (!IsInMap(obj)) { return false; }
    float ox, oy, oz;
    obj->GetPosition(ox, oy, oz);
    return(IsWithinLOS(ox, oy, oz));
}

bool WorldObject::IsWithinLOS(float ox, float oy, float oz) const
{
    float x, y, z;
    GetPosition(x, y, z);
    return GetMap()->IsInLineOfSight(x, y, z + 2.0f, ox, oy, oz + 2.0f);
}

bool WorldObject::GetDistanceOrder(WorldObject const* obj1, WorldObject const* obj2, bool is3D /* = true */) const
{
    float dx1 = GetPositionX() - obj1->GetPositionX();
    float dy1 = GetPositionY() - obj1->GetPositionY();
    float distsq1 = dx1 * dx1 + dy1 * dy1;
    if (is3D)
    {
        float dz1 = GetPositionZ() - obj1->GetPositionZ();
        distsq1 += dz1 * dz1;
    }

    float dx2 = GetPositionX() - obj2->GetPositionX();
    float dy2 = GetPositionY() - obj2->GetPositionY();
    float distsq2 = dx2 * dx2 + dy2 * dy2;
    if (is3D)
    {
        float dz2 = GetPositionZ() - obj2->GetPositionZ();
        distsq2 += dz2 * dz2;
    }

    return distsq1 < distsq2;
}

bool WorldObject::IsInRange(WorldObject const* obj, float minRange, float maxRange, bool is3D /* = true */) const
{
    float dx = GetPositionX() - obj->GetPositionX();
    float dy = GetPositionY() - obj->GetPositionY();
    float distsq = dx * dx + dy * dy;
    if (is3D)
    {
        float dz = GetPositionZ() - obj->GetPositionZ();
        distsq += dz * dz;
    }

    float sizefactor = GetObjectBoundingRadius() + obj->GetObjectBoundingRadius();

    // check only for real range
    if (minRange > 0.0f)
    {
        float mindist = minRange + sizefactor;
        if (distsq < mindist * mindist)
            { return false; }
    }

    float maxdist = maxRange + sizefactor;
    return distsq < maxdist * maxdist;
}

bool WorldObject::IsInRange2d(float x, float y, float minRange, float maxRange) const
{
    float dx = GetPositionX() - x;
    float dy = GetPositionY() - y;
    float distsq = dx * dx + dy * dy;

    float sizefactor = GetObjectBoundingRadius();

    // check only for real range
    if (minRange > 0.0f)
    {
        float mindist = minRange + sizefactor;
        if (distsq < mindist * mindist)
            { return false; }
    }

    float maxdist = maxRange + sizefactor;
    return distsq < maxdist * maxdist;
}

bool WorldObject::IsInRange3d(float x, float y, float z, float minRange, float maxRange) const
{
    float dx = GetPositionX() - x;
    float dy = GetPositionY() - y;
    float dz = GetPositionZ() - z;
    float distsq = dx * dx + dy * dy + dz * dz;

    float sizefactor = GetObjectBoundingRadius();

    // check only for real range
    if (minRange > 0.0f)
    {
        float mindist = minRange + sizefactor;
        if (distsq < mindist * mindist)
            { return false; }
    }

    float maxdist = maxRange + sizefactor;
    return distsq < maxdist * maxdist;
}

float WorldObject::GetAngle(const WorldObject* obj) const
{
    if (!obj)
        { return 0.0f; }

    // Rework the assert, when more cases where such a call can happen have been fixed
    // MANGOS_ASSERT(obj != this || PrintEntryError(""GetAngle (for self)""));
    if (obj == this)
    {
        sLog.outError(""INVALID CALL for GetAngle for %s"", obj->GetGuidStr().c_str());
        return 0.0f;
    }
    return GetAngle(obj->GetPositionX(), obj->GetPositionY());
}

// Return angle in range 0..2*pi
float WorldObject::GetAngle(const float x, const float y) const
{
    float dx = x - GetPositionX();
    float dy = y - GetPositionY();

    float ang = atan2(dy, dx);                              // returns value between -Pi..Pi
    ang = (ang >= 0) ? ang : 2 * M_PI_F + ang;
    return ang;
}

bool WorldObject::HasInArc(const float arcangle, const WorldObject* obj) const
{
    // always have self in arc
    if (obj == this)
        { return true; }

    float arc = arcangle;

    // move arc to range 0.. 2*pi
    arc = MapManager::NormalizeOrientation(arc);

    float angle = GetAngle(obj);
    angle -= m_position.o;

    // move angle to range -pi ... +pi
    angle = MapManager::NormalizeOrientation(angle);
    if (angle > M_PI_F)
        { angle -= 2.0f * M_PI_F; }

    float lborder =  -1 * (arc / 2.0f);                     // in range -pi..0
    float rborder = (arc / 2.0f);                           // in range 0..pi
    return ((angle >= lborder) && (angle <= rborder));
}

bool WorldObject::isInFrontInMap(WorldObject const* target, float distance,  float arc) const
{
    return IsWithinDistInMap(target, distance) && HasInArc(arc, target);
}

bool WorldObject::isInBackInMap(WorldObject const* target, float distance, float arc) const
{
    return IsWithinDistInMap(target, distance) && !HasInArc(2 * M_PI_F - arc, target);
}

bool WorldObject::isInFront(WorldObject const* target, float distance,  float arc) const
{
    return IsWithinDist(target, distance) && HasInArc(arc, target);
}

bool WorldObject::isInBack(WorldObject const* target, float distance, float arc) const
{
    return IsWithinDist(target, distance) && !HasInArc(2 * M_PI_F - arc, target);
}

void WorldObject::GetRandomPoint(float x, float y, float z, float distance, float& rand_x, float& rand_y, float& rand_z, float minDist /*=0.0f*/, float const* ori /*=NULL*/) const
{
    if (distance == 0)
    {
        rand_x = x;
        rand_y = y;
        rand_z = z;
        return;
    }

    // angle to face `obj` to `this`
    float angle;
    if (!ori)
        angle = rand_norm_f() * 2 * M_PI_F;
    else
        angle = *ori;

    float new_dist;
    if (minDist == 0.0f)
        new_dist = rand_norm_f() * distance;
    else
        new_dist = minDist + rand_norm_f() * (distance - minDist);

    rand_x = x + new_dist * cos(angle);
    rand_y = y + new_dist * sin(angle);
    rand_z = z;

    MaNGOS::NormalizeMapCoord(rand_x);
    MaNGOS::NormalizeMapCoord(rand_y);
    UpdateGroundPositionZ(rand_x, rand_y, rand_z);          // update to LOS height if available
}

void WorldObject::UpdateGroundPositionZ(float x, float y, float& z) const
{
    float new_z = GetMap()->GetHeight(x, y, z);
    if (new_z > INVALID_HEIGHT)
        { z = new_z + 0.05f; }                                  // just to be sure that we are not a few pixel under the surface
}

void WorldObject::UpdateAllowedPositionZ(float x, float y, float& z, Map* atMap /*=NULL*/) const
{
    if (!atMap)
        atMap = GetMap();

    switch (GetTypeId())
    {
        case TYPEID_UNIT:
        {
            // non fly unit don't must be in air
            // non swim unit must be at ground (mostly speedup, because it don't must be in water and water level check less fast
            if (!((Creature const*)this)->CanFly())
            {
                bool canSwim = ((Creature const*)this)->CanSwim();
                float ground_z = z;
                float max_z = canSwim
                              ? atMap->GetTerrain()->GetWaterOrGroundLevel(x, y, z, &ground_z, !((Unit const*)this)->HasAuraType(SPELL_AURA_WATER_WALK))
                              : ((ground_z = atMap->GetHeight(x, y, z)));
                if (max_z > INVALID_HEIGHT)
                {
                    if (z > max_z)
                        { z = max_z; }
                }
            }
            else
            {
                float ground_z = atMap->GetHeight(x, y, z);
                if (z < ground_z)
                    { z = ground_z; }
            }
            break;
        }
        case TYPEID_PLAYER:
        {
            // for server controlled moves player work same as creature (but it can always swim)
            {
                float ground_z = z;
                float max_z = atMap->GetTerrain()->GetWaterOrGroundLevel(x, y, z, &ground_z, !((Unit const*)this)->HasAuraType(SPELL_AURA_WATER_WALK));
                if (max_z > INVALID_HEIGHT)
                {
                    if (z > max_z)
                        { z = max_z; }
                }
            }
            break;
        }
        default:
        {
            float ground_z = atMap->GetHeight(x, y, z);
            if (ground_z > INVALID_HEIGHT)
                { z = ground_z; }
            break;
        }
    }
}

bool WorldObject::IsPositionValid() const
{
    return MaNGOS::IsValidMapCoord(m_position.x, m_position.y, m_position.z, m_position.o);
}

void WorldObject::MonsterSay(const char* text, uint32 /*language*/, Unit const* target) const
{
    WorldPacket data;
    ChatHandler::BuildChatPacket(data, CHAT_MSG_MONSTER_SAY, text, LANG_UNIVERSAL, CHAT_TAG_NONE, GetObjectGuid(), GetName(),
                                 target ? target->GetObjectGuid() : ObjectGuid(), target ? target->GetName() : """");
    SendMessageToSetInRange(&data, sWorld.getConfig(CONFIG_FLOAT_LISTEN_RANGE_SAY), true);
}

void WorldObject::MonsterYell(const char* text, uint32 /*language*/, Unit const* target) const
{
    WorldPacket data;
    ChatHandler::BuildChatPacket(data, CHAT_MSG_MONSTER_YELL, text, LANG_UNIVERSAL, CHAT_TAG_NONE, GetObjectGuid(), GetName(),
                                 target ? target->GetObjectGuid() : ObjectGuid(), target ? target->GetName() : """");
    SendMessageToSetInRange(&data, sWorld.getConfig(CONFIG_FLOAT_LISTEN_RANGE_YELL), true);
}

void WorldObject::MonsterTextEmote(const char* text, Unit const* target, bool IsBossEmote) const
{
    WorldPacket data;
    ChatHandler::BuildChatPacket(data, IsBossEmote ? CHAT_MSG_RAID_BOSS_EMOTE : CHAT_MSG_MONSTER_EMOTE, text, LANG_UNIVERSAL, CHAT_TAG_NONE, GetObjectGuid(), GetName(),
                                 target ? target->GetObjectGuid() : ObjectGuid(), target ? target->GetName() : """");
    SendMessageToSetInRange(&data, sWorld.getConfig(IsBossEmote ? CONFIG_FLOAT_LISTEN_RANGE_YELL : CONFIG_FLOAT_LISTEN_RANGE_TEXTEMOTE), true);
}

void WorldObject::MonsterWhisper(const char* text, Unit const* target, bool IsBossWhisper) const
{
    if (!target || target->GetTypeId() != TYPEID_PLAYER)
        { return; }

    WorldPacket data;
    ChatHandler::BuildChatPacket(data, IsBossWhisper ? CHAT_MSG_RAID_BOSS_WHISPER : CHAT_MSG_MONSTER_WHISPER, text, LANG_UNIVERSAL, CHAT_TAG_NONE, GetObjectGuid(), GetName(),
                                 target->GetObjectGuid(), target->GetName());
    ((Player*)target)->GetSession()->SendPacket(&data);
}

namespace MaNGOS
{
    class MonsterChatBuilder
    {
        public:
            MonsterChatBuilder(WorldObject const& obj, ChatMsg msgtype, MangosStringLocale const* textData, Language language, Unit const* target)
                : i_object(obj), i_msgtype(msgtype), i_textData(textData), i_language(language), i_target(target) {}
            void operator()(WorldPacket& data, int32 loc_idx)
            {
                char const* text = NULL;
                if ((int32)i_textData->Content.size() > loc_idx + 1 && !i_textData->Content[loc_idx + 1].empty())
                    { text = i_textData->Content[loc_idx + 1].c_str(); }
                else
                    { text = i_textData->Content[0].c_str(); }

                ChatHandler::BuildChatPacket(data, i_msgtype, text, i_language, CHAT_TAG_NONE, i_object.GetObjectGuid(), i_object.GetNameForLocaleIdx(loc_idx),
                                             i_target ? i_target->GetObjectGuid() : ObjectGuid(), i_target ? i_target->GetNameForLocaleIdx(loc_idx) : """");
            }

        private:
            WorldObject const& i_object;
            ChatMsg i_msgtype;
            MangosStringLocale const* i_textData;
            Language i_language;
            Unit const* i_target;
    };
}                                                           // namespace MaNGOS

/// Helper function to create localized around a source
void _DoLocalizedTextAround(WorldObject const* source, MangosStringLocale const* textData, ChatMsg msgtype, Language language, Unit const* target, float range)
{
    MaNGOS::MonsterChatBuilder say_build(*source, msgtype, textData, language, target);
    MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
    MaNGOS::CameraDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> > say_worker(source, range, say_do);
    Cell::VisitWorldObjects(source, say_worker, range);
}

/// Function that sends a text associated to a MangosString
void WorldObject::MonsterText(MangosStringLocale const* textData, Unit const* target) const
{
    MANGOS_ASSERT(textData);

    switch (textData->Type)
    {
        case CHAT_TYPE_SAY:
            _DoLocalizedTextAround(this, textData, CHAT_MSG_MONSTER_SAY, textData->LanguageId, target, sWorld.getConfig(CONFIG_FLOAT_LISTEN_RANGE_SAY));
            break;
        case CHAT_TYPE_YELL:
            _DoLocalizedTextAround(this, textData, CHAT_MSG_MONSTER_YELL, textData->LanguageId, target, sWorld.getConfig(CONFIG_FLOAT_LISTEN_RANGE_YELL));
            break;
        case CHAT_TYPE_TEXT_EMOTE:
            _DoLocalizedTextAround(this, textData, CHAT_MSG_MONSTER_EMOTE, LANG_UNIVERSAL, target, sWorld.getConfig(CONFIG_FLOAT_LISTEN_RANGE_TEXTEMOTE));
            break;
        case CHAT_TYPE_BOSS_EMOTE:
            _DoLocalizedTextAround(this, textData, CHAT_MSG_RAID_BOSS_EMOTE, LANG_UNIVERSAL, target, sWorld.getConfig(CONFIG_FLOAT_LISTEN_RANGE_YELL));
            break;
        case CHAT_TYPE_WHISPER:
        {
            if (!target || target->GetTypeId() != TYPEID_PLAYER)
                { return; }
            MaNGOS::MonsterChatBuilder say_build(*this, CHAT_MSG_MONSTER_WHISPER, textData, LANG_UNIVERSAL, target);
            MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
            say_do((Player*)target);
            break;
        }
        case CHAT_TYPE_BOSS_WHISPER:
        {
            if (!target || target->GetTypeId() != TYPEID_PLAYER)
                { return; }
            MaNGOS::MonsterChatBuilder say_build(*this, CHAT_MSG_RAID_BOSS_WHISPER, textData, LANG_UNIVERSAL, target);
            MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
            say_do((Player*)target);
            break;
        }
        case CHAT_TYPE_ZONE_YELL:
        {
            MaNGOS::MonsterChatBuilder say_build(*this, CHAT_MSG_MONSTER_YELL, textData, textData->LanguageId, target);
            MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
            uint32 zoneid = GetZoneId();
            Map::PlayerList const& pList = GetMap()->GetPlayers();
            for (Map::PlayerList::const_iterator itr = pList.begin(); itr != pList.end(); ++itr)
                if (itr->getSource()->GetZoneId() == zoneid)
                    { say_do(itr->getSource()); }
            break;
        }
    }
}

void WorldObject::SendMessageToSet(WorldPacket* data, bool /*bToSelf*/) const
{
    // if object is in world, map for it already created!
    if (IsInWorld())
        { GetMap()->MessageBroadcast(this, data); }
}

void WorldObject::SendMessageToSetInRange(WorldPacket* data, float dist, bool /*bToSelf*/) const
{
    // if object is in world, map for it already created!
    if (IsInWorld())
        { GetMap()->MessageDistBroadcast(this, data, dist); }
}

void WorldObject::SendMessageToSetExcept(WorldPacket* data, Player const* skipped_receiver) const
{
    // if object is in world, map for it already created!
    if (IsInWorld())
    {
        MaNGOS::MessageDelivererExcept notifier(data, skipped_receiver);
        Cell::VisitWorldObjects(this, notifier, GetMap()->GetVisibilityDistance());
    }
}

void WorldObject::SendObjectDeSpawnAnim(ObjectGuid guid)
{
    WorldPacket data(SMSG_GAMEOBJECT_DESPAWN_ANIM, 8);
    data << ObjectGuid(guid);
    SendMessageToSet(&data, true);
}

void WorldObject::SendGameObjectCustomAnim(ObjectGuid guid, uint32 animId /*= 0*/)
{
    WorldPacket data(SMSG_GAMEOBJECT_CUSTOM_ANIM, 8 + 4);
    data << ObjectGuid(guid);
    data << uint32(animId);
    SendMessageToSet(&data, true);
}

void WorldObject::SetMap(Map* map)
{
    MANGOS_ASSERT(map);
    m_currMap = map;
    // lets save current map's Id/instanceId
    m_mapId = map->GetId();
    m_InstanceId = map->GetInstanceId();

#ifdef ENABLE_ELUNA
    delete elunaEvents;
    // On multithread replace this with a pointer to map's Eluna pointer stored in a map
    elunaEvents = new ElunaEventProcessor(&Eluna::GEluna, this);
#endif
}

void WorldObject::ResetMap()
{
#ifdef ENABLE_ELUNA
    delete elunaEvents;
    elunaEvents = NULL;
#endif

    m_currMap = NULL;
}

TerrainInfo const* WorldObject::GetTerrain() const
{
    MANGOS_ASSERT(m_currMap);
    return m_currMap->GetTerrain();
}

void WorldObject::AddObjectToRemoveList()
{
    GetMap()->AddObjectToRemoveList(this);
}

Creature* WorldObject::SummonCreature(uint32 id, float x, float y, float z, float ang, TempSummonType spwtype, uint32 despwtime, bool asActiveObject)
{
    CreatureInfo const* cinfo = ObjectMgr::GetCreatureTemplate(id);
    if (!cinfo)
    {
        sLog.outErrorDb(""WorldObject::SummonCreature: Creature (Entry: %u) not existed for summoner: %s. "", id, GetGuidStr().c_str());
        return NULL;
    }

    TemporarySummon* pCreature = new TemporarySummon(GetObjectGuid());

    Team team = TEAM_NONE;
    if (GetTypeId() == TYPEID_PLAYER)
        { team = ((Player*)this)->GetTeam(); }

    CreatureCreatePos pos(GetMap(), x, y, z, ang);

    if (x == 0.0f && y == 0.0f && z == 0.0f)
        { pos = CreatureCreatePos(this, GetOrientation(), CONTACT_DISTANCE, ang); }

    if (!pCreature->Create(GetMap()->GenerateLocalLowGuid(cinfo->GetHighGuid()), pos, cinfo, team))
    {
        delete pCreature;
        return NULL;
    }

    pCreature->SetRespawnCoord(pos);

    // Active state set before added to map
    pCreature->SetActiveObjectState(asActiveObject);

    pCreature->Summon(spwtype, despwtime);                  // Also initializes the AI and MMGen

    if (GetTypeId() == TYPEID_UNIT && ((Creature*)this)->AI())
        { ((Creature*)this)->AI()->JustSummoned(pCreature); }

#ifdef ENABLE_ELUNA
    if (Unit* summoner = ToUnit())
        sEluna->OnSummoned(pCreature, summoner);
#endif /* ENABLE_ELUNA */

    // Creature Linking, Initial load is handled like respawn
    if (pCreature->IsLinkingEventTrigger())
        { GetMap()->GetCreatureLinkingHolder()->DoCreatureLinkingEvent(LINKING_EVENT_RESPAWN, pCreature); }

    // return the creature therewith the summoner has access to it
    return pCreature;
}

GameObject* WorldObject::SummonGameObject(uint32 id, float x, float y, float z, float angle, uint32 despwtime)
{
    GameObject* pGameObj = new GameObject;

    Map *map = GetMap();

    if (!map)
        return NULL;

    if (!pGameObj->Create(map->GenerateLocalLowGuid(HIGHGUID_GAMEOBJECT), id, map, x, y, z, angle))
    {
        delete pGameObj;
        return NULL;
    }

    pGameObj->SetRespawnTime(despwtime/IN_MILLISECONDS);

    map->Add(pGameObj);

    return pGameObj;
}

// how much space should be left in front of/ behind a mob that already uses a space
#define OCCUPY_POS_DEPTH_FACTOR                          1.8f

namespace MaNGOS
{
    class NearUsedPosDo
    {
        public:
            NearUsedPosDo(WorldObject const& obj, WorldObject const* searcher, float absAngle, ObjectPosSelector& selector)
                : i_object(obj), i_searcher(searcher), i_absAngle(MapManager::NormalizeOrientation(absAngle)), i_selector(selector) {}

            void operator()(Corpse*) const {}
            void operator()(DynamicObject*) const {}

            void operator()(Creature* c) const
            {
                // skip self or target
                if (c == i_searcher || c == &i_object)
                    { return; }

                float x, y, z;

                if (c->IsStopped() || !c->GetMotionMaster()->GetDestination(x, y, z))
                {
                    x = c->GetPositionX();
                    y = c->GetPositionY();
                }

                add(c, x, y);
            }

            template<class T>
            void operator()(T* u) const
            {
                // skip self or target
                if (u == i_searcher || u == &i_object)
                    { return; }

                float x, y;

                x = u->GetPositionX();
                y = u->GetPositionY();

                add(u, x, y);
            }

            // we must add used pos that can fill places around center
            void add(WorldObject* u, float x, float y) const
            {
                float dx = i_object.GetPositionX() - x;
                float dy = i_object.GetPositionY() - y;
                float dist2d = sqrt((dx * dx) + (dy * dy));

                // It is ok for the objects to require a bit more space
                float delta = u->GetObjectBoundingRadius();
                if (i_selector.m_searchPosFor && i_selector.m_searchPosFor != u)
                    { delta += i_selector.m_searchPosFor->GetObjectBoundingRadius(); }

                delta *= OCCUPY_POS_DEPTH_FACTOR;           // Increase by factor

                // u is too near/far away from i_object. Do not consider it to occupy space
                if (fabs(i_selector.m_searcherDist - dist2d) > delta)
                    { return; }

                float angle = i_object.GetAngle(u) - i_absAngle;

                // move angle to range -pi ... +pi, range before is -2Pi..2Pi
                if (angle > M_PI_F)
                    { angle -= 2.0f * M_PI_F; }
                else if (angle < -M_PI_F)
                    { angle += 2.0f * M_PI_F; }

                i_selector.AddUsedArea(u, angle, dist2d);
            }
        private:
            WorldObject const& i_object;
            WorldObject const* i_searcher;
            float              i_absAngle;
            ObjectPosSelector& i_selector;
    };
}                                                           // namespace MaNGOS

//===================================================================================================

void WorldObject::GetNearPoint2D(float& x, float& y, float distance2d, float absAngle) const
{
    x = GetPositionX() + distance2d * cos(absAngle);
    y = GetPositionY() + distance2d * sin(absAngle);

    MaNGOS::NormalizeMapCoord(x);
    MaNGOS::NormalizeMapCoord(y);
}

void WorldObject::GetNearPoint(WorldObject const* searcher, float& x, float& y, float& z, float searcher_bounding_radius, float distance2d, float absAngle) const
{
    GetNearPoint2D(x, y, distance2d, absAngle);
    const float init_z = z = GetPositionZ();

    // if detection disabled, return first point
    if (!sWorld.getConfig(CONFIG_BOOL_DETECT_POS_COLLISION))
    {
        if (searcher)
            { searcher->UpdateAllowedPositionZ(x, y, z, GetMap()); }      // update to LOS height if available
        else
            { UpdateGroundPositionZ(x, y, z); }
        return;
    }

    // or remember first point
    float first_x = x;
    float first_y = y;
    bool first_los_conflict = false;                        // first point LOS problems

    const float dist = distance2d + searcher_bounding_radius + GetObjectBoundingRadius();

    // prepare selector for work
    ObjectPosSelector selector(GetPositionX(), GetPositionY(), distance2d, searcher_bounding_radius, searcher);

    // adding used positions around object
    {
        MaNGOS::NearUsedPosDo u_do(*this, searcher, absAngle, selector);
        MaNGOS::WorldObjectWorker<MaNGOS::NearUsedPosDo> worker(u_do);

        Cell::VisitAllObjects(this, worker, dist);
    }

    // maybe can just place in primary position
    if (selector.CheckOriginalAngle())
    {
        if (searcher)
            { searcher->UpdateAllowedPositionZ(x, y, z, GetMap()); }      // update to LOS height if available
        else
            { UpdateGroundPositionZ(x, y, z); }

        if (fabs(init_z - z) < dist && IsWithinLOS(x, y, z))
            { return; }

        first_los_conflict = true;                          // first point have LOS problems
    }

    // set first used pos in lists
    selector.InitializeAngle();

    float angle;                                            // candidate of angle for free pos

    // select in positions after current nodes (selection one by one)
    while (selector.NextAngle(angle))                       // angle for free pos
    {
        GetNearPoint2D(x, y, distance2d, absAngle + angle);
        z = GetPositionZ();

        if (searcher)
            { searcher->UpdateAllowedPositionZ(x, y, z, GetMap()); }      // update to LOS height if available
        else
            { UpdateGroundPositionZ(x, y, z); }

        if (fabs(init_z - z) < dist && IsWithinLOS(x, y, z))
            { return; }
    }

    // BAD NEWS: not free pos (or used or have LOS problems)
    // Attempt find _used_ pos without LOS problem
    if (!first_los_conflict)
    {
        x = first_x;
        y = first_y;

        if (searcher)
            { searcher->UpdateAllowedPositionZ(x, y, z, GetMap()); }      // update to LOS height if available
        else
            { UpdateGroundPositionZ(x, y, z); }
        return;
    }

    // set first used pos in lists
    selector.InitializeAngle();

    // select in positions after current nodes (selection one by one)
    while (selector.NextUsedAngle(angle))                   // angle for used pos but maybe without LOS problem
    {
        GetNearPoint2D(x, y, distance2d, absAngle + angle);
        z = GetPositionZ();

        if (searcher)
            { searcher->UpdateAllowedPositionZ(x, y, z, GetMap()); }      // update to LOS height if available
        else
            { UpdateGroundPositionZ(x, y, z); }

        if (fabs(init_z - z) < dist && IsWithinLOS(x, y, z))
            { return; }
    }

    // BAD BAD NEWS: all found pos (free and used) have LOS problem :(
    x = first_x;
    y = first_y;

    if (searcher)
        { searcher->UpdateAllowedPositionZ(x, y, z, GetMap()); }          // update to LOS height if available
    else
        { UpdateGroundPositionZ(x, y, z); }
}

void WorldObject::PlayDistanceSound(uint32 sound_id, Player const* target /*= NULL*/) const
{
    WorldPacket data(SMSG_PLAY_OBJECT_SOUND, 4 + 8);
    data << uint32(sound_id);
    data << GetObjectGuid();
    if (target)
        { target->SendDirectMessage(&data); }
    else
        { SendMessageToSet(&data, true); }
}

void WorldObject::PlayDirectSound(uint32 sound_id, Player const* target /*= NULL*/) const
{
    WorldPacket data(SMSG_PLAY_SOUND, 4);
    data << uint32(sound_id);
    if (target)
        { target->SendDirectMessage(&data); }
    else
        { SendMessageToSet(&data, true); }
}

void WorldObject::PlayMusic(uint32 sound_id, Player const* target /*= NULL*/) const
{
    WorldPacket data(SMSG_PLAY_MUSIC, 4);
    data << uint32(sound_id);
    if (target)
        { target->SendDirectMessage(&data); }
    else
        { SendMessageToSet(&data, true); }
}

void WorldObject::UpdateVisibilityAndView()
{
    GetViewPoint().Call_UpdateVisibilityForOwner();
    UpdateObjectVisibility();
    GetViewPoint().Event_ViewPointVisibilityChanged();
}

void WorldObject::UpdateObjectVisibility()
{
    CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
    Cell cell(p);

    GetMap()->UpdateObjectVisibility(this, cell, p);
}

void WorldObject::AddToClientUpdateList()
{
    GetMap()->AddUpdateObject(this);
}

void WorldObject::RemoveFromClientUpdateList()
{
    GetMap()->RemoveUpdateObject(this);
}

struct WorldObjectChangeAccumulator
{
    UpdateDataMapType& i_updateDatas;
    WorldObject& i_object;
    WorldObjectChangeAccumulator(WorldObject& obj, UpdateDataMapType& d) : i_updateDatas(d), i_object(obj)
    {
        // send self fields changes in another way, otherwise
        // with new camera system when player's camera too far from player, camera wouldn't receive packets and changes from player
        if (i_object.isType(TYPEMASK_PLAYER))
            { i_object.BuildUpdateDataForPlayer((Player*)&i_object, i_updateDatas); }
    }

    void Visit(CameraMapType& m)
    {
        for (CameraMapType::iterator iter = m.begin(); iter != m.end(); ++iter)
        {
            Player* owner = iter->getSource()->GetOwner();
            if (owner != &i_object && owner->HaveAtClient(&i_object))
                { i_object.BuildUpdateDataForPlayer(owner, i_updateDatas); }
        }
    }

    template<class SKIP> void Visit(GridRefManager<SKIP>&) {}
};

void WorldObject::BuildUpdateData(UpdateDataMapType& update_players)
{
    WorldObjectChangeAccumulator notifier(*this, update_players);
    Cell::VisitWorldObjects(this, notifier, GetMap()->GetVisibilityDistance());

    ClearUpdateMask(false);
}

bool WorldObject::IsControlledByPlayer() const
{
    switch (GetTypeId())
    {
        case TYPEID_GAMEOBJECT:
            return ((GameObject*)this)->GetOwnerGuid().IsPlayer();
        case TYPEID_UNIT:
        case TYPEID_PLAYER:
            return ((Unit*)this)->IsCharmerOrOwnerPlayerOrPlayerItself();
        case TYPEID_DYNAMICOBJECT:
            return ((DynamicObject*)this)->GetCasterGuid().IsPlayer();
        case TYPEID_CORPSE:
            return true;
        default:
            return false;
    }
}

bool WorldObject::PrintCoordinatesError(float x, float y, float z, char const* descr) const
{
    sLog.outError(""%s with invalid %s coordinates: mapid = %uu, x = %f, y = %f, z = %f"", GetGuidStr().c_str(), descr, GetMapId(), x, y, z);
    return false;                                           // always false for continue assert fail
}

void WorldObject::SetActiveObjectState(bool active)
{
    if (m_isActiveObject == active || (isType(TYPEMASK_PLAYER) && !active))  // player shouldn't became inactive, never
        { return; }

    if (IsInWorld() && !isType(TYPEMASK_PLAYER))
        // player's update implemented in a different from other active worldobject's way
        // it's considired to use generic way in future
    {
        if (isActiveObject() && !active)
            { GetMap()->RemoveFromActive(this); }
        else if (!isActiveObject() && active)
            { GetMap()->AddToActive(this); }
    }
    m_isActiveObject = active;
}
",16184,True,2516.435163359832,median
"////
DO NOT EDIT THIS FILE. IT WAS GENERATED.
Manual changes to this file will be lost when it is generated again.
Edit the files in the src/main/asciidoc/ directory instead.
////


:jdkversion: 1.8
:github-tag: master
:github-repo: spring-cloud/spring-cloud-stream-binder-rabbit

:github-raw: https://raw.githubusercontent.com/{github-repo}/{github-tag}
:github-code: https://github.com/{github-repo}/tree/{github-tag}

image::https://circleci.com/gh/spring-cloud/spring-cloud-stream-binder-rabbit.svg?style=svg[""CircleCI"", link=""https://circleci.com/gh/spring-cloud/spring-cloud-stream-binder-rabbit""]
image::https://codecov.io/gh/spring-cloud/spring-cloud-stream-binder-rabbit/branch/{github-tag}/graph/badge.svg[""codecov"", link=""https://codecov.io/gh/spring-cloud/spring-cloud-stream-binder-rabbit""]
image::https://badges.gitter.im/spring-cloud/spring-cloud-stream-binder-rabbit.svg[Gitter, link=""https://gitter.im/spring-cloud/spring-cloud-stream-binder-rabbit?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge""]

// ======================================================================================

//= Overview
[partintro]
--
This guide describes the RabbitMQ implementation of the Spring Cloud Stream Binder.
It contains information about its design, usage and configuration options, as well as information on how the Stream Cloud Stream concepts map into RabbitMQ specific constructs.
--

== Usage

To use the RabbitMQ binder, you can add it to your Spring Cloud Stream application, by using the following Maven coordinates:

[source,xml]
----
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-stream-binder-rabbit</artifactId>
</dependency>
----

Alternatively, you can use the Spring Cloud Stream RabbitMQ Starter, as follows:

[source,xml]
----
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
</dependency>
----

== RabbitMQ Binder Overview

The following simplified diagram shows how the RabbitMQ binder operates:

.RabbitMQ Binder
image::{github-raw}/docs/src/main/asciidoc/images/rabbit-binder.png[width=300,scaledwidth=""50%""]

By default, the RabbitMQ Binder implementation maps each destination to a `TopicExchange`.
For each consumer group, a `Queue` is bound to that `TopicExchange`.
Each consumer instance has a corresponding RabbitMQ `Consumer` instance for its group's `Queue`.
For partitioned producers and consumers, the queues are suffixed with the partition index and use the partition index as the routing key.
For anonymous consumers (those with no `group` property), an auto-delete queue (with a randomized unique name) is used.

By using the optional `autoBindDlq` option, you can configure the binder to create and configure dead-letter queues (DLQs) (and a dead-letter exchange `DLX`, as well as routing infrastructure).
By default, the dead letter queue has the name of the destination, appended with `.dlq`.
If retry is enabled (`maxAttempts > 1`), failed messages are delivered to the DLQ after retries are exhausted.
If retry is disabled (`maxAttempts = 1`), you should set `requeueRejected` to `false` (the default) so that failed messages are routed to the DLQ, instead of being re-queued.
In addition, `republishToDlq` causes the binder to publish a failed message to the DLQ (instead of rejecting it).
This feature lets additional information (such as the stack trace in the `x-exception-stacktrace` header) be added to the message in headers.
See the <<spring-cloud-stream-rabbit-frame-max-headroom, `frameMaxHeadroom` property>> for information about truncated stack traces.
This option does not need retry enabled.
You can republish a failed message after just one attempt.
Starting with version 1.2, you can configure the delivery mode of republished messages.
See the <<spring-cloud-stream-rabbit-republish-delivery-mode,`republishDeliveryMode` property>>.

If the stream listener throws an `ImmediateAcknowledgeAmqpException`, the DLQ is bypassed and the message simply discarded.
Starting with version 2.1, this is true regardless of the setting of `republishToDlq`; previously it was only the case when `republishToDlq` was `false`.

IMPORTANT: Setting `requeueRejected` to `true` (with `republishToDlq=false` ) causes the message to be re-queued and redelivered continually, which is likely not what you want unless the reason for the failure is transient.
In general, you should enable retry within the binder by setting `maxAttempts` to greater than one or by setting `republishToDlq` to `true`.

Starting with version 3.1.2, if the consumer is marked as `transacted`, publishing to the DLQ will participate in the transaction.
This allows the transaction to roll back if the publishing fails for some reason (for example, if the user is not authorized to publish to the dead letter exchange).
In addition, if the connection factory is configured for publisher confirms or returns, the publication to the DLQ will wait for the confirmation and check for a returned message.
If a negative acknowledgment or returned message is received, the binder will throw an `AmqpRejectAndDontRequeueException`, allowing the broker to take care of publishing to the DLQ as if the `republishToDlq` property is `false`.

See <<rabbit-binder-properties>> for more information about these properties.

The framework does not provide any standard mechanism to consume dead-letter messages (or to re-route them back to the primary queue).
Some options are described in <<rabbit-dlq-processing>>.

NOTE: When multiple RabbitMQ binders are used in a Spring Cloud Stream application, it is important to disable 'RabbitAutoConfiguration' to avoid the same configuration from `RabbitAutoConfiguration` being applied to the two binders.
You can exclude the class by using the `@SpringBootApplication` annotation.

Starting with version 2.0, the `RabbitMessageChannelBinder` sets the `RabbitTemplate.userPublisherConnection` property to `true` so that the non-transactional producers avoid deadlocks on consumers, which can happen if cached connections are blocked because of a https://www.rabbitmq.com/memory.html[memory alarm] on the broker.

NOTE: Currently, a `multiplex` consumer (a single consumer listening to multiple queues) is only supported for message-driven consumers; polled consumers can only retrieve messages from a single queue.

== Configuration Options

This section contains settings specific to the RabbitMQ Binder and bound channels.

For general binding configuration options and properties, see the https://cloud.spring.io/spring-cloud-static/spring-cloud-stream/current/reference/html/spring-cloud-stream.html#_configuration_options[Spring Cloud Stream core documentation].

[[rabbit-binder-properties]]
=== RabbitMQ Binder Properties

By default, the RabbitMQ binder uses Spring Boot's `ConnectionFactory`.
Conseuqently, it supports all Spring Boot configuration options for RabbitMQ.
(For reference, see the https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#common-application-properties[Spring Boot documentation]).
RabbitMQ configuration options use the `spring.rabbitmq` prefix.

In addition to Spring Boot options, the RabbitMQ binder supports the following properties:

spring.cloud.stream.rabbit.binder.adminAddresses::
A comma-separated list of RabbitMQ management plugin URLs.
Only used when `nodes` contains more than one entry.
Each entry in this list must have a corresponding entry in `spring.rabbitmq.addresses`.
Only needed if you use a RabbitMQ cluster and wish to consume from the node that hosts the queue.
See https://docs.spring.io/spring-amqp/reference/html/_reference.html#queue-affinity[Queue Affinity and the LocalizedQueueConnectionFactory] for more information.
+
Default: empty.
spring.cloud.stream.rabbit.binder.nodes::
A comma-separated list of RabbitMQ node names.
When more than one entry, used to locate the server address where a queue is located.
Each entry in this list must have a corresponding entry in `spring.rabbitmq.addresses`.
Only needed if you use a RabbitMQ cluster and wish to consume from the node that hosts the queue.
See https://docs.spring.io/spring-amqp/reference/html/_reference.html#queue-affinity[Queue Affinity and the LocalizedQueueConnectionFactory] for more information.
+
Default: empty.
spring.cloud.stream.rabbit.binder.compressionLevel::
The compression level for compressed bindings.
See `java.util.zip.Deflater`.
+
Default: `1` (BEST_LEVEL).
spring.cloud.stream.binder.connection-name-prefix::
A connection name prefix used to name the connection(s) created by this binder.
The name is this prefix followed by `#n`, where `n` increments each time a new connection is opened.
+
Default: none (Spring AMQP default).

=== RabbitMQ Consumer Properties

The following properties are available for Rabbit consumers only and must be prefixed with `spring.cloud.stream.rabbit.bindings.<channelName>.consumer.`.

However if the same set of properties needs to be applied to most bindings, to
avoid repetition, Spring Cloud Stream supports setting values for all channels,
in the format of `spring.cloud.stream.rabbit.default.<property>=<value>`.

Also, keep in mind that binding specific property will override its equivalent in the default.

acknowledgeMode::
The acknowledge mode.
+
Default: `AUTO`.
anonymousGroupPrefix::
When the binding has no `group` property, an anonymous, auto-delete queue is bound to the destination exchange.
The default naming stragegy for such queues results in a queue named `anonymous.<base64 representation of a UUID>`.
Set this property to change the prefix to something other than the default.
+
Default: `anonymous.`.
autoBindDlq::
Whether to automatically declare the DLQ and bind it to the binder DLX.
+
Default: `false`.
bindingRoutingKey::
The routing key with which to bind the queue to the exchange (if `bindQueue` is `true`).
Can be multiple keys - see `bindingRoutingKeyDelimiter`.
For partitioned destinations, `-<instanceIndex>` is appended to each key.
+
Default: `#`.
bindingRoutingKeyDelimiter::
When this is not null, 'bindingRoutingKey' is considered to be a list of keys delimited by this value; often a comma is used.
+
Default: `null`.
bindQueue::
Whether to declare the queue and bind it to the destination exchange.
Set it to `false` if you have set up your own infrastructure and have previously created and bound the queue.
+
Default: `true`.
consumerTagPrefix::
Used to create the consumer tag(s); will be appended by `#n` where `n` increments for each consumer created.
Example: `${spring.application.name}-${spring.cloud.stream.bindings.input.group}-${spring.cloud.stream.instance-index}`.
+
Default: none - the broker will generate random consumer tags.
containerType::
Select the type of listener container to be used.
See https://docs.spring.io/spring-amqp/reference/html/_reference.html#choose-container[Choosing a Container] in the Spring AMQP documentation for more information.
+
Default: `simple`
deadLetterQueueName::
The name of the DLQ
+
Default: `prefix+destination.dlq`
deadLetterExchange::
A DLX to assign to the queue.
Relevant only if `autoBindDlq` is `true`.
+
Default: 'prefix+DLX'
deadLetterExchangeType::
The type of the DLX to assign to the queue.
Relevant only if `autoBindDlq` is `true`.
+
Default: 'direct'
deadLetterRoutingKey::
A dead letter routing key to assign to the queue.
Relevant only if `autoBindDlq` is `true`.
+
Default: `destination`
declareDlx::
Whether to declare the dead letter exchange for the destination.
Relevant only if `autoBindDlq` is `true`.
Set to `false` if you have a pre-configured DLX.
+
Default: `true`.
declareExchange::
Whether to declare the exchange for the destination.
+
Default: `true`.
delayedExchange::
Whether to declare the exchange as a `Delayed Message Exchange`.
Requires the delayed message exchange plugin on the broker.
The `x-delayed-type` argument is set to the `exchangeType`.
+
Default: `false`.
dlqBindingArguments::
Arguments applied when binding the dlq to the dead letter exchange; used with `headers` `deadLetterExchangeType` to specify headers to match on.
For example `...dlqBindingArguments.x-match=any`, `...dlqBindingArguments.someHeader=someValue`.
+
Default: empty
dlqDeadLetterExchange::
If a DLQ is declared, a DLX to assign to that queue.
+
Default: `none`
dlqDeadLetterRoutingKey::
If a DLQ is declared, a dead letter routing key to assign to that queue.
+
Default: `none`
dlqExpires::
How long before an unused dead letter queue is deleted (in milliseconds).
+
Default: `no expiration`
dlqLazy::
Declare the dead letter queue with the `x-queue-mode=lazy` argument.
See https://www.rabbitmq.com/lazy-queues.html[""`Lazy Queues`""].
Consider using a policy instead of this setting, because using a policy allows changing the setting without deleting the queue.
+
Default: `false`.
dlqMaxLength::
Maximum number of messages in the dead letter queue.
+
Default: `no limit`
dlqMaxLengthBytes::
Maximum number of total bytes in the dead letter queue from all messages.
+
Default: `no limit`
dlqMaxPriority::
Maximum priority of messages in the dead letter queue (0-255).
+
Default: `none`
dlqOverflowBehavior::
Action to take when `dlqMaxLength` or `dlqMaxLengthBytes` is exceeded; currently `drop-head` or `reject-publish` but refer to the RabbitMQ documentation.
+
Default: `none`
dlqQuorum.deliveryLimit::
When `quorum.enabled=true`, set a delivery limit after which the message is dropped or dead-lettered.
+
Default: none - broker default will apply.
dlqQuorum.enabled::
When true, create a quorum dead letter queue instead of a classic queue.
+
Default: false
dlqQuorum.initialQuorumSize::
When `quorum.enabled=true`, set the initial quorum size.
+
Default: none - broker default will apply.
dlqSingleActiveConsumer::
Set to true to set the `x-single-active-consumer` queue property to true.
+
Default: `false`
dlqTtl::
Default time to live to apply to the dead letter queue when declared (in milliseconds).
+
Default: `no limit`
durableSubscription::
Whether the subscription should be durable.
Only effective if `group` is also set.
+
Default: `true`.
exchangeAutoDelete::
If `declareExchange` is true, whether the exchange should be auto-deleted (that is, removed after the last queue is removed).
+
Default: `true`.
exchangeDurable::
If `declareExchange` is true, whether the exchange should be durable (that is, it survives broker restart).
+
Default: `true`.
exchangeType::
The exchange type: `direct`, `fanout`, `headers` or `topic` for non-partitioned destinations and `direct`, headers or `topic` for partitioned destinations.
+
Default: `topic`.
exclusive::
Whether to create an exclusive consumer.
Concurrency should be 1 when this is `true`.
Often used when strict ordering is required but enabling a hot standby instance to take over after a failure.
See `recoveryInterval`, which controls how often a standby instance attempts to consume.
Consider using `singleActiveConsumer` instead when using RabbitMQ 3.8 or later.
+
Default: `false`.
expires::
How long before an unused queue is deleted (in milliseconds).
+
Default: `no expiration`
failedDeclarationRetryInterval::
The interval (in milliseconds) between attempts to consume from a queue if it is missing.
+
Default: 5000
[[spring-cloud-stream-rabbit-frame-max-headroom]]
frameMaxHeadroom::
The number of bytes to reserve for other headers when adding the stack trace to a DLQ message header.
All headers must fit within the `frame_max` size configured on the broker.
Stack traces can be large; if the size plus this property exceeds `frame_max` then the stack trace will be truncated.
A WARN log will be written; consider increasing the `frame_max` or reducing the stack trace by catching the exception and throwing one with a smaller stack trace.
+
Default: 20000
headerPatterns::
Patterns for headers to be mapped from inbound messages.
+
Default: `['*']` (all headers).
lazy::
Declare the queue with the `x-queue-mode=lazy` argument.
See https://www.rabbitmq.com/lazy-queues.html[""`Lazy Queues`""].
Consider using a policy instead of this setting, because using a policy allows changing the setting without deleting the queue.
+
Default: `false`.
maxConcurrency::
The maximum number of consumers.
Not supported when the `containerType` is `direct`.
+
Default: `1`.
maxLength::
The maximum number of messages in the queue.
+
Default: `no limit`
maxLengthBytes::
The maximum number of total bytes in the queue from all messages.
+
Default: `no limit`
maxPriority::
The maximum priority of messages in the queue (0-255).
+
Default: `none`
missingQueuesFatal::
When the queue cannot be found, whether to treat the condition as fatal and stop the listener container.
Defaults to `false` so that the container keeps trying to consume from the queue -- for example, when using a cluster and the node hosting a non-HA queue is down.
+
Default: `false`
overflowBehavior::
Action to take when `maxLength` or `maxLengthBytes` is exceeded; currently `drop-head` or `reject-publish` but refer to the RabbitMQ documentation.
+
Default: `none`
prefetch::
Prefetch count.
+
Default: `1`.
prefix::
A prefix to be added to the name of the `destination` and queues.
+
Default: """".
queueBindingArguments::
Arguments applied when binding the queue to the exchange; used with `headers` `exchangeType` to specify headers to match on.
For example `...queueBindingArguments.x-match=any`, `...queueBindingArguments.someHeader=someValue`.
+
Default: empty
queueDeclarationRetries::
The number of times to retry consuming from a queue if it is missing.
Relevant only when `missingQueuesFatal` is `true`.
Otherwise, the container keeps retrying indefinitely.
Not supported when the `containerType` is `direct`.
+
Default: `3`
queueNameGroupOnly::
When true, consume from a queue with a name equal to the `group`.
Otherwise the queue name is `destination.group`.
This is useful, for example, when using Spring Cloud Stream to consume from an existing RabbitMQ queue.
+
Default: false.
quorum.deliveryLimit::
When `quorum.enabled=true`, set a delivery limit after which the message is dropped or dead-lettered.
+
Default: none - broker default will apply.
quorum.enabled::
When true, create a quorum queue instead of a classic queue.
+
Default: false
quorum.initialQuorumSize::
When `quorum.enabled=true`, set the initial quorum size.
+
Default: none - broker default will apply.
recoveryInterval::
The interval between connection recovery attempts, in milliseconds.
+
Default: `5000`.
requeueRejected::
Whether delivery failures should be re-queued when retry is disabled or `republishToDlq` is `false`.
+
Default: `false`.
[[spring-cloud-stream-rabbit-republish-delivery-mode]]
republishDeliveryMode::
When `republishToDlq` is `true`, specifies the delivery mode of the republished message.
+
Default: `DeliveryMode.PERSISTENT`
republishToDlq::
By default, messages that fail after retries are exhausted are rejected.
If a dead-letter queue (DLQ) is configured, RabbitMQ routes the failed message (unchanged) to the DLQ.
If set to `true`, the binder republishs failed messages to the DLQ with additional headers, including the exception message and stack trace from the cause of the final failure.
Also see the <<spring-cloud-stream-rabbit-frame-max-headroom, frameMaxHeadroom property>>.
+
Default: `true`
singleActiveConsumer::
Set to true to set the `x-single-active-consumer` queue property to true.
+
Default: `false`
transacted::
Whether to use transacted channels.
+
Default: `false`.
ttl::
Default time to live to apply to the queue when declared (in milliseconds).
+
Default: `no limit`
txSize::
The number of deliveries between acks.
Not supported when the `containerType` is `direct`.
+
Default: `1`.

=== Advanced Listener Container Configuration

To set listener container properties that are not exposed as binder or binding properties, add a single bean of type `ListenerContainerCustomizer` to the application context.
The binder and binding properties will be set and then the customizer will be called.
The customizer (`configure()` method) is provided with the queue name as well as the consumer group as arguments.

=== Advanced Queue/Exchange/Binding Configuration

From time to time, the RabbitMQ team add new features that are enabled by setting some argument when declaring, for example, a queue.
Generally, such features are enabled in the binder by adding appropriate properties, but this may not be immediately available in a current version.
Starting with version 3.0.1, you can now add `DeclarableCustomizer` bean(s) to the application context to modify a `Declarable` (`Queue`, `Exchange` or `Binding`) just before the declaration is performed.
This allows you to add arguments that are not currently directly supported by the binder.

[[rabbit-receiving-batch]]
=== Receiving Batched Messages

With the RabbitMQ binder, there are two types of batches handled by consumer bindings:

==== Batches Created by Producers

Normally, if a producer binding has `batch-enabled=true` (see <<rabbit-prod-props>>), or a message is created by a `BatchingRabbitTemplate`, elements of the batch are returned as individual calls to the listener method.
Starting with version 3.0, any such batch can be presented as a `List<?>` to the listener method if `spring.cloud.stream.bindings.<name>.consumer.batch-mode` is set to `true`.

==== Consumer-side Batching

Starting with version 3.1, the consumer can be configured to assemble multiple inbound messages into a batch which is presented to the application as a `List<?>` of converted payloads.
The following simple application demonstrates how to use this technique:

====
[source, properties]
----
spring.cloud.stream.bindings.input-in-0.group=someGroup

spring.cloud.stream.bindings.input-in-0.consumer.batch-mode=true

spring.cloud.stream.rabbit.bindings.input-in-0.consumer.enable-batching=true
spring.cloud.stream.rabbit.bindings.input-in-0.consumer.batch-size=10
spring.cloud.stream.rabbit.bindings.input-in-0.consumer.receive-timeout=200
----
====

====
[source, java]
----
@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Bean
    Consumer<List<Thing>> input() {
        return list -> {
            System.out.println(""Received "" + list.size());
            list.forEach(thing -> {
                System.out.println(thing);

                // ...

            });
        };
    }

    @Bean
    public ApplicationRunner runner(RabbitTemplate template) {
        return args -> {
            template.convertAndSend(""input-in-0.someGroup"", ""{\\""field\\"":\\""value1\\""}"");
            template.convertAndSend(""input-in-0.someGroup"", ""{\\""field\\"":\\""value2\\""}"");
        };
    }

    public static class Thing {

        private String field;

        public Thing() {
        }

        public Thing(String field) {
            this.field = field;
        }

        public String getField() {
            return this.field;
        }

        public void setField(String field) {
            this.field = field;
        }

        @Override
        public String toString() {
            return ""Thing [field="" + this.field + ""]"";
        }

    }

}
----
====

====
[source]
----
Received 2
Thing [field=value1]
Thing [field=value2]
----
====

The number of messages in a batch is specified by the `batch-size` and `receive-timeout` properties; if the `receive-timeout` elapses with no new messages, a ""short"" batch is delivered.

IMPORTANT: Consumer-side batching is only supported with `container-type=simple` (the default).

If you wish to examine headers of consumer-side batched messages, you should consume `Message<List<?>>`; the headers are a `List<Map<String, Object>>` in a header `AmqpInboundChannelAdapter.CONSOLIDATED_HEADERS`, with the headers for each payload element in the corresponding index.
Again, here is a simple example:

====
[source, java]
----
@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Bean
    Consumer<Message<List<Thing>>> input() {
        return msg -> {
            List<Thing> things = msg.getPayload();
            System.out.println(""Received "" + things.size());
            @SuppressWarnings(""unchecked"")
            List<Map<String, Object>> headers =
                    (List<Map<String, Object>>) msg.getHeaders().get(AmqpInboundChannelAdapter.CONSOLIDATED_HEADERS);
            for (int i = 0; i < things.size(); i++) {
                System.out.println(things.get(i) + "" myHeader="" + headers.get(i).get(""myHeader""));

                // ...

            }
        };
    }

    @Bean
    public ApplicationRunner runner(RabbitTemplate template) {
        return args -> {
            template.convertAndSend(""input-in-0.someGroup"", ""{\\""field\\"":\\""value1\\""}"", msg -> {
                msg.getMessageProperties().setHeader(""myHeader"", ""headerValue1"");
                return msg;
            });
            template.convertAndSend(""input-in-0.someGroup"", ""{\\""field\\"":\\""value2\\""}"", msg -> {
                msg.getMessageProperties().setHeader(""myHeader"", ""headerValue2"");
                return msg;
            });
        };
    }

    public static class Thing {

        private String field;

        public Thing() {
        }

        public Thing(String field) {
            this.field = field;
        }

        public String getfield() {
            return this.field;
        }

        public void setfield(String field) {
            this.field = field;
        }

        @Override
        public String toString() {
            return ""Thing [field="" + this.field + ""]"";
        }

    }

}
----
====

====
[source]
----
Received 2
Thing [field=value1] myHeader=headerValue1
Thing [field=value2] myHeader=headerValue2
----
====

[[rabbit-prod-props]]
=== Rabbit Producer Properties

The following properties are available for Rabbit producers only and must be prefixed with `spring.cloud.stream.rabbit.bindings.<channelName>.producer.`.

However if the same set of properties needs to be applied to most bindings, to
avoid repetition, Spring Cloud Stream supports setting values for all channels,
in the format of `spring.cloud.stream.rabbit.default.<property>=<value>`.

Also, keep in mind that binding specific property will override its equivalent in the default.


autoBindDlq::
Whether to automatically declare the DLQ and bind it to the binder DLX.
+
Default: `false`.
batchingEnabled::
Whether to enable message batching by producers.
Messages are batched into one message according to the following properties (described in the next three entries in this list): 'batchSize', `batchBufferLimit`, and `batchTimeout`.
See https://docs.spring.io/spring-amqp//reference/html/_reference.html#template-batching[Batching] for more information.
Also see <<rabbit-receiving-batch>>.
+
Default: `false`.
batchSize::
The number of messages to buffer when batching is enabled.
+
Default: `100`.
batchBufferLimit::
The maximum buffer size when batching is enabled.
+
Default: `10000`.
batchTimeout::
The batch timeout when batching is enabled.
+
Default: `5000`.
bindingRoutingKey::
The routing key with which to bind the queue to the exchange (if `bindQueue` is `true`).
Can be multiple keys - see `bindingRoutingKeyDelimiter`.
For partitioned destinations, `-n` is appended to each key.
Only applies if `requiredGroups` are provided and then only to those groups.
+
Default: `#`.
bindingRoutingKeyDelimiter::
When this is not null, 'bindingRoutingKey' is considered to be a list of keys delimited by this value; often a comma is used.
Only applies if `requiredGroups` are provided and then only to those groups.
+
Default: `null`.
bindQueue::
Whether to declare the queue and bind it to the destination exchange.
Set it to `false` if you have set up your own infrastructure and have previously created and bound the queue.
Only applies if `requiredGroups` are provided and then only to those groups.
+
Default: `true`.
compress::
Whether data should be compressed when sent.
+
Default: `false`.
confirmAckChannel::
When `errorChannelEnabled` is true, a channel to which to send positive delivery acknowledgments (aka publisher confirms).
If the channel does not exist, a `DirectChannel` is registered with this name.
The connection factory must be configured to enable publisher confirms.
Mutually exclusive with `useConfirmHeader`.
+
Default: `nullChannel` (acks are discarded).
deadLetterQueueName::
The name of the DLQ
Only applies if `requiredGroups` are provided and then only to those groups.
+
Default: `prefix+destination.dlq`
deadLetterExchange::
A DLX to assign to the queue.
Relevant only when `autoBindDlq` is `true`.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: 'prefix+DLX'
deadLetterExchangeType::
The type of the DLX to assign to the queue.
Relevant only if `autoBindDlq` is `true`.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: 'direct'
deadLetterRoutingKey::
A dead letter routing key to assign to the queue.
Relevant only when `autoBindDlq` is `true`.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: `destination`
declareDlx::
Whether to declare the dead letter exchange for the destination.
Relevant only if `autoBindDlq` is `true`.
Set to `false` if you have a pre-configured DLX.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: `true`.
declareExchange::
Whether to declare the exchange for the destination.
+
Default: `true`.
delayExpression::
A SpEL expression to evaluate the delay to apply to the message (`x-delay` header).
It has no effect if the exchange is not a delayed message exchange.
+
Default: No `x-delay` header is set.
delayedExchange::
Whether to declare the exchange as a `Delayed Message Exchange`.
Requires the delayed message exchange plugin on the broker.
The `x-delayed-type` argument is set to the `exchangeType`.
+
Default: `false`.
deliveryMode::
The delivery mode.
+
Default: `PERSISTENT`.
dlqBindingArguments::
Arguments applied when binding the dlq to the dead letter exchange; used with `headers` `deadLetterExchangeType` to specify headers to match on.
For example `...dlqBindingArguments.x-match=any`, `...dlqBindingArguments.someHeader=someValue`.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: empty
dlqDeadLetterExchange::
When a DLQ is declared, a DLX to assign to that queue.
Applies only if `requiredGroups` are provided and then only to those groups.
+
Default: `none`
dlqDeadLetterRoutingKey::
When a DLQ is declared, a dead letter routing key to assign to that queue.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: `none`
dlqExpires::
How long (in milliseconds) before an unused dead letter queue is deleted.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: `no expiration`
dlqLazy::
Declare the dead letter queue with the `x-queue-mode=lazy` argument.
See https://www.rabbitmq.com/lazy-queues.html[""`Lazy Queues`""].
Consider using a policy instead of this setting, because using a policy allows changing the setting without deleting the queue.
Applies only when `requiredGroups` are provided and then only to those groups.
+
dlqMaxLength::
Maximum number of messages in the dead letter queue.
Applies only if `requiredGroups` are provided and then only to those groups.
+
Default: `no limit`
dlqMaxLengthBytes::
Maximum number of total bytes in the dead letter queue from all messages.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: `no limit`
dlqMaxPriority::
Maximum priority of messages in the dead letter queue (0-255)
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: `none`
dlqQuorum.deliveryLimit::
When `quorum.enabled=true`, set a delivery limit after which the message is dropped or dead-lettered.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: none - broker default will apply.
dlqQuorum.enabled::
When true, create a quorum dead letter queue instead of a classic queue.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: false
dlqQuorum.initialQuorumSize::
When `quorum.enabled=true`, set the initial quorum size.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: none - broker default will apply.
dlqSingleActiveConsumer::
Set to true to set the `x-single-active-consumer` queue property to true.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: `false`
dlqTtl::
Default time (in milliseconds) to live to apply to the dead letter queue when declared.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: `no limit`
exchangeAutoDelete::
If `declareExchange` is `true`, whether the exchange should be auto-delete (it is removed after the last queue is removed).
+
Default: `true`.
exchangeDurable::
If `declareExchange` is `true`, whether the exchange should be durable (survives broker restart).
+
Default: `true`.
exchangeType::
The exchange type: `direct`, `fanout`, `headers` or `topic` for non-partitioned destinations and `direct`, `headers` or `topic` for partitioned destinations.
+
Default: `topic`.
expires::
How long (in milliseconds) before an unused queue is deleted.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: `no expiration`
headerPatterns::
Patterns for headers to be mapped to outbound messages.
+
Default: `['*']` (all headers).
lazy::
Declare the queue with the `x-queue-mode=lazy` argument.
See https://www.rabbitmq.com/lazy-queues.html[""`Lazy Queues`""].
Consider using a policy instead of this setting, because using a policy allows changing the setting without deleting the queue.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: `false`.
maxLength::
Maximum number of messages in the queue.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: `no limit`
maxLengthBytes::
Maximum number of total bytes in the queue from all messages.
Only applies if `requiredGroups` are provided and then only to those groups.
+
Default: `no limit`
maxPriority::
Maximum priority of messages in the queue (0-255).
Only applies if `requiredGroups` are provided and then only to those groups.
+
Default: `none`
prefix::
A prefix to be added to the name of the `destination` exchange.
+
Default: """".
queueBindingArguments::
Arguments applied when binding the queue to the exchange; used with `headers` `exchangeType` to specify headers to match on.
For example `...queueBindingArguments.x-match=any`, `...queueBindingArguments.someHeader=someValue`.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: empty
queueNameGroupOnly::
When `true`, consume from a queue with a name equal to the `group`.
Otherwise the queue name is `destination.group`.
This is useful, for example, when using Spring Cloud Stream to consume from an existing RabbitMQ queue.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: false.
quorum.deliveryLimit::
When `quorum.enabled=true`, set a delivery limit after which the message is dropped or dead-lettered.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: none - broker default will apply.
quorum.enabled::
When true, create a quorum queue instead of a classic queue.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: false
quorum.initialQuorumSize::
When `quorum.enabled=true`, set the initial quorum size.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: none - broker default will apply.
routingKeyExpression::
A SpEL expression to determine the routing key to use when publishing messages.
For a fixed routing key, use a literal expression, such as `routingKeyExpression='my.routingKey'` in a properties file or `routingKeyExpression: '''my.routingKey'''` in a YAML file.
+
Default: `destination` or `destination-<partition>` for partitioned destinations.
singleActiveConsumer::
Set to true to set the `x-single-active-consumer` queue property to true.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: `false`
transacted::
Whether to use transacted channels.
+
Default: `false`.
ttl::
Default time (in milliseconds) to live to apply to the queue when declared.
Applies only when `requiredGroups` are provided and then only to those groups.
+
Default: `no limit`
useConfirmHeader::
See <<publisher-confirms>>.
Mutually exclusive with `confirmAckChannel`.
+

NOTE: In the case of RabbitMQ, content type headers can be set by external applications.
Spring Cloud Stream supports them as part of an extended internal protocol used for any type of transport -- including transports, such as Kafka (prior to 0.11), that do not natively support headers.

[[publisher-confirms]]
=== Publisher Confirms

There are two mechanisms to get the result of publishing a message; in each case, the connection factory must have `publisherConfirmType` set `ConfirmType.CORRELATED`.
The ""legacy"" mechanism is to set the `confirmAckChannel` to the bean name of a message channel from which you can retrieve the confirmations asynchronously; negative acks are sent to the error channel (if enabled) - see <<rabbit-error-channels>>.

The preferred mechanism, added in version 3.1 is to use a correlation data header and wait for the result via its `Future<Confirm>` property.
This is particularly useful with a batch listener because you can send multiple messages before waiting for the result.
To use this technique, set the `useConfirmHeader` property to true
The following simple application is an example of using this technique:

====
[source, properties]
----
spring.cloud.stream.bindings.input-in-0.group=someGroup
spring.cloud.stream.bindings.input-in-0.consumer.batch-mode=true

spring.cloud.stream.source=output
spring.cloud.stream.bindings.output-out-0.producer.error-channel-enabled=true

spring.cloud.stream.rabbit.bindings.output-out-0.producer.useConfirmHeader=true
spring.cloud.stream.rabbit.bindings.input-in-0.consumer.auto-bind-dlq=true
spring.cloud.stream.rabbit.bindings.input-in-0.consumer.batch-size=10

spring.rabbitmq.publisher-confirm-type=correlated
spring.rabbitmq.publisher-returns=true
----
====

====
[source, java]
----
@SpringBootApplication
public class Application {

    private static final Logger log = LoggerFactory.getLogger(Application.class);

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Autowired
    private StreamBridge bridge;

    @Bean
    Consumer<List<String>> input() {
        return list -> {
            List<MyCorrelationData> results = new ArrayList<>();
            list.forEach(str -> {
                log.info(""Received: "" + str);
                MyCorrelationData corr = new MyCorrelationData(UUID.randomUUID().toString(), str);
                results.add(corr);
                this.bridge.send(""output-out-0"", MessageBuilder.withPayload(str.toUpperCase())
                        .setHeader(AmqpHeaders.PUBLISH_CONFIRM_CORRELATION, corr)
                        .build());
            });
            results.forEach(correlation -> {
                try {
                    Confirm confirm = correlation.getFuture().get(10, TimeUnit.SECONDS);
                    log.info(confirm + "" for "" + correlation.getPayload());
                    if (correlation.getReturnedMessage() != null) {
                        log.error(""Message for "" + correlation.getPayload() + "" was returned "");

                        // try to re-publish, send a DLQ, etc

                    }
                }
                catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    e.printStackTrace();
                }
                catch (ExecutionException | TimeoutException e) {
                    e.printStackTrace();
                }
            });
        };
    }


    @Bean
    public ApplicationRunner runner(BatchingRabbitTemplate template) {
        return args -> IntStream.range(0, 10).forEach(i ->
                template.convertAndSend(""input-in-0"", ""input-in-0.rbgh303"", ""foo"" + i));
    }

    @Bean
    public BatchingRabbitTemplate template(CachingConnectionFactory cf, TaskScheduler taskScheduler) {
        BatchingStrategy batchingStrategy = new SimpleBatchingStrategy(10, 1000000, 1000);
        return new BatchingRabbitTemplate(cf, batchingStrategy, taskScheduler);
    }

}

class MyCorrelationData extends CorrelationData {

    private final String payload;

    MyCorrelationData(String id, String payload) {
        super(id);
        this.payload = payload;
    }

    public String getPayload() {
        return this.payload;
    }

}
----
====

As you can see, we send each message and then await for the publication results.
If the messages can't be routed, then correlation data is populated with the returned message before the future is completed.

IMPORTANT: The correlation data must be provided with a unique `id` so that the framework can perform the correlation.

You cannot set both `useConfirmHeader` and `confirmAckChannel` but you can still receive returned messages in the error channel when `useConfirmHeader` is true, but using the correlation header is more convenient.

== Using Existing Queues/Exchanges

By default, the binder will automatically provision a topic exchange with the name being derived from the value of the destination binding property `<prefix><destination>`.
The destination defaults to the binding name, if not provided.
When binding a consumer, a queue will automatically be provisioned with the name `<prefix><destination>.<group>` (if a `group` binding property is specified), or an anonymous, auto-delete queue when there is no `group`.
The queue will be bound to the exchange with the ""match-all"" wildcard routing key (`#`) for a non-partitioned binding or `<destination>-<instanceIndex>` for a partitioned binding.
The prefix is an empty `String` by default.
If an output binding is specified with `requiredGroups`, a queue/binding will be provisioned for each group.

There are a number of rabbit-specific binding properties that allow you to modify this default behavior.

If you have an existing exchange/queue that you wish to use, you can completely disable automatic provisioning as follows, assuming the exchange is named `myExchange` and the queue is named `myQueue`:

* `spring.cloud.stream.bindings.<binding name>.destination=myExhange`
* `spring.cloud.stream.bindings.<binding name>.group=myQueue`
* `spring.cloud.stream.rabbit.bindings.<binding name>.consumer.bindQueue=false`
* `spring.cloud.stream.rabbit.bindings.<binding name>.consumer.declareExchange=false`
* `spring.cloud.stream.rabbit.bindings.<binding name>.consumer.queueNameGroupOnly=true`

If you want the binder to provision the queue/exchange, but you want to do it using something other than the defaults discussed here, use the following properties.
Refer to the property documentation above for more information.

* `spring.cloud.stream.rabbit.bindings.<binding name>.consumer.bindingRoutingKey=myRoutingKey`
* `spring.cloud.stream.rabbit.bindings.<binding name>.consumer.exchangeType=<type>`

* `spring.cloud.stream.rabbit.bindings.<binding name>.producer.routingKeyExpression='myRoutingKey'`

There are similar properties used when declaring a dead-letter exchange/queue, when `autoBindDlq` is `true`.

== Retry With the RabbitMQ Binder

When retry is enabled within the binder, the listener container thread is suspended for any back off periods that are configured.
This might be important when strict ordering is required with a single consumer. However, for other use cases, it prevents other messages from being processed on that thread.
An alternative to using binder retry is to set up dead lettering with time to live on the dead-letter queue (DLQ) as well as dead-letter configuration on the DLQ itself.
See ""`<<rabbit-binder-properties>>`"" for more information about the properties discussed here.
You can use the following example configuration to enable this feature:

* Set `autoBindDlq` to `true`.
The binder create a DLQ.
Optionally, you can specify a name in `deadLetterQueueName`.
* Set `dlqTtl` to the back off time you want to wait between redeliveries.
* Set the `dlqDeadLetterExchange` to the default exchange.
Expired messages from the DLQ are routed to the original queue, because the default `deadLetterRoutingKey` is the queue name (`destination.group`).
Setting to the default exchange is achieved by setting the property with no value, as shown in the next example.

To force a message to be dead-lettered, either throw an `AmqpRejectAndDontRequeueException` or set `requeueRejected` to `false` (the default) and throw any exception.

The loop continue without end, which is fine for transient problems, but you may want to give up after some number of attempts.
Fortunately, RabbitMQ provides the `x-death` header, which lets you determine how many cycles have occurred.

To acknowledge a message after giving up, throw an `ImmediateAcknowledgeAmqpException`.

=== Putting it All Together

The following configuration creates an exchange `myDestination` with queue `myDestination.consumerGroup` bound to a topic exchange with a wildcard routing key `#`:

[source]
---
spring.cloud.stream.bindings.input.destination=myDestination
spring.cloud.stream.bindings.input.group=consumerGroup
#disable binder retries
spring.cloud.stream.bindings.input.consumer.max-attempts=1
#dlx/dlq setup
spring.cloud.stream.rabbit.bindings.input.consumer.auto-bind-dlq=true
spring.cloud.stream.rabbit.bindings.input.consumer.dlq-ttl=5000
spring.cloud.stream.rabbit.bindings.input.consumer.dlq-dead-letter-exchange=
---

This configuration creates a DLQ bound to a direct exchange (`DLX`) with a routing key of `myDestination.consumerGroup`.
When messages are rejected, they are routed to the DLQ.
After 5 seconds, the message expires and is routed to the original queue by using the queue name as the routing key, as shown in the following example:

.Spring Boot application
[source, java]
----
@SpringBootApplication
@EnableBinding(Sink.class)
public class XDeathApplication {

    public static void main(String[] args) {
        SpringApplication.run(XDeathApplication.class, args);
    }

    @StreamListener(Sink.INPUT)
    public void listen(String in, @Header(name = ""x-death"", required = false) Map<?,?> death) {
        if (death != null && death.get(""count"").equals(3L)) {
            // giving up - don't send to DLX
            throw new ImmediateAcknowledgeAmqpException(""Failed after 4 attempts"");
        }
        throw new AmqpRejectAndDontRequeueException(""failed"");
    }

}
----

Notice that the count property in the `x-death` header is a `Long`.

[[rabbit-error-channels]]
== Error Channels

Starting with version 1.3, the binder unconditionally sends exceptions to an error channel for each consumer destination and can also be configured to send async producer send failures to an error channel.
See ""`<<spring-cloud-stream-overview-error-handling>>`"" for more information.

RabbitMQ has two types of send failures:

* Returned messages,
* Negatively acknowledged https://www.rabbitmq.com/confirms.html[Publisher Confirms].

The latter is rare.
According to the RabbitMQ documentation ""[A nack] will only be delivered if an internal error occurs in the Erlang process responsible for a queue."".
You can also get a negative acknowledgment if you publish to a bounded queue with `reject-publish` queue overflow behavior.

As well as enabling producer error channels (as described in ""`<<spring-cloud-stream-overview-error-handling>>`""), the RabbitMQ binder only sends messages to the channels if the connection factory is appropriately configured, as follows:

* `ccf.setPublisherConfirms(true);`
* `ccf.setPublisherReturns(true);`

When using Spring Boot configuration for the connection factory, set the following properties:

* `spring.rabbitmq.publisher-confirms`
* `spring.rabbitmq.publisher-returns`

The payload of the `ErrorMessage` for a returned message is a `ReturnedAmqpMessageException` with the following properties:

* `failedMessage`: The spring-messaging `Message<?>` that failed to be sent.
* `amqpMessage`: The raw spring-amqp `Message`.
* `replyCode`: An integer value indicating the reason for the failure (for example, 312 - No route).
* `replyText`: A text value indicating the reason for the failure (for example, `NO_ROUTE`).
* `exchange`: The exchange to which the message was published.
* `routingKey`: The routing key used when the message was published.

Also see <<publisher-confirms>> for an alternative mechanism to receive returned messages.

For negatively acknowledged confirmations, the payload is a `NackedAmqpMessageException` with the following properties:

* `failedMessage`: The spring-messaging `Message<?>` that failed to be sent.
* `nackReason`: A reason (if available -- you may need to examine the broker logs for more information).

There is no automatic handling of these exceptions (such as sending to a <<rabbit-dlq-processing, dead-letter queue>>).
You can consume these exceptions with your own Spring Integration flow.

= Appendices
[appendix]
[[building]]
== Building

:jdkversion: 1.8

=== Basic Compile and Test

To build the source you will need to install JDK {jdkversion}.

The build uses the Maven wrapper so you don't have to install a specific
version of Maven. To enable the tests, you should have RabbitMQ server running
on localhost and the default port (5672)
before building.

The main build command is

----
$ ./mvnw clean install
----

You can also add '-DskipTests' if you like, to avoid running the tests.

NOTE: You can also install Maven (>=3.3.3) yourself and run the `mvn` command
in place of `./mvnw` in the examples below. If you do that you also
might need to add `-P spring` if your local Maven settings do not
contain repository declarations for spring pre-release artifacts.

NOTE: Be aware that you might need to increase the amount of memory
available to Maven by setting a `MAVEN_OPTS` environment variable with
a value like `-Xmx512m -XX:MaxPermSize=128m`. We try to cover this in
the `.mvn` configuration, so if you find you have to do it to make a
build succeed, please raise a ticket to get the settings added to
source control.


The projects that require middleware generally include a
`docker-compose.yml`, so consider using
https://compose.docker.io/[Docker Compose] to run the middeware servers
in Docker containers.

=== Documentation

There is a ""docs"" profile that will generate documentation.

`./mvnw clean package -Pdocs -DskipTests`

The reference documentation can then be found in `docs/target/contents/reference`.

=== Working with the code
If you don't have an IDE preference we would recommend that you use
https://www.springsource.com/developer/sts[Spring Tools Suite] or
https://eclipse.org[Eclipse] when working with the code. We use the
https://eclipse.org/m2e/[m2eclipe] eclipse plugin for maven support. Other IDEs and tools
should also work without issue.

==== Importing into eclipse with m2eclipse
We recommend the https://eclipse.org/m2e/[m2eclipe] eclipse plugin when working with
eclipse. If you don't already have m2eclipse installed it is available from the ""eclipse
marketplace"".

Unfortunately m2e does not yet support Maven 3.3, so once the projects
are imported into Eclipse you will also need to tell m2eclipse to use
the `.settings.xml` file for the projects.  If you do not do this you
may see many different errors related to the POMs in the
projects.  Open your Eclipse preferences, expand the Maven
preferences, and select User Settings.  In the User Settings field
click Browse and navigate to the Spring Cloud project you imported
selecting the `.settings.xml` file in that project.  Click Apply and
then OK to save the preference changes.

NOTE: Alternatively you can copy the repository settings from https://github.com/spring-cloud/spring-cloud-build/blob/master/.settings.xml[`.settings.xml`] into your own `~/.m2/settings.xml`.

==== Importing into eclipse without m2eclipse
If you prefer not to use m2eclipse you can generate eclipse project metadata using the
following command:

[indent=0]
----
	$ ./mvnw eclipse:eclipse
----

The generated eclipse projects can be imported by selecting `import existing projects`
from the `file` menu.
[[contributing]]
== Contributing

Spring Cloud is released under the non-restrictive Apache 2.0 license,
and follows a very standard Github development process, using Github
tracker for issues and merging pull requests into master. If you want
to contribute even something trivial please do not hesitate, but
follow the guidelines below.

=== Sign the Contributor License Agreement
Before we accept a non-trivial patch or pull request we will need you to sign the
https://support.springsource.com/spring_committer_signup[contributor's agreement].
Signing the contributor's agreement does not grant anyone commit rights to the main
repository, but it does mean that we can accept your contributions, and you will get an
author credit if we do.  Active contributors might be asked to join the core team, and
given the ability to merge pull requests.

=== Code Conventions and Housekeeping
None of these is essential for a pull request, but they will all help.  They can also be
added after the original pull request but before a merge.

* Use the Spring Framework code format conventions. If you use Eclipse
  you can import formatter settings using the
  `eclipse-code-formatter.xml` file from the
  https://github.com/spring-cloud/build/tree/master/eclipse-coding-conventions.xml[Spring
  Cloud Build] project. If using IntelliJ, you can use the
  https://plugins.jetbrains.com/plugin/6546[Eclipse Code Formatter
  Plugin] to import the same file.
* Make sure all new `.java` files to have a simple Javadoc class comment with at least an
  `@author` tag identifying you, and preferably at least a paragraph on what the class is
  for.
* Add the ASF license header comment to all new `.java` files (copy from existing files
  in the project)
* Add yourself as an `@author` to the .java files that you modify substantially (more
  than cosmetic changes).
* Add some Javadocs and, if you change the namespace, some XSD doc elements.
* A few unit tests would help a lot as well -- someone has to do it.
* If no-one else is using your branch, please rebase it against the current master (or
  other target branch in the main project).
* When writing a commit message please follow https://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html[these conventions],
  if you are fixing an existing issue please add `Fixes gh-XXXX` at the end of the commit
  message (where XXXX is the issue number).

// ======================================================================================
",12267,False,2251.628537579598,median
"[[webflux]]
= Spring WebFlux




[[webflux-introduction]]
== Introduction
The original web framework included in the Spring Framework, Spring Web MVC, was purpose
built for the Servlet API and Servlet containers. The reactive stack, web framework,
Spring WebFlux, was added later in version 5.0. It is fully non-blocking, supports
http://www.reactive-streams.org/[Reactive Streams] back pressure, and runs on servers such as
Netty, Undertow, and Servlet 3.1+ containers.

Both web frameworks mirror the names of their source modules
https://github.com/spring-projects/spring-framework/tree/master/spring-webmvc[spring-webmvc] and
https://github.com/spring-projects/spring-framework/tree/master/spring-webflux[spring-webflux]
and co-exist side by side in the Spring Framework. Each module is optional.
Applications may use one or the other module, or in some cases both --
e.g. Spring MVC controllers with the reactive `WebClient`.



[[webflux-new-framework]]
=== Why a new web framework?

Part of the answer is the need for a non-blocking web stack to handle concurrency with a
small number of threads and scale with less hardware resources. Servlet 3.1 did provide
an API for non-blocking I/O. However, using it leads away from the rest of the Servlet API
where contracts are synchronous (`Filter`, `Servlet`) or blocking (`getParameter`,
`getPart`). This was the motivation for a new common API to serve as a foundation across
any non-blocking runtime. That is important because of servers such as Netty that are well
established in the async, non-blocking space.

The other part of the answer is functional programming. Much like the addition of annotations
in Java 5 created opportunities -- e.g. annotated REST controllers or unit tests, the addition
of lambda expressions in Java 8 created opportunities for functional APIs in Java.
This is a boon for non-blocking applications and continuation style APIs -- as popularized
by `CompletableFuture` and http://reactivex.io/[ReactiveX], that allow declarative
composition of asynchronous logic. At the programming model level Java 8 enabled Spring
WebFlux to offer functional web endpoints alongside with annotated controllers.



[[webflux-why-reactive]]
=== Reactive: what and why?

We touched on non-blocking and functional but why reactive and what do we mean?

The term ""reactive"" refers to programming models that are built around reacting to change --
network component reacting to I/O events, UI controller reacting to mouse events, etc.
In that sense non-blocking is reactive because instead of being blocked we are now in the mode
of reacting to notifications as operations complete or data becomes available.

There is also another important mechanism that we on the Spring team associate with ""reactive""
and that is non-blocking back pressure. In synchronous, imperative code, blocking calls
serve as a natural form of back pressure that forces the caller to wait. In non-blocking
code it becomes important to control the rate of events so that a fast producer does not
overwhelm its destination.

Reactive Streams is a
https://github.com/reactive-streams/reactive-streams-jvm/blob/v1.0.1/README.md#specification[small spec],
also http://download.java.net/java/jdk9/docs/api/java/util/concurrent/Flow.html[adopted] in Java 9,
that defines the interaction between asynchronous components with back pressure.
For example a data repository -- acting as
http://www.reactive-streams.org/reactive-streams-1.0.1-javadoc/org/reactivestreams/Publisher.html[Publisher],
can produce data that an HTTP server -- acting as
http://www.reactive-streams.org/reactive-streams-1.0.1-javadoc/org/reactivestreams/Subscriber.html[Subscriber],
can then write to the response. The main purpose of Reactive Streams is to allow the
subscriber to control how fast or how slow the publisher will produce data.

[NOTE]
====
*Common question: what if a publisher can't slow down?* +
The purpose of Reactive Streams is only to establish the mechanism and a boundary.
If a publisher can't slow down then it has to decide whether to buffer, drop, or fail.
====



[[webflux-reactive-api]]
=== Reactive API

Reactive Streams plays an important role for interoperability. It is of interest to libraries
and infrastructure components but less useful as an application API because it is too
low level. What applications need is a higher level and richer, functional API to
compose async logic -- similar to the Java 8 `Stream` API but not only for collections.
This is the role that reactive libraries play.

https://github.com/reactor/reactor[Reactor] is the reactive library of choice for
Spring WebFlux. It provides the
https://projectreactor.io/docs/core/release/api/reactor/core/publisher/Mono.html[Mono] and
https://projectreactor.io/docs/core/release/api/reactor/core/publisher/Flux.html[Flux] API types
to work on data sequences of 0..1 and 0..N through a rich set of operators aligned with the
ReactiveX http://reactivex.io/documentation/operators.html[vocabulary of operators].
Reactor is a Reactive Streams library and therefore all of its operators support non-blocking back pressure.
Reactor has a strong focus on server-side Java. It is developed in close collaboration
with Spring.

WebFlux requires Reactor as a core dependency but it is interoperable with other reactive
libraries via Reactive Streams. As a general rule WebFlux APIs accept a plain `Publisher`
as input, adapt it to Reactor types internally, use those, and then return either
`Flux` or `Mono` as output. So you can pass any `Publisher` as input and you can apply
operations on the output, but you'll need to adapt the output for use with another reactive library.
Whenever feasible -- e.g. annotated controllers, WebFlux adapts transparently to the use
of RxJava or other reactive library. See <<webflux-reactive-libraries>> for more details.



[[webflux-programming-models]]
=== Programming models

The `spring-web` module contains the reactive foundation that underlies Spring WebFlux --
HTTP abstractions, Reactive Streams server adapters, reactive codecs, and a
core Web API whose role is comparable to the Servlet API but with non-blocking semantics.

On that foundation Spring WebFlux provides a choice of two programming models:

- <<webflux-controller>> -- consistent with Spring MVC, and based on the same annotations
from the `spring-web` module. Both Spring MVC and WebFlux controllers support reactive
(Reactor, RxJava) return types and as a result it is not easy to tell them apart. One notable
difference is that WebFlux also supports reactive `@RequestBody` arguments.
- <<webflux-fn>> -- lambda-based, lightweight, functional programming model. Think of
this as a small library or a set of utilities that an application can use to route and
handle requests. The big difference with annotated controllers is that the application
is in charge of request handling from start to finish vs declaring intent through
annotations and being called back.



[[webflux-framework-choice]]
=== Choosing a web framework

Should you use Spring MVC or WebFlux? Let's cover a few different perspectives.

If you have a Spring MVC application that works fine, there is no need to change.
Imperative programming is the easiest way to write, understand, and debug code.
You have maximum choice of libraries since historically most are blocking.

If you are already shopping for a non-blocking web stack, Spring WebFlux offers the same
execution model benefits as others in this space and also provides a choice of servers --
Netty, Tomcat, Jetty, Undertow, Servlet 3.1+ containers, a choice of programming models --
annotated controllers and functional web endpoints, and a choice of reactive libraries --
Reactor, RxJava, or other.

If you are interested in a lightweight, functional web framework for use with Java 8 lambdas
or Kotlin then use the Spring WebFlux functional web endpoints. That can also be a good choice
for smaller applications or microservices with less complex requirements that can benefit
from greater transparency and control.

In a microservice architecture you can have a mix of applications with either Spring MVC
or Spring WebFlux controllers, or with Spring WebFlux functional endpoints. Having support
for the same annotation-based programming model in both frameworks makes it easier to
re-use knowledge while also selecting the right tool for the right job.

A simple way to evaluate an application is to check its dependencies. If you have blocking
persistence APIs (JPA, JDBC), or networking APIs to use, then Spring MVC is the best choice
for common architectures at least. It is technically feasible with both Reactor and
RxJava to perform blocking calls on a separate thread but you wouldn't be making the
most of a non-blocking web stack.

If you have a Spring MVC application with calls to remote services, try the reactive `WebClient`.
You can return reactive types (Reactor, RxJava, <<webflux-reactive-libraries,or other>>)
directly from Spring MVC controller methods. The greater the latency per call, or the
interdependency among calls, the more dramatic the benefits. Spring MVC controllers
can call other reactive components too.

If you have a large team, keep in mind the steep learning curve in the shift to non-blocking,
functional, and declarative programming. A practical way to start without a full switch
is to use the reactive `WebClient`. Beyond that start small and measure the benefits.
We expect that for a wide range of applications the shift is unnecessary.

If you are unsure what benefits to look for, start by learning about how non-blocking I/O
works (e.g. concurrency on single-threaded Node.js is not an oxymoron) and its effects.
The tag line is ""scale with less hardware"" but that effect is not guaranteed, not without
some network I/O that can be slow or unpredictable. This Netflix
https://medium.com/netflix-techblog/zuul-2-the-netflix-journey-to-asynchronous-non-blocking-systems-45947377fb5c[blog post]
is a good resource.



[[webflux-server-choice]]
=== Choosing a server

Spring WebFlux is supported on Netty, Undertow, Tomcat, Jetty, and Servlet 3.1+ containers.
Each server is adapted to a common Reactive Streams API. The Spring WebFlux programming
models are built on that common API.

[NOTE]
====
*Common question: how can Tomcat and Jetty be used in both stacks?* +
Tomcat and Jetty are non-blocking at their core. It's the Servlet API that adds a
blocking facade. Starting in version 3.1 the Servlet API adds a choice for non-blocking I/O.
However its use requires care to avoid other synchronous and blocking parts. For this
reason Spring's reactive web stack has a low-level Servlet adapter to bridge to Reactive
Streams but the Servlet API is otherwise not exposed for direct use.
====

Spring Boot 2 uses Netty by default with WebFlux because Netty is more widely used in the
async, non-blocking space and also provides both client and server that can share resources.
By comparison Servlet 3.1 non-blocking I/O hasn't seen much use because the bar to use it
is so high. Spring WebFlux opens one practical path to adoption.

The default server choice in Spring Boot is mainly about the out-of-the-box experience.
Applications can still choose any of the other supported servers which are also highly
optimized for performance, fully non-blocking, and adapted to Reactive Streams back
pressure. In Spring Boot it is trivial to make the switch.



[[webflux-performance]]
=== Performance vs scale

Performance has many characteristics and meanings. Reactive and non-blocking generally
do not make applications run faster. They can, in some cases, for example if using the
`WebClient` to execute remote calls in parallel. On the whole it requires more work to do
things the non-blocking way and that can increase slightly the required processing time.

The key expected benefit of reactive and non-blocking is the ability to scale with a small,
fixed number of threads and less memory. That makes applications more resilient under load
because they scale in a more predictable way. In order to observe those benefits however you
need to have some latency including a mix of slow and unpredictable network I/O.
That's where the reactive stack begins to show its strengths and the differences can be
dramatic.




[[webflux-reactive-spring-web]]
== Reactive Spring Web

The `spring-web` module provides low level infrastructure and HTTP abstractions -- client
and server, to build reactive web applications. All public APIs are build around Reactive
Streams with Reactor as a backing implementation.

Server support is organized in two layers:

* <<webflux-httphandler,HttpHandler>> and server adapters -- the most basic, common API
for HTTP request handling with Reactive Streams back pressure.
* <<webflux-web-handler-api,WebHandler API>> -- slightly higher level but still general
purpose server web API with filter chain style processing.



[[webflux-httphandler]]
=== HttpHandler

Every HTTP server has some API for HTTP request handling.
{api-spring-framework}/http/server/reactive/HttpHandler.html[HttpHandler]
is a simple contract with one method to handle a request and response.
It is intentionally minimal. Its main purpose is to provide a common, Reactive Streams
based API for HTTP request handling over different servers.

The `spring-web` module contains adapters for every supported server. The table below shows
the server APIs are used and where Reactive Streams support comes from:

[cols=""1,2,2"", options=""header""]
|===
|Server name|Server API used|Reactive Streams support

|Netty
|Netty API
|https://github.com/reactor/reactor-netty[Reactor Netty]

|Undertow
|Undertow API
|spring-web: Undertow to Reactive Streams bridge

|Tomcat
|Servlet 3.1 non-blocking I/O; Tomcat API to read and write ByteBuffers vs byte[]
|spring-web: Servlet 3.1 non-blocking I/O to Reactive Streams bridge

|Jetty
|Servlet 3.1 non-blocking I/O; Jetty API to write ByteBuffers vs byte[]
|spring-web: Servlet 3.1 non-blocking I/O to Reactive Streams bridge

|Servlet 3.1 container
|Servlet 3.1 non-blocking I/O
|spring-web: Servlet 3.1 non-blocking I/O to Reactive Streams bridge
|===

Here are required dependencies,
https://github.com/spring-projects/spring-framework/wiki/What%27s-New-in-the-Spring-Framework[supported versions],
and code snippets for each server:

|===
|Server name|Group id|Artifact name

|Reactor Netty
|io.projectreactor.ipc
|reactor-netty

|Undertow
|io.undertow
|undertow-core

|Tomcat
|org.apache.tomcat.embed
|tomcat-embed-core

|Jetty
|org.eclipse.jetty
|jetty-server, jetty-servlet
|===

Reactor Netty:
[source,java,indent=0]
[subs=""verbatim,quotes""]
----
HttpHandler handler = ...
ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(handler);
HttpServer.create(host, port).newHandler(adapter).block();
----

Undertow:
[source,java,indent=0]
[subs=""verbatim,quotes""]
----
HttpHandler handler = ...
UndertowHttpHandlerAdapter adapter = new UndertowHttpHandlerAdapter(handler);
Undertow server = Undertow.builder().addHttpListener(port, host).setHandler(adapter).build();
server.start();
----

Tomcat:
[source,java,indent=0]
[subs=""verbatim,quotes""]
----
HttpHandler handler = ...
Servlet servlet = new TomcatHttpHandlerAdapter(handler);

Tomcat server = new Tomcat();
File base = new File(System.getProperty(""java.io.tmpdir""));
Context rootContext = server.addContext("""", base.getAbsolutePath());
Tomcat.addServlet(rootContext, ""main"", servlet);
rootContext.addServletMappingDecoded(""/"", ""main"");
server.setHost(host);
server.setPort(port);
server.start();
----

Jetty:
[source,java,indent=0]
[subs=""verbatim,quotes""]
----
HttpHandler handler = ...
Servlet servlet = new JettyHttpHandlerAdapter(handler);

Server server = new Server();
ServletContextHandler contextHandler = new ServletContextHandler(server, """");
contextHandler.addServlet(new ServletHolder(servlet), ""/"");
contextHandler.start();

ServerConnector connector = new ServerConnector(server);
connector.setHost(host);
connector.setPort(port);
server.addConnector(connector);
server.start();
----

[NOTE]
====
To deploy as a WAR to a Servlet 3.1+ container, wrap `HttpHandler` with
`ServletHttpHandlerAdapter` and register that as a `Servlet`.
This can be automated through the use of
{api-spring-framework}/web/server/adapter/AbstractReactiveWebInitializer.html[AbstractReactiveWebInitializer].
====



[[webflux-web-handler-api]]
=== WebHandler API

`HttpHandler` is the basis for running on different servers. On that base the WebHandler
API provides a slightly higher level processing chain of
exception handlers
({api-spring-framework}/web/server/WebExceptionHandler.html[WebExceptionHandler]), filters
({api-spring-framework}/web/server/WebFilter.html[WebFilter]), and a target handler
({api-spring-framework}/web/server/WebHandler.html[WebHandler]).

All components work on `ServerWebExchange` -- a container for the HTTP request and
response that also adds request attributes, session attributes, access to form data,
multipart data, and more.

The processing chain can be put together with `WebHttpHandlerBuilder` which builds an
`HttpHandler` that in turn can be run with a <<webflux-httphandler,server adapter>>.
To use the builder either add components individually or point to an `ApplicationContext`
to have the following detected:

[cols=""2,2,1,3"", options=""header""]
|===
|Bean name|Bean type|Count|Description

|""webHandler""
|WebHandler
|1
|Target handler after filters

|<any>
|WebFilter
|0..N
|Filters

|<any>
|WebExceptionHandler
|0..N
|Exception handlers after filter chain

|""webSessionManager""
|WebSessionManager
|0..1
|Custom session manager; `DefaultWebSessionManager` by default

|""serverCodecConfigurer""
|ServerCodecConfigurer
|0..1
|Custom form and multipart data decoders; `ServerCodecConfigurer.create()` by default

|""localeContextResolver""
|LocaleContextResolver
|0..1
|Custom resolver for `LocaleContext`; `AcceptHeaderLocaleContextResolver` by default
|===



[[webflux-codecs]]
=== Codecs

The `spring-web` module provides
{api-spring-framework}/http/codec/HttpMessageReader.html[HttpMessageReader] and
{api-spring-framework}/http/codec/HttpMessageWriter.html[HttpMessageWriter]
for encoding and decoding the HTTP request and response body with Reactive Streams.
It builds on lower level contracts from `spring-core`:

* {api-spring-framework}/core/io/buffer/DataBuffer.html[DataBuffer] -- abstraction for
byte buffers -- e.g. Netty `ByteBuf`, `java.nio.ByteBuffer`
* {api-spring-framework}/core/codec/Encoder.html[Encoder] -- serialize a stream of Objects
to a stream of data buffers
* {api-spring-framework}/core/codec/Decoder.html[Decoder] -- deserialize a stream of data
buffers into a stream of Objects

Basic `Encoder` and `Decoder` implementations exist in `spring-core` but `spring-web` adds
more for JSON, XML, and other formats. You can wrap any `Encoder` and `Decoder` as a reader
or writer with `EncoderHttpMessageWriter` and `DecoderHttpMessageReader`. There are some
additional, web-only reader and writer implementations for server-sent events, form data,
and more.

Finally, `ClientCodecConfigurer` and `ServerCodecConfigurer` can be used to initialize
a list of readers and writers. They include support for classpath detection and a
of defaults along with the ability to override or replace those defaults.




[[webflux-dispatcher-handler]]
== DispatcherHandler
[.small]#<<web.adoc#mvc-servlet,Same in Spring MVC>>#

Spring WebFlux, like Spring MVC, is designed around the front controller pattern where a
central `WebHandler`, the `DispatcherHandler`, provides a shared algorithm for request
processing while actual work is performed by configurable, delegate components.
This model is flexible and supports diverse workflows.

`DispatcherHandler` discovers the delegate components it needs from Spring configuration.
It is also designed to be a Spring bean itself and implements `ApplicationContextAware`
for access to the context it runs in. If `DispatcherHandler` is declared with the bean
name ""webHandler"" it is in turn discovered by
{api-spring-framework}/web/server/adapter/WebHttpHandlerBuilder.html[WebHttpHandlerBuilder]
which puts together a request processing chain as described in
<<webflux-web-handler-api,WebHandler API>>.

Spring configuration in a WebFlux application typically contains:

* `DispatcherHandler` with the bean name ""webHandler""
* `WebFilter` and `WebExceptionHandler` beans
* <<webflux-special-bean-types,DispatcherHandler special beans>>
* Others

The configuration is given to `WebHttpHandlerBuilder` to build the processing chain:
[source,java,indent=0]
[subs=""verbatim,quotes""]
----
ApplicationContext context = ...
HttpHandler handler = WebHttpHandlerBuilder.applicationContext(context);
----

The resulting `HttpHandler` is ready for use with a
<<webflux-httphandler,server adapter>>.



[[webflux-special-bean-types]]
=== Special bean types
[.small]#<<web.adoc#mvc-servlet-special-bean-types,Same in Spring MVC>>#

The `DispatcherHandler` delegates to special beans to process requests and render the
appropriate responses. By ""special beans"" we mean Spring-managed Object instances that
implement one of the framework contracts listed in the table below.
Spring WebFlux provides built-in implementations of these contracts but you can also
customize, extend, or replace them.

[[webflux-special-beans-table]]
[cols=""1,2"", options=""header""]
|===
| Bean type| Explanation

| HandlerMapping
| Map a request to a handler. The mapping is based on some criteria the details of
  which vary by `HandlerMapping` implementation -- annotated controllers, simple
  URL pattern mappings, etc.

  The main `HandlerMapping` implementations are `RequestMappingHandlerMapping` based on
  `@RequestMapping` annotated methods, `RouterFunctionMapping` based on functional
  endpoint routes, and `SimpleUrlHandlerMapping` based on explicit registrations of URI
  path patterns to handlers.

| HandlerAdapter
| Help the `DispatcherHandler` to invoke a handler mapped to a request regardless of
  how the handler is actually invoked. For example invoking an annotated controller
  requires resolving annotations. The main purpose of a `HandlerAdapter` is to shield the
  `DispatcherHandler` from such details.

| HandlerResultHandler
| Process the result from the handler invocation and finalize the response.

  The built-in `HandlerResultHandler` implementations are `ResponseEntityResultHandler`
  supporting `ResponseEntity` return values, `ResponseBodyResultHandler`
  supporting `@ResponseBody` methods, `ServerResponseResultHandler`
  supporting the `ServerResponse` returned from functional endpoints, and
  `ViewResolutionResultHandler` supporting rendering with a view and a model.
|===



[[webflux-framework-config]]
=== Framework Config
[.small]#<<web.adoc#mvc-servlet-config,Same in Spring MVC>>#

The `DispatcherHandler` detects the special beans it needs in the `ApplicationContext`.
Applications can declare the special beans they wish to have. However most applications
will find a better starting point in the WebFlux Java config which provide a higher level
configuration API that in turn make the necessary bean declarations.
See <<webflux-config>> for more details.



[[webflux-dispatcher-handler-sequence]]
=== Processing
[.small]#<<web.adoc#mvc-servlet-sequence,Same in Spring MVC>>#

The `DispatcherHandler` processes requests as follows:

* Each `HandlerMapping` is asked to find a matching handler and the first match is used.
* If a handler is found, it is executed through an appropriate `HandlerAdapter` which
exposes the return value from the execution as `HandlerResult`.
* The `HandlerResult` is given to an appropriate `HandlerResultHandler` to complete
processing by writing to the response directly or using a view to render.



[[webflux-controller]]
== Annotated Controllers
[.small]#<<web.adoc#mvc-controller,Same in Spring MVC>>#

Spring WebFlux provides an annotation-based programming model where `@Controller` and
`@RestController` components use annotations to express request mappings, request input,
exception handling, and more. Annotated controllers have flexible method signatures and
do not have to extend base classes nor implement specific interfaces.

Here is a basic example:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@RestController
	public class HelloController {

		@GetMapping(""/hello"")
		public String handle() {
			return ""Hello WebFlux"";
		}
	}
----

In this example the methods returns a String to be written to the response body.



[[webflux-ann-controller]]
=== @Controller
[.small]#<<web.adoc#mvc-ann-controller,Same in Spring MVC>>#

You can define controller beans using a standard Spring bean definition.
The `@Controller` stereotype allows for auto-detection, aligned with Spring general support
for detecting `@Component` classes in the classpath and auto-registering bean definitions
for them. It also acts as a stereotype for the annotated class, indicating its role as
a web component.

To enable auto-detection of such `@Controller` beans, you can add component scanning to
your Java configuration:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@Configuration
	@ComponentScan(""org.example.web"")
	public class WebConfig {

		// ...
	}
----

`@RestController` is a composed annotation that is itself annotated with
`@Controller` and `@ResponseBody` indicating a controller whose every method inherits the type-level
`@ResponseBody` annotation and therefore writes to the response body (vs model-and-vew
rendering).



[[webflux-ann-requestmapping]]
=== Request Mapping
[.small]#<<web.adoc#mvc-ann-requestmapping,Same in Spring MVC>>#

The `@RequestMapping` annotation is used to map requests to controllers methods. It has
various attributes to match by URL, HTTP method, request parameters, headers, and media
types. It can be used at the class-level to express shared mappings or at the method level
to narrow down to a specific endpoint mapping.

There are also HTTP method specific shortcut variants of `@RequestMapping`:

- `@GetMapping`
- `@PostMapping`
- `@PutMapping`
- `@DeleteMapping`
- `@PatchMapping`

The shortcut variants are
https://github.com/spring-projects/spring-framework/wiki/Spring-Annotation-Programming-Model#composed-annotations[composed annotations]
-- themselves annotated with `@RequestMapping`. They are commonly used at the method level.
At the class level an `@RequestMapping` is more useful for expressing shared mappings.

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@RestController
	@RequestMapping(""/persons"")
	class PersonController {

		@GetMapping(""/{id}"")
		public Person getPerson(@PathVariable Long id) {
			// ...
		}

		@PostMapping
		@ResponseStatus(HttpStatus.CREATED)
		public void add(@RequestBody Person person) {
			// ...
		}
	}
----


[[webflux-ann-requestmapping-uri-templates]]
==== URI Patterns
[.small]#<<web.adoc#mvc-ann-requestmapping-uri-templates,Same in Spring MVC>>#

You can map requests using glob patterns and wildcards:

* `?` matches one character
* `*` matches zero or more characters within a path segment
* `**` match zero or more path segments

You can also declare URI variables and access their values with `@PathVariable`:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@GetMapping(""/owners/{ownerId}/pets/{petId}"")
	public Pet findPet(@PathVariable Long ownerId, @PathVariable Long petId) {
		// ...
	}
----

URI variables can be declared at the class and method level:
[source,java,intent=0]
[subs=""verbatim,quotes""]
----
@Controller
@RequestMapping(""/owners/{ownerId}"")
public class OwnerController {

	@GetMapping(""/pets/{petId}"")
	public Pet findPet(@PathVariable Long ownerId, @PathVariable Long petId) {
		// ...
	}
}
----

URI variables are automatically converted to the appropriate type or`TypeMismatchException`
is raised. Simple types -- `int`, `long`, `Date`, are supported by default and you can
register support for any other data type.
// TODO: see <<webflux-ann-typeconversion>> and <<webflux-ann-webdatabinder>>.

URI variables can be named explicitly -- e.g. `@PathVariable(""customId"")`, but you can
leave that detail out if the names are the same and your code is compiled with debugging
information or with the `-parameters` compiler flag on Java 8.

The syntax `{*varName}` declares a URI variable that matches zero or more remaining
path segments. For example `/resources/{*path}` matches all files `/resources/` and the
`""path""` variable captures the complete relative path.

The syntax `{varName:regex}` declares a URI variable with a regular expressions with the
syntax `{varName:regex}` -- e.g. given URL `""/spring-web-3.0.5 .jar""`, the below method
extracts the name, version, and file extension:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@GetMapping(""/{name:[a-z-]+}-{version:\\\\d\\\\.\\\\d\\\\.\\\\d}{ext:\\\\.[a-z]+}"")
	public void handle(@PathVariable String version, @PathVariable String ext) {
		// ...
	}
----

URI path patterns can also have embedded `${...}` placeholders that are resolved on startup
 via `PropertyPlaceHolderConfigurer` against local, system, environment, and other property
sources. This can be used for example to parameterize a base URL based on some external
configuration.

[NOTE]
====
Spring WebFlux uses `PathPattern` and the `PathPatternParser` for URI path matching support
both of which are located in `spring-web` and expressly designed for use with HTTP URL
paths in web applications where a large number of URI path patterns are matched at runtime.
====

Spring WebFlux does not support suffix pattern matching -- unlike Spring MVC, where a
mapping such as `/person` also matches to `/person.{asterisk}`. For URL based content
negotiation, if needed, we recommend using a query parameter, which is simpler, more
explicit, and less vulnerable to URL path based exploits.


[[webflux-ann-requestmapping-pattern-comparison]]
==== Pattern Comparison
[.small]#<<web.adoc#mvc-ann-requestmapping-pattern-comparison,Same in Spring MVC>>#

When multiple patterns match a URL, they must be compared to find the best match. This is done
with `PathPattern.SPECIFICITY_COMPARATOR` which looks for patterns that more specific.

For every pattern, a score is computed based the number of URI variables and wildcards
where a URI variable scores lower than a wildcard. A pattern with a lower total score
wins. If two patterns have the same score, then the longer is chosen.

Catch-all patterns, e.g. `**`, `{*varName}`, are excluded from the scoring and are always
sorted last instead. If two patterns are both catch-all, the longer is chosen.


[[webflux-ann-requestmapping-consumes]]
==== Consumable Media Types
[.small]#<<web.adoc#mvc-ann-requestmapping-consumes,Same in Spring MVC>>#

You can narrow the request mapping based on the `Content-Type` of the request:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@PostMapping(path = ""/pets"", **consumes = ""application/json""**)
	public void addPet(@RequestBody Pet pet) {
		// ...
	}
----

The consumes attribute also supports negation expressions -- e.g. `!text/plain` means any
content type other than ""text/plain"".

You can declare a shared consumes attribute at the class level. Unlike most other request
mapping attributes however when used at the class level, a method-level consumes attribute
will overrides rather than extend the class level declaration.

[TIP]
====
`MediaType` provides constants for commonly used media types -- e.g.
`APPLICATION_JSON_VALUE`, `APPLICATION_JSON_UTF8_VALUE`.
====


[[webflux-ann-requestmapping-produces]]
==== Producible Media Types
[.small]#<<web.adoc#mvc-ann-requestmapping-produces,Same in Spring MVC>>#

You can narrow the request mapping based on the `Accept` request header and the list of
content types that a controller method produces:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@GetMapping(path = ""/pets/{petId}"", **produces = ""application/json;charset=UTF-8""**)
	@ResponseBody
	public Pet getPet(@PathVariable String petId) {
		// ...
	}
----

The media type can specify a character set. Negated expressions are supported -- e.g.
`!text/plain` means any content type other than ""text/plain"".

You can declare a shared produces attribute at the class level. Unlike most other request
mapping attributes however when used at the class level, a method-level produces attribute
will overrides rather than extend the class level declaration.

[TIP]
====
`MediaType` provides constants for commonly used media types -- e.g.
`APPLICATION_JSON_VALUE`, `APPLICATION_JSON_UTF8_VALUE`.
====


[[webflux-ann-requestmapping-params-and-headers]]
==== Parameters and Headers
[.small]#<<web.adoc#mvc-ann-requestmapping-params-and-headers,Same in Spring MVC>>#

You can narrow request mappings based on query parameter conditions. You can test for the
presence of a query parameter (`""myParam""`), for the absence (`""!myParam""`), or for a
specific value (`""myParam=myValue""`):

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@GetMapping(path = ""/pets/{petId}"", **params = ""myParam=myValue""**)
	public void findPet(@PathVariable String petId) {
		// ...
	}
----

You can also use the same with request header conditions:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@GetMapping(path = ""/pets"", **headers = ""myHeader=myValue""**)
	public void findPet(@PathVariable String petId) {
		// ...
	}
----


[[webflux-ann-requestmapping-head-options]]
==== HTTP HEAD, OPTIONS
[.small]#<<web.adoc#mvc-ann-requestmapping-head-options,Same in Spring MVC>>#

`@GetMapping` -- and also `@RequestMapping(method=HttpMethod.GET)`, support HTTP HEAD
transparently for request mapping purposes. Controller methods don't need to change.
A response wrapper, applied in the `HttpHandler` server adapter, ensures a `""Content-Length""`
header is set to the number of bytes written and without actually writing to the response.

By default HTTP OPTIONS is handled by setting the ""Allow"" response header to the list of HTTP
methods listed in all `@RequestMapping` methods with matching URL patterns.

For a `@RequestMapping` without HTTP method declarations, the ""Allow"" header is set to
`""GET,HEAD,POST,PUT,PATCH,DELETE,OPTIONS""`. Controller methods should always declare the
supported HTTP methods for example by using the HTTP method specific variants --
`@GetMapping`, `@PostMapping`, etc.

`@RequestMapping` method can be explicitly mapped to HTTP HEAD and HTTP OPTIONS, but that
is not necessary in the common case.



[[webflux-ann-methods]]
=== Handler methods
[.small]#<<web.adoc#mvc-ann-methods,Same in Spring MVC>>#

`@RequestMapping` handler methods have a flexible signature and can choose from a range of
supported controller method arguments and return values.


[[webflux-ann-arguments]]
==== Method arguments
[.small]#<<web.adoc#mvc-ann-arguments,Same in Spring MVC>>#

The table below shows supported controller method arguments.

Reactive types (Reactor, RxJava, <<webflux-reactive-libraries,or other>>) are
supported on arguments that require blocking I/O, e.g. reading the request body, to
be resolved. This is marked in the description column. Reactive types are not expected
on arguments that don't require blocking.

JDK 1.8's `java.util.Optional` is supported as a method argument in combination with
annotations that have a `required` attribute -- e.g. `@RequestParam`, `@RequestHeader`,
etc, and is equivalent to `required=false`.

[cols=""1,2"", options=""header""]
|===
|Controller method argument|Description

|`ServerWebExchange`
|Access to the full `ServerWebExchange` -- container for the HTTP request and response,
request and session attributes, `checkNotModified` methods, and others.

|`ServerHttpRequest`, `ServerHttpResponse`
|Access to the HTTP request or response.

|`WebSession`
|Access to the session; this does not forcing the start of a new session unless attributes
are added. Supports reactive types.

|`java.security.Principal`
|Currently authenticated user; possibly a specific `Principal` implementation class if known.
Supports reactive types.

|`org.springframework.http.HttpMethod`
|The HTTP method of the request.

 |`java.util.Locale`
 |The current request locale, determined by the most specific `LocaleResolver` available, in
 effect, the configured `LocaleResolver`/`LocaleContextResolver`.

|Java 6+: `java.util.TimeZone` +
Java 8+: `java.time.ZoneId`
|The time zone associated with the current request, as determined by a `LocaleContextResolver`.

|`@PathVariable`
|For access to URI template variables.
// TODO: See <<webflux-ann-requestmapping-uri-templates>>.

|`@MatrixVariable`
|For access to name-value pairs in URI path segments.
// TODO: See <<webflux-ann-matrix-variables>>.

|`@RequestParam`
|For access to Servlet request parameters. Parameter values are converted to the declared
method argument type.
// TODO: See <<webflux-ann-requestparam>>.

|`@RequestHeader`
|For access to request headers. Header values are converted to the declared method argument
type.
// TODO: See <<webflux-ann-requestheader>>.

|`@RequestBody`
|For access to the HTTP request body. Body content is converted to the declared method
argument type using ``HttpMessageReader``'s. Supports reactive types.
// TODO: See <<webflux-ann-requestbody>>.

|`HttpEntity<B>`
|For access to request headers and body. The body is converted with ``HttpMessageReader``'s.
Supports reactive types.
// TODO: See <<webflux-ann-httpentity>>.

|`@RequestPart`
|For access to a part in  a ""multipart/form-data"" request. Supports reactive types.
// TODO: See <<webflux-multipart-forms-non-browsers>> and <<webflux-multipart>>.

|`java.util.Map`, `org.springframework.ui.Model`, `org.springframework.ui.ModelMap`
|For access and updates of the implicit model that is exposed to the web view.

|Command or form object (with optional `@ModelAttribute`)
|Command object whose properties to bind to request parameters -- via setters or directly to
fields, with customizable type conversion, depending on `@InitBinder` methods and/or the
HandlerAdapter configuration (see the `webBindingInitializer` property on
`RequestMappingHandlerAdapter`).

Command objects along with their validation results are exposed as model attributes, by
default using the command class name - e.g. model attribute ""orderAddress"" for a command
object of type ""some.package.OrderAddress"". `@ModelAttribute` can be used to customize the
model attribute name.

Supports reactive types.

|`Errors`, `BindingResult`
|Validation results for the command/form object data binding; this argument must be
declared immediately after the command/form object in the controller method signature.

|`SessionStatus`
|For marking form processing complete which triggers cleanup of session attributes
declared through a class-level `@SessionAttributes` annotation.

|`UriComponentsBuilder`
|For preparing a URL relative to the current request's host, port, scheme, context path, and
the literal  part of the servlet mapping also taking into account `Forwarded` and
`X-Forwarded-*` headers.

|`@SessionAttribute`
|For access to any session attribute; in contrast to model attributes stored in the session
as a result of a class-level `@SessionAttributes` declaration.

|`@RequestAttribute`
|For access to request attributes.
|===


[[webflux-ann-return-types]]
==== Return values
[.small]#<<web.adoc#mvc-ann-return-types,Same in Spring MVC>>#

The table below shows supported controller method return values. Reactive types --
Reactor, RxJava, <<webflux-reactive-libraries,or other>> are supported for all return
values.

[cols=""1,2"", options=""header""]
|===
|Controller method return value|Description

|`@ResponseBody`
|The return value is encoded through ``HttpMessageWriter``s and written to the response.
// TODO: See <<webflux-ann-responsebody>>.

|`HttpEntity<B>`, `ResponseEntity<B>`
|The return value specifies the full response including HTTP headers and body be encoded
through ``HttpMessageWriter``s and written to the response.
// TODO: See <<webflux-ann-httpentity>>.

|`HttpHeaders`
|For returning a response with headers and no body.

|`String`
|A view name to be resolved with ``ViewResolver``'s and used together with the implicit
model -- determined through command objects and `@ModelAttribute` methods. The handler
method may also programmatically enrich the model by declaring a `Model` argument (see
above).

|`View`
|A `View` instance to use for rendering together with the implicit model -- determined
through command objects and `@ModelAttribute` methods. The handler method may also
programmatically enrich the model by declaring a `Model` argument (see above).

|`java.util.Map`, `org.springframework.ui.Model`
|Attributes to be added to the implicit model with the view name implicitly determined
from the request path.

|`Rendering`
|An API for model and view rendering scenarios.

|`void`
|A method with a `void`, possibly async (e.g. `Mono<Void>`), return type (or a `null` return
value) is considered to have fully handled the response if it also has a `ServerHttpResponse`,
or a `ServerWebExchange` argument, or an `@ResponseStatus` annotation. The same is true also
if the controller has made a positive ETag or lastModified timestamp check.
// TODO (see <<webflux-caching-etag-lastmodified>> for details)

If none of the above is true, a `void` return type may also indicate ""no response body"" for
REST controllers, or default view name selection for HTML controllers.

|`Flux<ServerSentEvent>`, `Observable<ServerSentEvent>`, or other reactive type
|Emit server-sent events; the `SeverSentEvent` wrapper can be omitted when only data needs
to be written (however `text/event-stream` must be requested or declared in the mapping
through the produces attribute).

|Any other return type
|A single model attribute to be added to the implicit model with the view name implicitly
determined through a `RequestToViewNameTranslator`; the attribute name may be specified
through a method-level `@ModelAttribute` or otherwise a name is selected based on the
class name of the return type.
|===




include::webflux-functional.adoc[leveloffset=+1]




[[webflux-config]]
== WebFlux Java Config
[.small]#<<web.adoc#mvc-config,Same in Spring MVC>>#

The WebFlux Java config provides default configuration suitable for most applications along
with a configuration API to customize it. For more advanced customizations, not available in
the configuration API, see <<webflux-config-advanced-java>>.

You do not need to understand the underlying beans created by the Java config, but it's
easy to seem them in `WebFluxConfigurationSupport`, and if you want to learn more, see
<<webflux-special-bean-types>>.



[[webflux-config-enable]]
=== Enable WebFlux config
[.small]#<<web.adoc#mvc-config-enable,Same in Spring MVC>>#

Use the `@EnableWebFlux` annotation in your Java config:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@Configuration
	@EnableWebFlux
	public class WebConfig {
	}
----

The above registers a number of Spring WebFlux
<<mvc-webflux-special-bean-types,infrastructure beans>> also adapting to dependencies
available on the classpath -- for JSON, XML, etc.



[[webflux-config-customize]]
=== WebFlux config API
[.small]#<<web.adoc#mvc-config-customize,Same in Spring MVC>>#

In your Java config implement the `WebFluxConfigurer` interface:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@Configuration
	@EnableWebFlux
	public class WebConfig implements WebFluxConfigurer {

		// Implement configuration methods...

	}
----



[[webflux-config-conversion]]
=== Conversion, formatting
[.small]#<<web.adoc#mvc-config-conversion,Same in Spring MVC>>#

By default formatters for `Number` and `Date` types are installed, including support for
the `@NumberFormat` and `@DateTimeFormat` annotations. Full support for the Joda Time
formatting library is also installed if Joda Time is present on the classpath.

To register custom formatters and converters:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@Configuration
	@EnableWebFlux
	public class WebConfig implements WebFluxConfigurer {

		@Override
		public void addFormatters(FormatterRegistry registry) {
			// ...
		}

	}
----

[NOTE]
====
See <<core.adoc#format-FormatterRegistrar-SPI,FormatterRegistrar SPI>>
and the `FormattingConversionServiceFactoryBean` for more information on when to use FormatterRegistrars.
====



[[webflux-config-validation]]
=== Validation
[.small]#<<web.adoc#mvc-config-validation,Same in Spring MVC>>#

By default if <<core.adoc#validation-beanvalidation-overview,Bean Validation>> is present
on the classpath -- e.g. Hibernate Validator, the `LocalValidatorFactoryBean` is registered
as a global <<core.adoc#validator,Validator>> for use with `@Valid` and `Validated` on
`@Controller` method arguments.

In your Java config, you can customize the global `Validator` instance:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@Configuration
	@EnableWebFlux
	public class WebConfig implements WebFluxConfigurer {

		@Override
		public Validator getValidator(); {
			// ...
		}

	}
----

Note that you can also register ``Validator``'s locally:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@Controller
	public class MyController {

		@InitBinder
		protected void initBinder(WebDataBinder binder) {
			binder.addValidators(new FooValidator());
		}

	}
----

[TIP]
====
If you need to have a `LocalValidatorFactoryBean` injected somewhere, create a bean and
mark it with `@Primary` in order to avoid conflict with the one declared in the MVC config.
====



[[webflux-config-content-negotiation]]
=== Content type resolvers
[.small]#<<web.adoc#mvc-config-content-negotiation,Same in Spring MVC>>#

You can configure how Spring WebFlux determines the requested media types for
``@Controller``'s from the request. By default only the ""Accept"" header is checked but you
can also enable a query parameter based strategy.

To customize the requested content type resolution:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@Configuration
	@EnableWebFlux
	public class WebConfig implements WebFluxConfigurer {

		@Override
		public void configureContentTypeResolver(RequestedContentTypeResolverBuilder builder) {
			// ...
		}
	}
----



[[webflux-config-message-codecs]]
=== HTTP message codecs
[.small]#<<web.adoc#mvc-config-message-converters,Same in Spring MVC>>#

To customize how the request and response body are read and written:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@Configuration
	@EnableWebFlux
	public class WebConfig implements WebFluxConfigurer {

		@Override
		public void configureHttpMessageCodecs(ServerCodecConfigurer configurer) {
			// ...
		}
	}
----

`ServerCodecConfigurer` provides a set of default readers and writers. You can use it to add
more readers and writers, customize the default ones, or replace the default ones completely.

For Jackson JSON and XML, consider using the
{api-spring-framework}/http/converter/json/Jackson2ObjectMapperBuilder.html[Jackson2ObjectMapperBuilder]
which customizes Jackson's default properties with the following ones:

. http://fasterxml.github.io/jackson-databind/javadoc/2.6/com/fasterxml/jackson/databind/DeserializationFeature.html#FAIL_ON_UNKNOWN_PROPERTIES[`DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES`] is disabled.
. http://fasterxml.github.io/jackson-databind/javadoc/2.6/com/fasterxml/jackson/databind/MapperFeature.html#DEFAULT_VIEW_INCLUSION[`MapperFeature.DEFAULT_VIEW_INCLUSION`] is disabled.

It also automatically registers the following well-known modules if they are detected on the classpath:

. https://github.com/FasterXML/jackson-datatype-jdk7[jackson-datatype-jdk7]: support for Java 7 types like `java.nio.file.Path`.
. https://github.com/FasterXML/jackson-datatype-joda[jackson-datatype-joda]: support for Joda-Time types.
. https://github.com/FasterXML/jackson-datatype-jsr310[jackson-datatype-jsr310]: support for Java 8 Date & Time API types.
. https://github.com/FasterXML/jackson-datatype-jdk8[jackson-datatype-jdk8]: support for other Java 8 types like `Optional`.



[[webflux-config-view-resolvers]]
=== View resolvers
[.small]#<<web.adoc#mvc-config-view-resolvers,Same in Spring MVC>>#

To configure view resolution:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@Configuration
	@EnableWebFlux
	public class WebConfig implements WebFluxConfigurer {

		@Override
		public void configureViewResolvers(ViewResolverRegistry registry) {
			// ...
		}
	}
----

Note that FreeMarker also requires configuration of the underlying view technology:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@Configuration
	@EnableWebFlux
	public class WebConfig implements WebFluxConfigurer {

		// ...

		@Bean
		public FreeMarkerConfigurer freeMarkerConfigurer() {
			FreeMarkerConfigurer configurer = new FreeMarkerConfigurer();
			configurer.setTemplateLoaderPath(""classpath:/templates"");
			return configurer;
		}

	}
----



[[webflux-config-static-resources]]
=== Static resources
[.small]#<<web.adoc#mvc-config-static-resources,Same in Spring MVC>>#

This option provides a convenient way to serve static resources from a list of
{api-spring-framework}/core/io/Resource.html[Resource]-based locations.

In the example below, given a request that starts with `""/resources""`, the relative path is
used to find and serve static resources relative to `""/static""` on the classpath. Resources
will be served with a 1-year future expiration to ensure maximum use of the browser cache
and a reduction in HTTP requests made by the browser. The `Last-Modified` header is also
evaluated and if present a `304` status code is returned.

[source,java,indent=0]
[subs=""verbatim""]
----
	@Configuration
	@EnableWebFlux
	public class WebConfig implements WebFluxConfigurer {

		@Override
		public void addResourceHandlers(ResourceHandlerRegistry registry) {
			registry.addResourceHandler(""/resources/**"")
				.addResourceLocations(""/public"", ""classpath:/static/"")
				.setCachePeriod(31556926);
		}

	}
----

// TODO:
// See also <<webflux-caching-static-resources, HTTP caching support for static resources>>.

The resource handler also supports a chain of
{api-spring-framework}/web/reactive/resource/ResourceResolver.html[ResourceResolver]'s and
{api-spring-framework}/web/reactive/resource/ResourceTransformer.html[ResourceTransformer]'s.
which can be used to create a toolchain for working with optimized resources.

The `VersionResourceResolver` can be used for versioned resource URLs based on an MD5 hash
computed from the content, a fixed application version, or other. A
`ContentVersionStrategy` (MD5 hash) is a good choice with some notable exceptions such as
JavaScript resources used with a module loader.

For example in your Java config;

[source,java,indent=0]
[subs=""verbatim""]
----
	@Configuration
	@EnableWebFlux
	public class WebConfig implements WebFluxConfigurer {

		@Override
		public void addResourceHandlers(ResourceHandlerRegistry registry) {
			registry.addResourceHandler(""/resources/**"")
					.addResourceLocations(""/public/"")
					.resourceChain(true)
					.addResolver(new VersionResourceResolver().addContentVersionStrategy(""/**""));
		}

	}
----

You can use `ResourceUrlProvider` to rewrite URLs and apply the full chain of resolvers and
transformers -- e.g. to insert versions. The WebFlux config provides a `ResourceUrlProvider`
so it can be injected into others.

Unlike Spring MVC at present in WebFlux there is no way to transparely rewrite static
resource URLs since the are no view technologies that can make use of a non-blocking chain
of resolvers and transformers (e.g. resources on Amazon S3). When serving only local
resources the workaround is to use `ResourceUrlProvider` directly (e.g. through a custom
tag) and block for 0 seconds.

http://www.webjars.org/documentation[WebJars] is also supported via `WebJarsResourceResolver`
and automatically registered when `""org.webjars:webjars-locator""` is present on the
classpath. The resolver can re-write URLs to include the version of the jar and can also
match to incoming URLs without versions -- e.g. `""/jquery/jquery.min.js""` to
`""/jquery/1.2.0/jquery.min.js""`.



[[webflux-config-path-matching]]
=== Path Matching
[.small]#<<web.adoc#mvc-config-path-matching,Same in Spring MVC>>#

Spring WebFlux uses parsed representation of path patterns -- i.e. `PathPattern`, and also
the incoming  request path -- i.e. `RequestPath`, which eliminates the need to indicate
whether to decode the request path, or remove semicolon content, since `PathPattern`
can now access decoded path segment values and match safely.

Spring WebFlux also does not support suffix pattern matching so effectively there are only two
minor options to customize related to path matching -- whether to match trailing slashes
(`true` by default) and whether the match is case-sensitive (`false`).

To customize those options:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@Configuration
	@EnableWebFlux
	public class WebConfig implements WebFluxConfigurer {

		@Override
		public void configurePathMatch(PathMatchConfigurer configurer) {
			// ...
		}

	}
----



[[webflux-config-advanced-java]]
=== Advanced config mode
[.small]#<<web.adoc#mvc-config-advanced-java,Same in Spring MVC>>#

`@EnableWebFlux` imports `DelegatingWebFluxConfiguration` that (1) provides default
Spring configuration for WebFlux applications and (2) detects and delegates to
``WebFluxConfigurer``'s to customize that configuration.

For advanced mode, remove `@EnableWebFlux` and extend directly from
`DelegatingWebFluxConfiguration` instead of implementing `WebFluxConfigurer`:

[source,java,indent=0]
[subs=""verbatim,quotes""]
----
	@Configuration
	public class WebConfig extends DelegatingWebFluxConfiguration {

		// ...

	}
----

You can keep existing methods in `WebConfig` but you can now also override bean declarations
from the base class and you can still have any number of other ``WebMvcConfigurer``'s on
the classpath.




[[webflux-http2]]
== HTTP/2
[.small]#<<web.adoc#mvc-http2,Same in Spring MVC>>#

Servlet 4 containers are required to support HTTP/2 and Spring Framework 5 is compatible
with Servlet API 4. From a programming model perspective there is nothing specific that
applications need to do. However there are considerations related to server configuration.
For more details please check out the
https://github.com/spring-projects/spring-framework/wiki/HTTP-2-support[HTTP/2 wiki page].

Currently Spring WebFlux does not support HTTP/2 with Netty. There is also no support for
pushing resources programmatically to the client.",12463,False,1951.3622479740375,median
"[[defining-processors]]
=== Define processors

You can use processors to filter and enhance data before sending it to the
configured output. To define a processor, you specify the processor name, an
optional condition, and a set of parameters:

[source,yaml]
------
processors:
- <processor_name>:
    when:
      <condition>
    <parameters>

- <processor_name>:
    when:
      <condition>
    <parameters>

...
------

Where:

* `<processor_name>` specifies a <<processors,processor>> that performs some kind
of action, such as selecting the fields that are exported or adding metadata to
the event.
* `<condition>` specifies an optional <<conditions,condition>>. If the
condition is present, then the action is executed only if the condition is
fulfilled. If no condition is passed, then the action is always executed.
* `<parameters>` is the list of parameters to pass to the processor.

More complex conditional processing can be accomplished by using the
if-then-else processor configuration. This allows multiple processors to be
executed based on a single condition.

[source,yaml]
----
processors:
- if:
    <condition>
  then: <1>
    - <processor_name>:
        <parameters>
    - <processor_name>:
        <parameters>
    ...
  else: <2>
    - <processor_name>:
        <parameters>
    - <processor_name>:
        <parameters>
    ...
----
<1> `then` must contain a single processor or a list of one or more processors
to execute when the condition evaluates to true.
<2> `else` is optional. It can contain a single processor or a list of
processors to execute when the conditional evaluate to false.

[[where-valid]]
==== Where are processors valid?

// TODO: ANY NEW BEATS THAT RE-USE THIS TOPIC NEED TO DEFINE processor-scope.

ifeval::[""{beatname_lc}""==""filebeat""]
:processor-scope: input
endif::[]

ifeval::[""{beatname_lc}""==""auditbeat""]
:processor-scope: module
endif::[]

ifeval::[""{beatname_lc}""==""metricbeat""]
:processor-scope: module
endif::[]

ifeval::[""{beatname_lc}""==""packetbeat""]
:processor-scope: protocol
endif::[]

ifeval::[""{beatname_lc}""==""heartbeat""]
:processor-scope: monitor
endif::[]

ifeval::[""{beatname_lc}""==""winlogbeat""]
:processor-scope: event log shipper
endif::[]

Processors are valid:

* At the top-level in the configuration. The processor is applied to all data
collected by {beatname_uc}.
* Under a specific {processor-scope}. The processor is applied to the data
collected for that {processor-scope}.
ifeval::[""{beatname_lc}""==""filebeat""]
For example:
+
[source,yaml]
------
- type: <input_type>
  processors:
  - <processor_name>:
      when:
        <condition>
      <parameters>
...
------
+
Similarly, for {beatname_uc} modules, you can define processors under the
`input` section of the module definition. 
endif::[]
ifeval::[""{beatname_lc}""==""metricbeat""]
[source,yaml]
----
- module: <module_name>
  metricsets: [""<metricset_name>""]
  processors:
  - <processor_name>:
      when:
        <condition>
      <parameters> 
----
endif::[]
ifeval::[""{beatname_lc}""==""auditbeat""]
For example:
+
[source,yaml]
----
auditbeat.modules:
- module: <module_name>
  processors:
  - <processor_name>:
      when:
        <condition>
      <parameters> 
----
endif::[]
ifeval::[""{beatname_lc}""==""packetbeat""]
For example:
+
[source,yaml]
----
packetbeat.protocols:
- type: <protocol_type>  
  processors:
  - <processor_name>:
      when:
        <condition>
      <parameters>
----

* Under `packetbeat.flows`. The processor is applied to the data in
<<configuration-flows,network flows>>:
+
[source,yaml]
----
packetbeat.flows:
  processors:
  - <processor_name>:
      when:
        <condition>
      <parameters>
----
endif::[]
ifeval::[""{beatname_lc}""==""heartbeat""]
For example:
+
[source,yaml]
----
heartbeat.monitors:
- type: <monitor_type>
  processors:
  - <processor_name>:
      when:
        <condition>
      <parameters>
----
endif::[]
ifeval::[""{beatname_lc}""==""winlogbeat""]
For example:
+
[source,yaml]
----
winlogbeat.event_logs:
- name: <network_shipper_name>
  processors:
  - <processor_name>:
      when:
        <condition>
      <parameters>
----
endif::[]


[[processors]]
==== Processors

The supported processors are:

 * <<add-cloud-metadata,`add_cloud_metadata`>>
 * <<add-docker-metadata,`add_docker_metadata`>>
 * <<add-fields, `add_fields`>>
 * <<add-host-metadata,`add_host_metadata`>>
 * <<add-observer-metadata,`add_observer_metadata`>>
 * <<add-kubernetes-metadata,`add_kubernetes_metadata`>>
 * <<add-labels, `add_labels`>>
 * <<add-locale,`add_locale`>>
 * <<add-process-metadata,`add_process_metadata`>>
 * <<add-tags, `add_tags`>>
 * <<community-id,`community_id`>>
 * <<convert,`convert`>>
ifdef::has_decode_csv_fields_processor[]
 * <<decode-csv-fields,`decode_csv_fields`>>
endif::[]
 * <<decode-json-fields,`decode_json_fields`>>
 * <<dissect, `dissect`>>
 * <<extract-array,`extract_array`>>
 * <<processor-dns, `dns`>>
 * <<drop-event,`drop_event`>>
 * <<drop-fields,`drop_fields`>>
 * <<include-fields,`include_fields`>>
 * <<rename-fields,`rename`>>
ifdef::has_script_processor[]
 * <<processor-script,`script`>>
endif::[]

[[conditions]]
==== Conditions

Each condition receives a field to compare. You can specify multiple fields
under the same condition by using `AND` between the fields (for example,
`field1 AND field2`).

For each field, you can specify a simple field name or a nested map, for example
`dns.question.name`.

See <<exported-fields>> for a list of all the fields that are exported by
{beatname_uc}.

The supported conditions are:

* <<condition-equals,`equals`>>
* <<condition-contains,`contains`>>
* <<condition-regexp,`regexp`>>
* <<condition-range, `range`>>
* <<condition-network, `network`>>
* <<condition-has_fields, `has_fields`>>
* <<condition-or, `or`>>
* <<condition-and, `and`>>
* <<condition-not, `not`>>


[float]
[[condition-equals]]
===== `equals`

With the `equals` condition, you can compare if a field has a certain value.
The condition accepts only an integer or a string value.

For example, the following condition checks if the response code of the HTTP
transaction is 200:

[source,yaml]
-------
equals:
  http.response.code: 200
-------

[float]
[[condition-contains]]
===== `contains`

The `contains` condition checks if a value is part of a field. The field can be
a string or an array of strings. The condition accepts only a string value.

For example, the following condition checks if an error is part of the
transaction status:

[source,yaml]
------
contains:
  status: ""Specific error""
------

[float]
[[condition-regexp]]
===== `regexp`

The `regexp` condition checks the field against a regular expression. The
condition accepts only strings.

For example, the following condition checks if the process name starts with
`foo`:

[source,yaml]
-----
regexp:
  system.process.name: ""foo.*""
-----

[float]
[[condition-range]]
===== `range`

The `range` condition checks if the field is in a certain range of values. The
condition supports `lt`, `lte`, `gt` and `gte`. The condition accepts only
integer or float values.

For example, the following condition checks for failed HTTP transactions by
comparing the `http.response.code` field with 400.


[source,yaml]
------
range:
    http.response.code:
        gte: 400
------

This can also be written as:

[source,yaml]
----
range:
    http.response.code.gte: 400
----

The following condition checks if the CPU usage in percentage has a value
between 0.5 and 0.8.

[source,yaml]
------
range:
    system.cpu.user.pct.gte: 0.5
    system.cpu.user.pct.lt: 0.8
------

[float]
[[condition-network]]
===== `network`

The `network` condition checks if the field is in a certain IP network range.
Both IPv4 and IPv6 addresses are supported. The network range may be specified
using CIDR notation, like ""192.0.2.0/24"" or ""2001:db8::/32"", or by using one of
these named ranges:

- `loopback` - Matches loopback addresses in the range of `127.0.0.0/8` or
  `::1/128`.
- `unicast` - Matches global unicast addresses defined in RFC 1122, RFC 4632,
  and RFC 4291 with the exception of the IPv4 broadcast address
  (`255.255.255.255`). This includes private address ranges.
- `multicast` - Matches multicast addresses.
- `interface_local_multicast` - Matches IPv6 interface-local multicast addresses.
- `link_local_unicast` - Matches link-local unicast addresses.
- `link_local_multicast` - Matches link-local multicast addresses.
- `private` - Matches private address ranges defined in RFC 1918 (IPv4) and
  RFC 4193 (IPv6).
- `public` - Matches addresses that are not loopback, unspecified, IPv4
  broadcast, link local unicast, link local multicast, interface local
  multicast, or private.
- `unspecified` - Matches unspecified addresses (either the IPv4 address
  ""0.0.0.0"" or the IPv6 address ""::"").

The following condition returns true if the `source.ip` value is within the
private address space.

[source,yaml]
----
network:
    source.ip: private
----

This condition returns true if the `destination.ip` value is within the
IPv4 range of `192.168.1.0` - `192.168.1.255`.

[source,yaml]
----
network:
    destination.ip: '192.168.1.0/24'
----

And this condition returns true when `destination.ip` is within any of the given
subnets.

[source,yaml]
----
network:
    destination.ip: ['192.168.1.0/24', '10.0.0.0/8', loopback]
----

[float]
[[condition-has_fields]]
===== `has_fields`

The `has_fields` condition checks if all the given fields exist in the
event. The condition accepts a list of string values denoting the field names.

For example, the following condition checks if the `http.response.code` field
is present in the event.


[source,yaml]
------
has_fields: ['http.response.code']
------


[float]
[[condition-or]]
===== `or`

The `or` operator receives a list of conditions.

[source,yaml]
-------
or:
  - <condition1>
  - <condition2>
  - <condition3>
  ...

-------

For example, to configure the condition
`http.response.code = 304 OR http.response.code = 404`:

[source,yaml]
------
or:
  - equals:
      http.response.code: 304
  - equals:
      http.response.code: 404
------

[float]
[[condition-and]]
===== `and`

The `and` operator receives a list of conditions.

[source,yaml]
-------
and:
  - <condition1>
  - <condition2>
  - <condition3>
  ...

-------

For example, to configure the condition
`http.response.code = 200 AND status = OK`:

[source,yaml]
------
and:
  - equals:
      http.response.code: 200
  - equals:
      status: OK
------

To configure a condition like `<condition1> OR <condition2> AND <condition3>`:

[source,yaml]
------
or:
 - <condition1>
 - and:
    - <condition2>
    - <condition3>

------

[float]
[[condition-not]]
===== `not`

The `not` operator receives the condition to negate.

[source,yaml]
-------
not:
  <condition>

-------

For example, to configure the condition `NOT status = OK`:

[source,yaml]
------
not:
  equals:
    status: OK
------

[[add-cloud-metadata]]
=== Add cloud metadata

The `add_cloud_metadata` processor enriches each event with instance metadata
from the machine's hosting provider. At startup it will detect the hosting
provider and cache the instance metadata.

The following cloud providers are supported:

- Amazon Web Services (AWS)
- Digital Ocean
- Google Compute Engine (GCE)
- https://www.qcloud.com/?lang=en[Tencent Cloud] (QCloud)
- Alibaba Cloud (ECS)
- Azure Virtual Machine
- Openstack Nova

The simple configuration below enables the processor.

[source,yaml]
-------------------------------------------------------------------------------
processors:
- add_cloud_metadata: ~
-------------------------------------------------------------------------------

The `add_cloud_metadata` processor has two optional configuration settings.
The first one is `timeout` which specifies the maximum amount of time to wait
for a successful response when detecting the hosting provider. The default
timeout value is `3s`.

If a timeout occurs then no instance metadata will be added to the events. This
makes it possible to enable this processor for all your deployments (in the
cloud or on-premise).

The second optional configuration setting is `overwrite`. When `overwrite` is
`true`, `add_cloud_metadata` overwrites existing `cloud.*` fields (`false` by
default).

The metadata that is added to events varies by hosting provider. Below are
examples for each of the supported providers.

_AWS_

[source,json]
-------------------------------------------------------------------------------
{
  ""cloud"": {
    ""availability_zone"": ""us-east-1c"",
    ""instance_id"": ""i-4e123456"",
    ""machine_type"": ""t2.medium"",
    ""provider"": ""aws"",
    ""region"": ""us-east-1""
  }
}
-------------------------------------------------------------------------------

_Digital Ocean_

[source,json]
-------------------------------------------------------------------------------
{
  ""cloud"": {
    ""instance_id"": ""1234567"",
    ""provider"": ""digitalocean"",
    ""region"": ""nyc2""
  }
}
-------------------------------------------------------------------------------

_GCP_

[source,json]
-------------------------------------------------------------------------------
{
  ""cloud"": {
    ""availability_zone"": ""us-east1-b"",
    ""instance_id"": ""1234556778987654321"",
    ""machine_type"": ""f1-micro"",
    ""project_id"": ""my-dev"",
    ""provider"": ""gcp""
  }
}
-------------------------------------------------------------------------------

_Tencent Cloud_

[source,json]
-------------------------------------------------------------------------------
{
  ""cloud"": {
    ""availability_zone"": ""gz-azone2"",
    ""instance_id"": ""ins-qcloudv5"",
    ""provider"": ""qcloud"",
    ""region"": ""china-south-gz""
  }
}
-------------------------------------------------------------------------------

_Alibaba Cloud_

This metadata is only available when VPC is selected as the network type of the
ECS instance.

[source,json]
-------------------------------------------------------------------------------
{
  ""cloud"": {
    ""availability_zone"": ""cn-shenzhen"",
    ""instance_id"": ""i-wz9g2hqiikg0aliyun2b"",
    ""provider"": ""ecs"",
    ""region"": ""cn-shenzhen-a""
  }
}
-------------------------------------------------------------------------------

_Azure Virtual Machine_

[source,json]
-------------------------------------------------------------------------------
{
  ""cloud"": {
    ""provider"": ""az"",
    ""instance_id"": ""04ab04c3-63de-4709-a9f9-9ab8c0411d5e"",
    ""instance_name"": ""test-az-vm"",
    ""machine_type"": ""Standard_D3_v2"",
    ""region"": ""eastus2""
  }
}
-------------------------------------------------------------------------------

_Openstack Nova_

[source,json]
-------------------------------------------------------------------------------
{
  ""cloud"": {
    ""provider"": ""openstack"",
    ""instance_name"": ""test-998d932195.mycloud.tld"",
    ""availability_zone"": ""xxxx-az-c"",
    ""instance_id"": ""i-00011a84"",
    ""machine_type"": ""m2.large""
  }
}
-------------------------------------------------------------------------------

[[add-fields]]
=== Add fields

The `add_fields` processor adds additional fields to the event.  Fields can be
scalar values, arrays, dictionaries, or any nested combination of these.  By
default the fields that you specify will be grouped under the `fields`
sub-dictionary in the event. To group the fields under a different
sub-dictionary, use the `target` setting. To store the fields as
top-level fields, set `target: ''`. 

`target`:: (Optional) Sub-dictionary to put all fields into. Defaults to `fields`.
`fields`:: Fields to be added.


For example, this configuration:

[source,yaml]
------------------------------------------------------------------------------
processors:
- add_fields:
    target: project
    fields:
      name: myproject
      id: '574734885120952459'
------------------------------------------------------------------------------

Adds these fields to any event:

[source,json]
-------------------------------------------------------------------------------
{
  ""project"": {
    ""name"": ""myproject"",
    ""id"": ""574734885120952459""
  }
}
-------------------------------------------------------------------------------


[[add-labels]]
=== Add labels

The `add_labels` processors adds a set of key-value pairs to an event.
The processor will flatten nested configuration objects like arrays or
dictionaries into a fully qualified name by merging nested names with a `.`.
Array entries create numeric names starting with 0.  Labels are always stored
under the Elastic Common Schema compliant `labels` sub-dictionary.

`labels`:: dictionaries of labels to be added.

For example, this configuration:

[source,yaml]
------------------------------------------------------------------------------
processors:
- add_labels:
    labels:
      number: 1
      with.dots: test
      nested:
        with.dots: nested
      array:
        - do
	- re
	- with.field: mi
------------------------------------------------------------------------------

Adds these fields to every event:

[source,json]
-------------------------------------------------------------------------------
{
  ""labels"": {
    ""number"": 1,
    ""with.dots"": ""test"",
    ""nested.with.dots"": ""nested"",
    ""array.0"": ""do"",
    ""array.1"": ""re"",
    ""array.2.with.field"": ""mi""
  }
}
-------------------------------------------------------------------------------


[[add-locale]]
=== Add the local time zone

The `add_locale` processor enriches each event with the machine's time zone
offset from UTC or with the name of the time zone. It supports one configuration
option named `format` that controls whether an offset or time zone abbreviation
is added to the event. The default format is `offset`. The processor adds the
a `event.timezone` value to each event.

The configuration below enables the processor with the default settings.

[source,yaml]
-------------------------------------------------------------------------------
processors:
- add_locale: ~
-------------------------------------------------------------------------------

This configuration enables the processor and configures it to add the time zone
abbreviation to events.

[source,yaml]
-------------------------------------------------------------------------------
processors:
- add_locale:
    format: abbreviation
-------------------------------------------------------------------------------

NOTE: Please note that `add_locale` differentiates between daylight savings
time (DST) and regular time. For example `CEST` indicates DST and and `CET` is
regular time.

[[add-tags]]
=== Add tags

The `add_tags` processor adds tags to a list of tags. If the target field already exists,
the tags are appended to the existing list of tags.

`tags`:: List of tags to add.
`target`:: (Optional) Field the tags will be added to. Defaults to `tags`.

For example, this configuration:


[source,yaml]
------------------------------------------------------------------------------
processors:
- add_tags:
    tags: [web, production]
    target: ""environment""
------------------------------------------------------------------------------

Adds the environment field to every event:

[source,json]
-------------------------------------------------------------------------------
{
  ""environment"": [""web"", ""production""]
}
-------------------------------------------------------------------------------

ifdef::has_decode_csv_fields_processor[]
[[decode-csv-fields]]
=== Decode CSV fields

experimental[]

The `decode_csv_fields` processor decodes fields containing records in
comma-separated format (CSV). It will output the values as an array of strings.
This processor is available for Filebeat and Journalbeat.

[source,yaml]
-----------------------------------------------------
processors:
 - decode_csv_fields:
     fields:
        message: decoded.csv
     separator: ,
     ignore_missing: false
     overwrite_keys: true
     trim_leading_whitespace: false
     fail_on_error: true
-----------------------------------------------------

The `decode_csv_fields` has the following settings:

`fields`:: This is a mapping from the source field containing the CSV data to
           the destination field to which the decoded array will be written.
`separator`:: (Optional) Character to be used as a column separator.
              The default is the comma character. For using a TAB character you
              must set it to ""\\t"".
`ignore_missing`:: (Optional) Whether to ignore events which lack the source
                   field. The default is `false`, which will fail processing of
                   an event if a field is missing.
`overwrite_keys`:: Whether the target field is overwritten if it
                   already exists. The default is false, which will fail
                   processing of an event when `target` already exists.
`trim_leading_space`:: Whether extra space after the separator is trimmed from
                       values. This works even if the separator is also a space.
                       The default is `false`.
`fail_on_error`:: (Optional) If set to true, in case of an error the changes to
the event are reverted, and the original event is returned. If set to `false`,
processing continues also if an error happens. Default is `true`.

endif::[]

[[decode-json-fields]]
=== Decode JSON fields

The `decode_json_fields` processor decodes fields containing JSON strings and
replaces the strings with valid JSON objects.

[source,yaml]
-----------------------------------------------------
processors:
 - decode_json_fields:
     fields: [""field1"", ""field2"", ...]
     process_array: false
     max_depth: 1
     target: """"
     overwrite_keys: false
-----------------------------------------------------

The `decode_json_fields` processor has the following configuration settings:

`fields`:: The fields containing JSON strings to decode.
`process_array`:: (Optional) A boolean that specifies whether to process
arrays. The default is false.
`max_depth`:: (Optional) The maximum parsing depth. The default is 1.
`target`:: (Optional) The field under which the decoded JSON will be written. By
default the decoded JSON object replaces the string field from which it was
read. To merge the decoded JSON fields into the root of the event, specify
`target` with an empty string (`target: """"`). Note that the `null` value (`target:`)
is treated as if the field was not set at all.
`overwrite_keys`:: (Optional) A boolean that specifies whether keys that already
exist in the event are overwritten by keys from the decoded JSON object. The
default value is false.

[[community-id]]
=== Community ID Network Flow Hash

The `community_id` processor computes a network flow hash according to the
https://github.com/corelight/community-id-spec[Community ID Flow Hash
specification].

The flow hash is useful for correlating all network events related to a
single flow. For example you can filter on a community ID value and you might
get back the Netflow records from multiple collectors and layer 7 protocol
records from Packetbeat.

By default the processor is configured to read the flow parameters from the
appropriate Elastic Common Schema (ECS) fields. If you are processing ECS data
then no parameters are required.

[source,yaml]
----
processors:
  - community_id:
----

If the data does not conform to ECS then you can customize the field names
that the processor reads from. You can also change the `target` field which
is where the computed hash is written to.

[source,yaml]
----
processors:
  - community_id:
      fields:
        source_ip: my_source_ip
        source_port: my_source_port
        destination_ip: my_dest_ip
        destination_port: my_dest_port
        transport: proto
        icmp_type: my_icmp_type
        icmp_code: my_icmp_code
      target: network.community_id
----

If the necessary fields are not present in the event then the processor will
silently continue without adding the target field.

The processor also accepts an optional `seed` parameter that must be a 16-bit
unsigned integer. This value gets incorporated into all generated hashes.

[[convert]]
=== Convert

The `convert` processor converts a field in the event to a different type, such
as converting a string to an integer.

The supported types include: `integer`, `long`, `float`, `double`, `string`,
`boolean`, and `ip`.

The `ip` type is effectively an alias for `string`, but with an added validation
that the value is an IPv4 or IPv6 address.

[source,yaml]
----
processors:
  - convert:
      fields:
        - {from: ""src_ip"", to: ""source.ip"", type: ""ip""}
        - {from: ""src_port"", to: ""source.port"", type: ""integer""}
      ignore_missing: true
      fail_on_error: false
----

The `convert` processor has the following configuration settings:

`fields`:: (Required) This is the list of fields to convert. At least one item
must be contained in the list. Each item in the list must have a `from` key that
specifies the source field. The `to` key is optional and specifies where to
assign the converted value. If `to` is omitted then the `from` field is updated
in-place. The `type` key specifies the data type to convert the value to. If
`type` is omitted then the processor copies or renames the field without any
type conversion.

`ignore_missing`:: (Optional) If `true` the processor continues to the next
field when the `from` key is not found in the event. If false then the processor
returns an error and does not process the remaining fields. Default is `false`.

`fail_on_error`:: (Optional) If false type conversion failures are ignored and
the processor continues to the next field. Default is `true`.

`tag`:: (Optional) An identifier for this processor. Useful for debugging.

`mode`:: (Optional) When both `from` and `to` are defined for a field then
`mode` controls whether to `copy` or `rename` the field when the type conversion
is successful. Default is `copy`.

[[drop-event]]
=== Drop events

The `drop_event` processor drops the entire event if the associated condition
is fulfilled. The condition is mandatory, because without one, all the events
are dropped.

[source,yaml]
------
processors:
 - drop_event:
     when:
        condition
------

See <<conditions>> for a list of supported conditions.

[[drop-fields]]
=== Drop fields from events

The `drop_fields` processor specifies which fields to drop if a certain
condition is fulfilled. The condition is optional. If it's missing, the
specified fields are always dropped. The `@timestamp` and `type` fields cannot
be dropped, even if they show up in the `drop_fields` list.

[source,yaml]
-----------------------------------------------------
processors:
 - drop_fields:
     when:
        condition
     fields: [""field1"", ""field2"", ...]
-----------------------------------------------------

See <<conditions>> for a list of supported conditions.

NOTE: If you define an empty list of fields under `drop_fields`, then no fields
are dropped.

[[include-fields]]
=== Keep fields from events

The `include_fields` processor specifies which fields to export if a certain
condition is fulfilled. The condition is optional. If it's missing, the
specified fields are always exported. The `@timestamp` and `type` fields are
always exported, even if they are not defined in the `include_fields` list.

[source,yaml]
-------
processors:
 - include_fields:
     when:
        condition
     fields: [""field1"", ""field2"", ...]
-------

See <<conditions>> for a list of supported conditions.

You can specify multiple `include_fields` processors under the `processors`
section.

NOTE: If you define an empty list of fields under `include_fields`, then only
the required fields, `@timestamp` and `type`, are exported.

[[rename-fields]]
=== Rename fields from events

The `rename` processor specifies a list of fields to rename. Under the `fields`
key each entry contains a `from: old-key` and a `to: new-key` pair. `from` is
the origin and `to` the target name of the field.

Renaming fields can be useful in cases where field names cause conflicts. For
example if an event has two fields, `c` and `c.b`, that are both assigned scalar
values (e.g. `{""c"": 1, ""c.b"": 2}`) this will result in an Elasticsearch error at
ingest time. This is because the value of a cannot simultaneously be a scalar
and an object. To prevent this rename_fields can be used to rename `c` to
`c.value`.

Rename fields cannot be used to overwrite fields. To overwrite fields either
first rename the target field or use the `drop_fields` processor to drop the
field and then rename the field.

[source,yaml]
-------
processors:
- rename:
    fields:
     - from: ""a.g""
       to: ""e.d""
    ignore_missing: false
    fail_on_error: true
-------

The `rename` processor has the following configuration settings:

`ignore_missing`:: (Optional) If set to true, no error is logged in case a key
which should be renamed is missing. Default is `false`.

`fail_on_error`:: (Optional) If set to true, in case of an error the renaming of
fields is stopped and the original event is returned. If set to false, renaming
continues also if an error happened during renaming. Default is `true`.

See <<conditions>> for a list of supported conditions.

You can specify multiple `ignore_missing` processors under the `processors`
section.

[[add-kubernetes-metadata]]
=== Add Kubernetes metadata

The `add_kubernetes_metadata` processor annotates each event with relevant
metadata based on which Kubernetes pod the event originated from. Each event is
annotated with:

* Pod Name
* Pod UID
* Namespace
* Labels

The `add_kubernetes_metadata` processor has two basic building blocks which are:

* Indexers
* Matchers

Indexers take in a pod's metadata and builds indices based on the pod metadata.
For example, the `ip_port` indexer can take a Kubernetes pod and index the pod
metadata based on all `pod_ip:container_port` combinations.

Matchers are used to construct lookup keys for querying indices. For example,
when the `fields` matcher takes `[""metricset.host""]` as a lookup field, it would
construct a lookup key with the value of the field `metricset.host`.

Each Beat can define its own default indexers and matchers which are enabled by
default. For example, FileBeat enables the `container` indexer, which indexes
pod metadata based on all container IDs, and a `logs_path` matcher, which takes
the `log.file.path` field, extracts the container ID, and uses it to retrieve 
metadata.

The configuration below enables the processor when {beatname_lc} is run as a pod in
Kubernetes.

[source,yaml]
-------------------------------------------------------------------------------
processors:
- add_kubernetes_metadata:
    in_cluster: true
-------------------------------------------------------------------------------

The configuration below enables the processor on a Beat running as a process on
the Kubernetes node.

[source,yaml]
-------------------------------------------------------------------------------
processors:
- add_kubernetes_metadata:
    in_cluster: false
    host: <hostname>
    kube_config: ${HOME}/.kube/config
-------------------------------------------------------------------------------

The configuration below has the default indexers and matchers disabled and
enables ones that the user is interested in.

[source,yaml]
-------------------------------------------------------------------------------
processors:
- add_kubernetes_metadata:
    in_cluster: false
    host: <hostname>
    kube_config: ~/.kube/config
    default_indexers.enabled: false
    default_matchers.enabled: false
    indexers:
      - ip_port:
    matchers:
      - fields:
          lookup_fields: [""metricset.host""]
-------------------------------------------------------------------------------

The `add_kubernetes_metadata` processor has the following configuration settings:

`in_cluster`:: (Optional) Use in cluster settings for Kubernetes client, `true`
by default.
`host`:: (Optional) Identify the node where {beatname_lc} is running in case it
cannot be accurately detected, as when running {beatname_lc} in host network
mode.
`namespace`:: (Optional) Select the namespace from which to collect the
metadata. If it is not set, the processor collects metadata from all namespaces.
It is unset by default.
`kube_config`:: (Optional) Use given config file as configuration for Kubernetes
client.
`default_indexers.enabled`:: (Optional) Enable/Disable default pod indexers, in
case you want to specify your own.
`default_matchers.enabled`:: (Optional) Enable/Disable default pod matchers, in
case you want to specify your own.

[[add-docker-metadata]]
=== Add Docker metadata

The `add_docker_metadata` processor annotates each event with relevant metadata
from Docker containers:

* Container ID
* Name
* Image
* Labels

[NOTE]
=====
When running {beatname_uc} in a container, you need to provide access to
Docker’s unix socket in order for the `add_docker_metadata` processor to work.
You can do this by mounting the socket inside the container. For example:

`docker run -v /var/run/docker.sock:/var/run/docker.sock ...`

To avoid privilege issues, you may also need to add `--user=root` to the
`docker run` flags. Because the user must be part of the docker group in order
to access `/var/run/docker.sock`, root access is required if {beatname_uc} is
running as non-root inside the container. 
=====

[source,yaml]
-------------------------------------------------------------------------------
processors:
- add_docker_metadata:
    host: ""unix:///var/run/docker.sock""
    #match_fields: [""system.process.cgroup.id""]
    #match_pids: [""process.pid"", ""process.ppid""]
    #match_source: true
    #match_source_index: 4
    #match_short_id: true
    #cleanup_timeout: 60
    #labels.dedot: false
    # To connect to Docker over TLS you must specify a client and CA certificate.
    #ssl:
    #  certificate_authority: ""/etc/pki/root/ca.pem""
    #  certificate:           ""/etc/pki/client/cert.pem""
    #  key:                   ""/etc/pki/client/cert.key""
-------------------------------------------------------------------------------

It has the following settings:

`host`:: (Optional) Docker socket (UNIX or TCP socket). It uses
`unix:///var/run/docker.sock` by default.

`ssl`:: (Optional) SSL configuration to use when connecting to the Docker
socket.

`match_fields`:: (Optional) A list of fields to match a container ID, at least
one of them should hold a container ID to get the event enriched.

`match_pids`:: (Optional) A list of fields that contain process IDs. If the
process is running in Docker then the event will be enriched. The default value
is `[""process.pid"", ""process.ppid""]`.

`match_source`:: (Optional) Match container ID from a log path present in the
`log.file.path` field. Enabled by default.

`match_short_id`:: (Optional) Match container short ID from a log path present
in the `log.file.path` field. Disabled by default.
This allows to match directories names that have the first 12 characters
of the container ID. For example, `/var/log/containers/b7e3460e2b21/*.log`.

`match_source_index`:: (Optional) Index in the source path split by `/` to look
for container ID. It defaults to 4 to match
`/var/lib/docker/containers/<container_id>/*.log`

`cleanup_timeout`:: (Optional) Time of inactivity to consider we can clean and
forget metadata for a container, 60s by default.

`labels.dedot`:: (Optional) Default to be false. If set to true, replace dots in
 labels with `_`.

[[add-host-metadata]]
=== Add Host metadata

beta[]

[source,yaml]
-------------------------------------------------------------------------------
processors:
- add_host_metadata:
    netinfo.enabled: false
    cache.ttl: 5m
    geo:
      name: nyc-dc1-rack1
      location: 40.7128, -74.0060
      continent_name: North America
      country_iso_code: US
      region_name: New York
      region_iso_code: NY
      city_name: New York
-------------------------------------------------------------------------------

It has the following settings:

`netinfo.enabled`:: (Optional) Default false. Include IP addresses and MAC addresses as fields host.ip and host.mac

`cache.ttl`:: (Optional) The processor uses an internal cache for the host metadata. This sets the cache expiration time. The default is 5m, negative values disable caching altogether.

`geo.name`:: User definable token to be used for identifying a discrete location. Frequently a datacenter, rack, or similar.

`geo.location`:: Longitude and latitude in comma separated format.

`geo.continent_name`:: Name of the continent.

`geo.country_name`:: Name of the country.

`geo.region_name`:: Name of the region.

`geo.city_name`:: Name of the city.

`geo.country_iso_code`:: ISO country code.

`geo.region_iso_code`:: ISO region code.


The `add_host_metadata` processor annotates each event with relevant metadata from the host machine.
The fields added to the event look like the following:

[source,json]
-------------------------------------------------------------------------------
{
   ""host"":{
      ""architecture"":""x86_64"",
      ""name"":""example-host"",
      ""id"":"""",
      ""os"":{
         ""family"":""darwin"",
         ""build"":""16G1212"",
         ""platform"":""darwin"",
         ""version"":""10.12.6"",
         ""kernel"":""16.7.0"",
         ""name"":""Mac OS X""
      },
      ""ip"": [""192.168.0.1"", ""10.0.0.1""],
      ""mac"": [""00:25:96:12:34:56"", ""72:00:06:ff:79:f1""],
      ""geo"": {
          ""continent_name"": ""North America"",
          ""country_iso_code"": ""US"",
          ""region_name"": ""New York"",
          ""region_iso_code"": ""NY"",
          ""city_name"": ""New York"",
          ""name"": ""nyc-dc1-rack1"",
          ""location"": ""40.7128, -74.0060""
        }
   }
}
-------------------------------------------------------------------------------

[[add-observer-metadata]]
=== Add Observer metadata

beta[]

[source,yaml]
-------------------------------------------------------------------------------
processors:
- add_observer_metadata:
    netinfo.enabled: false
    cache.ttl: 5m
    geo:
      name: nyc-dc1-rack1
      location: 40.7128, -74.0060
      continent_name: North America
      country_iso_code: US
      region_name: New York
      region_iso_code: NY
      city_name: New York
-------------------------------------------------------------------------------

It has the following settings:

`netinfo.enabled`:: (Optional) Default false. Include IP addresses and MAC addresses as fields observer.ip and observer.mac

`cache.ttl`:: (Optional) The processor uses an internal cache for the observer metadata. This sets the cache expiration time. The default is 5m, negative values disable caching altogether.

`geo.name`:: User definable token to be used for identifying a discrete location. Frequently a datacenter, rack, or similar.

`geo.location`:: Longitude and latitude in comma separated format.

`geo.continent_name`:: Name of the continent.

`geo.country_name`:: Name of the country.

`geo.region_name`:: Name of the region.

`geo.city_name`:: Name of the city.

`geo.country_iso_code`:: ISO country code.

`geo.region_iso_code`:: ISO region code.


The `add_geo_metadata` processor annotates each event with relevant metadata from the observer machine.
The fields added to the event look like the following:

[source,json]
-------------------------------------------------------------------------------
{
  ""observer"" : {
    ""hostname"" : ""avce"",
    ""type"" : ""heartbeat"",
    ""vendor"" : ""elastic"",
    ""ip"" : [
      ""192.168.1.251"",
      ""fe80::64b2:c3ff:fe5b:b974"",
    ],
    ""mac"" : [
      ""dc:c1:02:6f:1b:ed"",
    ],
    ""geo"": {
      ""continent_name"": ""North America"",
      ""country_iso_code"": ""US"",
      ""region_name"": ""New York"",
      ""region_iso_code"": ""NY"",
      ""city_name"": ""New York"",
      ""name"": ""nyc-dc1-rack1"",
      ""location"": ""40.7128, -74.0060""
    }
  }
}
-------------------------------------------------------------------------------

[[dissect]]
=== Dissect strings

The dissect processor tokenizes incoming strings using defined patterns.

[source,yaml]
-------
processors:
- dissect:
    tokenizer: ""%{key1} %{key2}""
    field: ""message""
    target_prefix: ""dissect""
-------

The `dissect` processor has the following configuration settings:

`field`:: (Optional) The event field to tokenize. Default is `message`.

`target_prefix`:: (Optional) The name of the field where the values will be extracted. When an empty
string is defined, the processor will create the keys at the root of the event. Default is
`dissect`. When the target key already exists in the event, the processor won't replace it and log
an error; you need to either drop or rename the key before using dissect.

For tokenization to be successful, all keys must be found and extracted, if one of them cannot be
found an error will be logged and no modification is done on the original event.

NOTE: A key can contain any characters except reserved suffix or prefix modifiers:  `/`,`&`, `+`
and `?`.

See <<conditions>> for a list of supported conditions.

[[processor-dns]]
=== DNS Reverse Lookup

The DNS processor performs reverse DNS lookups of IP addresses. It caches the
responses that it receives in accordance to the time-to-live (TTL) value
contained in the response. It also caches failures that occur during lookups.
Each instance of this processor maintains its own independent cache.

The processor uses its own DNS resolver to send requests to nameservers and does
not use the operating system's resolver. It does not read any values contained
in `/etc/hosts`.

This processor can significantly slow down your pipeline's throughput if you
have a high latency network or slow upstream nameserver. The cache will help
with performance, but if the addresses being resolved have a high cardinality
then the cache benefits will be diminished due to the high miss ratio.

By way of example, if each DNS lookup takes 2 milliseconds, the maximum
throughput you can achieve is 500 events per second (1000 milliseconds / 2
milliseconds). If you have a high cache hit ratio then your throughput can be
higher.

This is a minimal configuration example that resolves the IP addresses contained
in two fields.

[source,yaml]
----
processors:
- dns:
    type: reverse
    fields:
      source.ip: source.hostname
      destination.ip: destination.hostname
----

Next is a configuration example showing all options.

[source,yaml]
----
processors:
- dns:
    type: reverse
    action: append
    fields:
      server.ip: server.hostname
      client.ip: client.hostname
    success_cache:
      capacity.initial: 1000
      capacity.max: 10000
    failure_cache:
      capacity.initial: 1000
      capacity.max: 10000
      ttl: 1m
    nameservers: ['192.0.2.1', '203.0.113.1']
    timeout: 500ms
    tag_on_failure: [_dns_reverse_lookup_failed]
----

The `dns` processor has the following configuration settings:

`type`:: The type of DNS lookup to perform. The only supported type is
`reverse` which queries for a PTR record.

`action`:: This defines the behavior of the processor when the target field
already exists in the event. The options are `append` (default) and `replace`.

`fields`:: This is a mapping of source field names to target field names. The
value of the source field will be used in the DNS query and result will be
written to the target field.

`success_cache.capacity.initial`:: The initial number of items that the success
cache will be allocated to hold. When initialized the processor will allocate
the memory for this number of items. Default value is `1000`.

`success_cache.capacity.max`:: The maximum number of items that the success
cache can hold. When the maximum capacity is reached a random item is evicted.
Default value is `10000`.

`failure_cache.capacity.initial`:: The initial number of items that the failure
cache will be allocated to hold. When initialized the processor will allocate
the memory for this number of items. Default value is `1000`.

`failure_cache.capacity.max`:: The maximum number of items that the failure
cache can hold. When the maximum capacity is reached a random item is evicted.
Default value is `10000`.

`failure_cache.ttl`:: The duration for which failures are cached. Valid time
units are ""ns"", ""us"" (or ""µs""), ""ms"", ""s"", ""m"", ""h"". Default value is `1m`.

`nameservers`:: A list of nameservers to query. If there are multiple servers,
the resolver queries them in the order listed. If none are specified then it
will read the nameservers listed in `/etc/resolv.conf` once at initialization.
On Windows you must always supply at least one nameserver.

`timeout`:: The duration after which a DNS query will timeout. This is timeout
for each DNS request so if you have 2 nameservers then the total timeout will be
2 times this value. Valid time units are ""ns"", ""us"" (or ""µs""), ""ms"", ""s"", ""m"",
""h"". Default value is `500ms`.

`tag_on_failure`:: A list of tags to add to the event when any lookup fails. The
tags are only added once even if multiple lookups fail. By default no tags are
added upon failure.

[[add-process-metadata]]
=== Add process metadata

The Add process metadata processor enriches events with information from running
processes, identified by their process ID (PID).

[source,yaml]
-------------------------------------------------------------------------------
processors:
- add_process_metadata:
    match_pids: [system.process.ppid]
    target: system.process.parent
-------------------------------------------------------------------------------

The fields added to the event look as follows:
[source,json]
-------------------------------------------------------------------------------
""process"": {
  ""name"":  ""systemd"",
  ""title"": ""/usr/lib/systemd/systemd --switched-root --system --deserialize 22"",
  ""exe"":   ""/usr/lib/systemd/systemd"",
  ""args"":  [""/usr/lib/systemd/systemd"", ""--switched-root"", ""--system"", ""--deserialize"", ""22""],
  ""pid"":   1,
  ""ppid"":  0,
  ""start_time"": ""2018-08-22T08:44:50.684Z"",
}
-------------------------------------------------------------------------------

Optionally, the process environment can be included, too:
[source,json]
-------------------------------------------------------------------------------
  ...
  ""env"": {
    ""HOME"":       ""/"",
    ""TERM"":       ""linux"",
    ""BOOT_IMAGE"": ""/boot/vmlinuz-4.11.8-300.fc26.x86_64"",
    ""LANG"":       ""en_US.UTF-8"",
  }
  ...
-------------------------------------------------------------------------------
It has the following settings:

`match_pids`:: List of fields to lookup for a PID. The processor will
search the list sequentially until the field is found in the current event, and
the PID lookup will be applied to the value of this field.

`target`:: (Optional) Destination prefix where the `process` object will be
created. The default is the event's root.

`include_fields`:: (Optional) List of fields to add. By default, the processor
will add all the available fields except `process.env`.

`ignore_missing`:: (Optional) When set to `false`, events that don't contain any
of the fields in match_pids will be discarded and an error will be generated. By
default, this condition is ignored.

`overwrite_keys`:: (Optional) By default, if a target field already exists, it
will not be overwritten and an error will be logged. If `overwrite_keys` is
set to `true`, this condition will be ignored.

`restricted_fields`:: (Optional) By default, the `process.env` field is not
output, to avoid leaking sensitive data. If `restricted_fields` is `true`, the
field will be present in the output.

ifdef::has_script_processor[]
[[processor-script]]
=== Script Processor

experimental[]

The script processor executes Javascript code to process an event. The processor
uses a pure Go implementation of ECMAScript 5.1 and has no external
dependencies. This can be useful in situations where one of the other processors
doesn't provide the functionality you need to filter events.

The processor can be configured by embedding Javascript in your configuration
file or by pointing the processor at external file(s).

[source,yaml]
----
processors:
- script:
    lang: javascript
    id: my_filter
    source: >
      function process(event) {
          event.Tag(""js"");
      }
----

This loads `filter.js` from disk.

[source,yaml]
----
processors:
- script:
    lang: javascript
    id: my_filter
    file: ${path.config}/filter.js
----

Parameters can be passed to the script by adding `params` to the config.
This allows for a script to be made reusable. When using `params` the
code must define a `register(params)` function to receive the parameters.

[source,yaml]
----
processors:
- script:
    lang: javascript
    id: my_filter
    params:
      threshold: 15
    source: >
      var params = {threshold: 42};
      function register(scriptParams) {
          params = scriptParams;
      }
      function process(event) {
          if (event.Get(""severity"") < params.threshold) {
              event.Cancel();
          }
      }
----

If the script defines a `test()` function it will be invoked when the processor
is loaded. Any exceptions thrown will cause the processor to fail to load. This
can be used to make assertions about the behavior of the script.

[source,javascript]
----
function process(event) {
    if (event.Get(""event.code"") === 1102) {
        event.Put(""event.action"", ""cleared"");
    }
}

function test() {
    var event = process(new Event({event: {code: 1102}));
    if (event.Get(""event.action"") !== ""cleared"") {
        throw ""expected event.action === cleared"";
    }
}
----

[float]
==== Configuration options

The `script` processor has the following configuration settings:

`lang`:: This field is required and its value must be `javascript`.

`tag`:: This is an optional identifier that is added to log messages. If defined
it enables metrics logging for this instance of the processor. The metrics
include the number of exceptions and a histogram of the execution times for
the `process` function.

`source`:: Inline Javascript source code.

`file`:: Path to a script file to load. Relative paths are interpreted as
relative to the `path.config` directory. Globs are expanded.

`files`:: List of script files to load. The scripts are concatenated together.
Relative paths are interpreted as relative to the `path.config` directory.
And globs are expanded.

`params`:: A dictionary of parameters that are passed to the `register` of the
script.

`tag_on_exception`:: Tag to add to events in case the Javascript code causes an
exception while processing an event. Defaults to `_js_exception`.

`timeout`:: This sets an execution timeout for the `process` function. When
the `process` function takes longer than the `timeout` period the function
is interrupted. You can set this option to prevent a script from running for
too long (like preventing an infinite `while` loop). By default there is no
timeout.

[float]
==== Event API

The `Event` object passed to the `process` method has the following API.

[frame=""topbot"",options=""header""]
|===
|Method |Description

|`Get(string)`
|Get a value from the event (either a scalar or an object). If the key does not
exist `null` is returned. If no key is provided then an object containing all
fields is returned.

*Example*: `var value = event.Get(key);`

|`Put(string, value)`
|Put a value into the event. If the key was already set then the
previous value is returned. It throws an exception if the key cannot be set
because one of the intermediate values is not an object.

*Example*: `var old = event.Put(key, value);`

|`Rename(string, string)`
|Rename a key in the event. The target key must not exist. It
returns true if the source key was successfully renamed to the target key.

*Example*: `var success = event.Rename(""source"", ""target"");`

|`Delete(string)`
|Delete a field from the event. It returns true on success.

*Example*: `var deleted = event.Delete(""user.email"");`

|`Cancel()`
|Flag the event as cancelled which causes the processor to drop
event.

*Example*: `event.Cancel(); return;`

|`Tag(string)`
|Append a tag to the `tags` field if the tag does not already
exist. Throws an exception if `tags` exists and is not a string or a list of
strings.

*Example*: `event.Tag(""user_event"");`

|`AppendTo(string, string)`
|`AppendTo` is a specialized `Put` method that converts the existing value to an
array and appends the value if it does not already exist. If there is an
existing value that's not a string or array of strings then an exception is
thrown.

*Example*: `event.AppendTo(""error.message"", ""invalid file hash"");`
|===
endif::[]

[[extract-array]]
=== Extract array

experimental[]

The `extract_array` processor populates fields with values read from an array
field. The following example will populate `source.ip` with the first element of
the `my_array` field, `destination.ip` with the second element, and
`network.transport` with the third.

[source,yaml]
-----------------------------------------------------
processors:
 - extract_array:
     field: my_array
     mappings:
        source.ip: 0
        destination.ip: 1
        network.transport: 2
-----------------------------------------------------

The following settings are supported:

`field`:: The array field whose elements are to be extracted.
`mappings`:: Maps each field name to an array index. Use 0 for the first element in
             the array. Multiple fields can be mapped to the same array element.
`ignore_missing`:: (Optional) Whether to ignore events where the array field is
                   missing. The default is `false`, which will fail processing
                   of an event if the specified field does not exist. Set it to
                   `true` to ignore this condition.
`overwrite_keys`:: Whether the target fields specified in the mapping are
                   overwritten if they already exist. The default is `false`,
                   which will fail processing if a target field already exists.
`fail_on_error`:: (Optional) If set to `true` and an error happens, changes to
                  the event are reverted, and the original event is returned. If
                  set to `false`, processing continues despite errors.
                  Default is `true`.
`omit_empty`:: (Optional) Whether empty values are extracted from the array. If
                  set to `true`, instead of the target field being set to an
                  empty value, it is left unset. The empty string (`""""`), an
                  empty array (`[]`) or an empty object (`{}`) are considered
                  empty values. Default is `false`.
",12448,False,2016.9292343105258,median
"[[netty-component]]
= Netty Component
:docTitle: Netty
:artifactId: camel-netty
:description: Socket level networking using TCP or UDP with Netty 4.x.
:since: 2.14
:supportLevel: Stable
:component-header: Both producer and consumer are supported
include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/netty.adoc[opts=optional]

*Since Camel {since}*

*{component-header}*

The Netty component in Camel is a socket communication component,
based on the http://netty.io/[Netty] project version 4. +
 Netty is a NIO client server framework which enables quick and easy
development of networkServerInitializerFactory applications such as
protocol servers and clients. +
 Netty greatly simplifies and streamlines network programming such as
TCP and UDP socket server.

This camel component supports both producer and consumer endpoints.

The Netty component has several options and allows fine-grained control
of a number of TCP/UDP communication parameters (buffer sizes,
keepAlives, tcpNoDelay, etc) and facilitates both In-Only and In-Out
communication on a Camel route.

Maven users will need to add the following dependency to their `pom.xml`
for this component:

[source,xml]
----
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-netty</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
----

== URI format

The URI scheme for a netty component is as follows

[source,text]
----
netty:tcp://0.0.0.0:99999[?options]
netty:udp://remotehost:99999/[?options]
----

This component supports producer and consumer endpoints for both TCP and
UDP.

You can append query options to the URI in the following format,
`?option=value&option=value&...`

== Options

// component options: START
The Netty component supports 73 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *configuration* (common) | To use the NettyConfiguration as configuration when creating endpoints. |  | NettyConfiguration
| *disconnect* (common) | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. | false | boolean
| *keepAlive* (common) | Setting to ensure socket is not closed due to inactivity | true | boolean
| *reuseAddress* (common) | Setting to facilitate socket multiplexing | true | boolean
| *reuseChannel* (common) | This option allows producers and consumers (in client mode) to reuse the same Netty Channel for the lifecycle of processing the Exchange. This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection. When using this, the channel is not returned to the connection pool until the Exchange is done; or disconnected if the disconnect option is set to true. The reused Channel is stored on the Exchange as an exchange property with the key NettyConstants#NETTY_CHANNEL which allows you to obtain the channel during routing and use it as well. | false | boolean
| *sync* (common) | Setting to set endpoint as one-way or request-response | true | boolean
| *tcpNoDelay* (common) | Setting to improve TCP protocol performance | true | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *broadcast* (consumer) | Setting to choose Multicast over UDP | false | boolean
| *clientMode* (consumer) | If the clientMode is true, netty consumer will connect the address as a TCP client. | false | boolean
| *reconnect* (consumer) | Used only in clientMode in consumer, the consumer will attempt to reconnect on disconnection if this is enabled | true | boolean
| *reconnectInterval* (consumer) | Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection | 10000 | int
| *backlog* (consumer) | Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200, 500 or 1000, tells the TCP stack how long the accept queue can be If this option is not configured, then the backlog depends on OS setting. |  | int
| *bossCount* (consumer) | When netty works on nio mode, it uses default bossCount parameter from Netty, which is 1. User can use this option to override the default bossCount from Netty | 1 | int
| *bossGroup* (consumer) | Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint |  | EventLoopGroup
| *disconnectOnNoReply* (consumer) | If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back. | true | boolean
| *executorService* (consumer) | To use the given EventExecutorGroup. |  | EventExecutorGroup
| *maximumPoolSize* (consumer) | Sets a maximum thread pool size for the netty consumer ordered thread pool. The default size is 2 x cpu_core plus 1. Setting this value to eg 10 will then use 10 threads unless 2 x cpu_core plus 1 is a higher value, which then will override and be used. For example if there are 8 cores, then the consumer thread pool will be 17. This thread pool is used to route messages received from Netty by Camel. We use a separate thread pool to ensure ordering of messages and also in case some messages will block, then nettys worker threads (event loop) wont be affected. |  | int
| *nettyServerBootstrapFactory* (consumer) | To use a custom NettyServerBootstrapFactory |  | NettyServerBootstrapFactory
| *networkInterface* (consumer) | When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group. |  | String
| *noReplyLogLevel* (consumer) | If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverClosedChannelException{zwsp}CaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | DEBUG | LoggingLevel
| *serverExceptionCaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an exception then its logged using this logging level. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverInitializerFactory* (consumer) | To use a custom ServerInitializerFactory |  | ServerInitializerFactory
| *usingExecutorService* (consumer) | Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. | true | boolean
| *connectTimeout* (producer) | Time to wait for a socket connection to be available. Value is in milliseconds. | 10000 | int
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *requestTimeout* (producer) | Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milli seconds, so eg 30000 is 30 seconds. The requestTimeout is using Netty's ReadTimeoutHandler to trigger the timeout. |  | long
| *clientInitializerFactory* (producer) | To use a custom ClientInitializerFactory |  | ClientInitializerFactory
| *correlationManager* (producer) | To use a custom correlation manager to manage how request and reply messages are mapped when using request/reply with the netty producer. This should only be used if you have a way to map requests together with replies such as if there is correlation ids in both the request and reply messages. This can be used if you want to multiplex concurrent messages on the same channel (aka connection) in netty. When doing this you must have a way to correlate the request and reply messages so you can store the right reply on the inflight Camel Exchange before its continued routed. We recommend extending the TimeoutCorrelationManagerSupport when you build custom correlation managers. This provides support for timeout and other complexities you otherwise would need to implement as well. See also the producerPoolEnabled option for more details. |  | NettyCamelStateCorrelationManager
| *lazyChannelCreation* (producer) | Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. | true | boolean
| *producerPoolEnabled* (producer) | Whether producer pool is enabled or not. Important: If you turn this off then a single shared connection is used for the producer, also if you are doing request/reply. That means there is a potential issue with interleaved responses if replies comes back out-of-order. Therefore you need to have a correlation id in both the request and reply messages so you can properly correlate the replies to the Camel callback that is responsible for continue processing the message in Camel. To do this you need to implement NettyCamelStateCorrelationManager as correlation manager and configure it via the correlationManager option. See also the correlationManager option for more details. | true | boolean
| *producerPoolMaxActive* (producer) | Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit. | -1 | int
| *producerPoolMaxIdle* (producer) | Sets the cap on the number of idle instances in the pool. | 100 | int
| *producerPoolMinEvictableIdle* (producer) | Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor. | 300000 | long
| *producerPoolMinIdle* (producer) | Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects. |  | int
| *udpConnectionlessSending* (producer) | This option supports connection less udp sending which is a real fire and forget. A connected udp send receive the PortUnreachableException if no one is listen on the receiving port. | false | boolean
| *useByteBuf* (producer) | If the useByteBuf is true, netty producer will turn the message body into ByteBuf before sending it out. | false | boolean
| *hostnameVerification* ( security) | To enable/disable hostname verification on SSLEngine | false | boolean
| *allowSerializedHeaders* (advanced) | Only used for TCP when transferExchange is true. When set to true, serializable objects in headers and properties will be added to the exchange. Otherwise Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *autowiredEnabled* (advanced) | Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. | true | boolean
| *channelGroup* (advanced) | To use a explicit ChannelGroup. |  | ChannelGroup
| *nativeTransport* (advanced) | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: \\http://netty.io/wiki/native-transports.html | false | boolean
| *options* (advanced) | Allows to configure additional netty options using option. as prefix. For example option.child.keepAlive=false to set the netty option child.keepAlive=false. See the Netty documentation for possible options that can be used. |  | Map
| *receiveBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. | 65536 | int
| *receiveBufferSizePredictor* (advanced) | Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |  | int
| *sendBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. | 65536 | int
| *transferExchange* (advanced) | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *udpByteArrayCodec* (advanced) | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | boolean
| *workerCount* (advanced) | When netty works on nio mode, it uses default workerCount parameter from Netty (which is cpu_core_threads x 2). User can use this option to override the default workerCount from Netty. |  | int
| *workerGroup* (advanced) | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. |  | EventLoopGroup
| *allowDefaultCodec* (codec) | The netty component installs a default codec if both, encoder/decoder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | boolean
| *autoAppendDelimiter* (codec) | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | boolean
| *decoderMaxLineLength* (codec) | The max line length to use for the textline codec. | 1024 | int
| *decoders* (codec) | A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *delimiter* (codec) | The delimiter to use for the textline codec. Possible values are LINE and NULL. There are 2 enums and the value can be one of: LINE, NULL | LINE | TextLineDelimiter
| *encoders* (codec) | A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *encoding* (codec) | The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |  | String
| *textline* (codec) | Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP - however only Strings are allowed to be serialized by default. | false | boolean
| *enabledProtocols* (security) | Which protocols to enable when using SSL | TLSv1,TLSv1.1,TLSv1.2 | String
| *keyStoreFile* (security) | Client side certificate keystore to be used for encryption |  | File
| *keyStoreFormat* (security) | Keystore format to be used for payload encryption. Defaults to JKS if not set |  | String
| *keyStoreResource* (security) | Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *needClientAuth* (security) | Configures whether the server needs client authentication when using SSL. | false | boolean
| *passphrase* (security) | Password setting to use in order to encrypt/decrypt payloads sent using SSH |  | String
| *securityProvider* (security) | Security provider to be used for payload encryption. Defaults to SunX509 if not set. |  | String
| *ssl* (security) | Setting to specify whether SSL encryption is applied to this endpoint | false | boolean
| *sslClientCertHeaders* (security) | When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. | false | boolean
| *sslContextParameters* (security) | To configure security using SSLContextParameters |  | SSLContextParameters
| *sslHandler* (security) | Reference to a class that could be used to return an SSL Handler |  | SslHandler
| *trustStoreFile* (security) | Server side certificate keystore to be used for encryption |  | File
| *trustStoreResource* (security) | Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *useGlobalSslContextParameters* (security) | Enable usage of global SSL context parameters. | false | boolean
|===
// component options: END


// endpoint options: START
The Netty endpoint is configured using URI syntax:

----
netty:protocol://host:port
----

with the following path and query parameters:

=== Path Parameters (3 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *protocol* | *Required* The protocol to use which can be tcp or udp. There are 2 enums and the value can be one of: tcp, udp |  | String
| *host* | *Required* The hostname. For the consumer the hostname is localhost or 0.0.0.0. For the producer the hostname is the remote host to connect to |  | String
| *port* | *Required* The host port number |  | int
|===


=== Query Parameters (71 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *disconnect* (common) | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. | false | boolean
| *keepAlive* (common) | Setting to ensure socket is not closed due to inactivity | true | boolean
| *reuseAddress* (common) | Setting to facilitate socket multiplexing | true | boolean
| *reuseChannel* (common) | This option allows producers and consumers (in client mode) to reuse the same Netty Channel for the lifecycle of processing the Exchange. This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection. When using this, the channel is not returned to the connection pool until the Exchange is done; or disconnected if the disconnect option is set to true. The reused Channel is stored on the Exchange as an exchange property with the key NettyConstants#NETTY_CHANNEL which allows you to obtain the channel during routing and use it as well. | false | boolean
| *sync* (common) | Setting to set endpoint as one-way or request-response | true | boolean
| *tcpNoDelay* (common) | Setting to improve TCP protocol performance | true | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *broadcast* (consumer) | Setting to choose Multicast over UDP | false | boolean
| *clientMode* (consumer) | If the clientMode is true, netty consumer will connect the address as a TCP client. | false | boolean
| *reconnect* (consumer) | Used only in clientMode in consumer, the consumer will attempt to reconnect on disconnection if this is enabled | true | boolean
| *reconnectInterval* (consumer) | Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection | 10000 | int
| *backlog* (consumer) | Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200, 500 or 1000, tells the TCP stack how long the accept queue can be If this option is not configured, then the backlog depends on OS setting. |  | int
| *bossCount* (consumer) | When netty works on nio mode, it uses default bossCount parameter from Netty, which is 1. User can use this option to override the default bossCount from Netty | 1 | int
| *bossGroup* (consumer) | Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint |  | EventLoopGroup
| *disconnectOnNoReply* (consumer) | If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back. | true | boolean
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut |  | ExchangePattern
| *nettyServerBootstrapFactory* (consumer) | To use a custom NettyServerBootstrapFactory |  | NettyServerBootstrapFactory
| *networkInterface* (consumer) | When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group. |  | String
| *noReplyLogLevel* (consumer) | If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverClosedChannelException{zwsp}CaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | DEBUG | LoggingLevel
| *serverExceptionCaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an exception then its logged using this logging level. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverInitializerFactory* (consumer) | To use a custom ServerInitializerFactory |  | ServerInitializerFactory
| *usingExecutorService* (consumer) | Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. | true | boolean
| *connectTimeout* (producer) | Time to wait for a socket connection to be available. Value is in milliseconds. | 10000 | int
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *requestTimeout* (producer) | Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milli seconds, so eg 30000 is 30 seconds. The requestTimeout is using Netty's ReadTimeoutHandler to trigger the timeout. |  | long
| *clientInitializerFactory* (producer) | To use a custom ClientInitializerFactory |  | ClientInitializerFactory
| *correlationManager* (producer) | To use a custom correlation manager to manage how request and reply messages are mapped when using request/reply with the netty producer. This should only be used if you have a way to map requests together with replies such as if there is correlation ids in both the request and reply messages. This can be used if you want to multiplex concurrent messages on the same channel (aka connection) in netty. When doing this you must have a way to correlate the request and reply messages so you can store the right reply on the inflight Camel Exchange before its continued routed. We recommend extending the TimeoutCorrelationManagerSupport when you build custom correlation managers. This provides support for timeout and other complexities you otherwise would need to implement as well. See also the producerPoolEnabled option for more details. |  | NettyCamelStateCorrelationManager
| *lazyChannelCreation* (producer) | Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. | true | boolean
| *producerPoolEnabled* (producer) | Whether producer pool is enabled or not. Important: If you turn this off then a single shared connection is used for the producer, also if you are doing request/reply. That means there is a potential issue with interleaved responses if replies comes back out-of-order. Therefore you need to have a correlation id in both the request and reply messages so you can properly correlate the replies to the Camel callback that is responsible for continue processing the message in Camel. To do this you need to implement NettyCamelStateCorrelationManager as correlation manager and configure it via the correlationManager option. See also the correlationManager option for more details. | true | boolean
| *producerPoolMaxActive* (producer) | Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit. | -1 | int
| *producerPoolMaxIdle* (producer) | Sets the cap on the number of idle instances in the pool. | 100 | int
| *producerPoolMinEvictableIdle* (producer) | Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor. | 300000 | long
| *producerPoolMinIdle* (producer) | Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects. |  | int
| *udpConnectionlessSending* (producer) | This option supports connection less udp sending which is a real fire and forget. A connected udp send receive the PortUnreachableException if no one is listen on the receiving port. | false | boolean
| *useByteBuf* (producer) | If the useByteBuf is true, netty producer will turn the message body into ByteBuf before sending it out. | false | boolean
| *hostnameVerification* ( security) | To enable/disable hostname verification on SSLEngine | false | boolean
| *allowSerializedHeaders* (advanced) | Only used for TCP when transferExchange is true. When set to true, serializable objects in headers and properties will be added to the exchange. Otherwise Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *channelGroup* (advanced) | To use a explicit ChannelGroup. |  | ChannelGroup
| *nativeTransport* (advanced) | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: \\http://netty.io/wiki/native-transports.html | false | boolean
| *options* (advanced) | Allows to configure additional netty options using option. as prefix. For example option.child.keepAlive=false to set the netty option child.keepAlive=false. See the Netty documentation for possible options that can be used. |  | Map
| *receiveBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. | 65536 | int
| *receiveBufferSizePredictor* (advanced) | Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |  | int
| *sendBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. | 65536 | int
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used | false | boolean
| *transferExchange* (advanced) | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *udpByteArrayCodec* (advanced) | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | boolean
| *workerCount* (advanced) | When netty works on nio mode, it uses default workerCount parameter from Netty (which is cpu_core_threads x 2). User can use this option to override the default workerCount from Netty. |  | int
| *workerGroup* (advanced) | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. |  | EventLoopGroup
| *allowDefaultCodec* (codec) | The netty component installs a default codec if both, encoder/decoder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | boolean
| *autoAppendDelimiter* (codec) | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | boolean
| *decoderMaxLineLength* (codec) | The max line length to use for the textline codec. | 1024 | int
| *decoders* (codec) | A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *delimiter* (codec) | The delimiter to use for the textline codec. Possible values are LINE and NULL. There are 2 enums and the value can be one of: LINE, NULL | LINE | TextLineDelimiter
| *encoders* (codec) | A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *encoding* (codec) | The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |  | String
| *textline* (codec) | Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP - however only Strings are allowed to be serialized by default. | false | boolean
| *enabledProtocols* (security) | Which protocols to enable when using SSL | TLSv1,TLSv1.1,TLSv1.2 | String
| *keyStoreFile* (security) | Client side certificate keystore to be used for encryption |  | File
| *keyStoreFormat* (security) | Keystore format to be used for payload encryption. Defaults to JKS if not set |  | String
| *keyStoreResource* (security) | Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *needClientAuth* (security) | Configures whether the server needs client authentication when using SSL. | false | boolean
| *passphrase* (security) | Password setting to use in order to encrypt/decrypt payloads sent using SSH |  | String
| *securityProvider* (security) | Security provider to be used for payload encryption. Defaults to SunX509 if not set. |  | String
| *ssl* (security) | Setting to specify whether SSL encryption is applied to this endpoint | false | boolean
| *sslClientCertHeaders* (security) | When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. | false | boolean
| *sslContextParameters* (security) | To configure security using SSLContextParameters |  | SSLContextParameters
| *sslHandler* (security) | Reference to a class that could be used to return an SSL Handler |  | SslHandler
| *trustStoreFile* (security) | Server side certificate keystore to be used for encryption |  | File
| *trustStoreResource* (security) | Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
|===
// endpoint options: END



== Registry based Options

Codec Handlers and SSL Keystores can be enlisted in the Registry, such as in the Spring XML file.
The values that could be passed in, are the following:

[width=""100%"",cols=""10%,90%"",options=""header"",]
|===
|Name |Description

|`passphrase` |password setting to use in order to encrypt/decrypt payloads sent using
SSH

|`keyStoreFormat` |keystore format to be used for payload encryption. Defaults to ""JKS"" if
not set

|`securityProvider` |Security provider to be used for payload encryption. Defaults to
""SunX509"" if not set.

|`keyStoreFile` |*deprecated:* Client side certificate keystore to be used for encryption

|`trustStoreFile` |*deprecated:* Server side certificate keystore to be used for encryption

|`keyStoreResource` |Client side certificate keystore to be used for
encryption. Is loaded by default from classpath, but you can prefix with
`""classpath:""`, `""file:""`, or `""http:""` to load the resource from
different systems.

|`trustStoreResource` |Server side certificate keystore to be used for
encryption. Is loaded by default from classpath, but you can prefix with
`""classpath:""`, `""file:""`, or `""http:""` to load the resource from
different systems.

|`sslHandler` |Reference to a class that could be used to return an SSL Handler

|`encoder` |A custom `ChannelHandler` class that can be used to perform special
marshalling of outbound payloads. Must override
io.netty.channel.ChannelInboundHandlerAdapter.

|`encoders` |A list of encoders to be used. You can use a String which have values
separated by comma, and have the values be looked up in the
Registry. Just remember to prefix the value with #
so Camel knows it should lookup.

|`decoder` |A custom `ChannelHandler` class that can be used to perform special
marshalling of inbound payloads. Must override
io.netty.channel.ChannelOutboundHandlerAdapter.

|`decoders` |A list of decoders to be used. You can use a String which have values
separated by comma, and have the values be looked up in the
Registry. Just remember to prefix the value with #
so Camel knows it should lookup.
|===

[NOTE]
====
Read below about using non shareable encoders/decoders.
====

=== Using non shareable encoders or decoders

If your encoders or decoders are not shareable (e.g. they don't have the
@Shareable class annotation), then your encoder/decoder must implement
the `org.apache.camel.component.netty.ChannelHandlerFactory` interface,
and return a new instance in the `newChannelHandler` method. This is to
ensure the encoder/decoder can safely be used. If this is not the case,
then the Netty component will log a WARN when an endpoint is created.

The Netty component offers a
`org.apache.camel.component.netty.ChannelHandlerFactories` factory
class, that has a number of commonly used methods.

== Sending Messages to/from a Netty endpoint

=== Netty Producer

In Producer mode, the component provides the ability to send payloads to
a socket endpoint using either TCP or UDP protocols (with optional SSL support).

The producer mode supports both one-way and request-response based operations.

=== Netty Consumer

In Consumer mode, the component provides the ability to:

* listen on a specified socket using either TCP or UDP protocols (with
optional SSL support),
* receive requests on the socket using text/xml, binary and serialized
object based payloads and
* send them along on a route as message exchanges.

The consumer mode supports both one-way and request-response based
operations.

== Examples

=== A UDP Netty endpoint using Request-Reply and serialized object payload

Note that Object serialization is not allowed by default, and so a decoder must be configured.

[source,java]
----
@BindToRegistry(""decoder"")
public ChannelHandler getDecoder() throws Exception {
    return new DefaultChannelHandlerFactory() {
        @Override
        public ChannelHandler newChannelHandler() {
            return new DatagramPacketObjectDecoder(ClassResolvers.weakCachingResolver(null));
        }
    };
}

RouteBuilder builder = new RouteBuilder() {
  public void configure() {
    from(""netty:udp://0.0.0.0:5155?sync=true&decoders=#decoder"")
      .process(new Processor() {
         public void process(Exchange exchange) throws Exception {
           Poetry poetry = (Poetry) exchange.getIn().getBody();
           // Process poetry in some way
           exchange.getOut().setBody(""Message received);
         }
       }
    }
};
----

=== A TCP based Netty consumer endpoint using One-way communication

[source,java]
----
RouteBuilder builder = new RouteBuilder() {
  public void configure() {
       from(""netty:tcp://0.0.0.0:5150"")
           .to(""mock:result"");
  }
};
----

=== An SSL/TCP based Netty consumer endpoint using Request-Reply communication

[[Netty-UsingtheJSSEConfigurationUtility]]
Using the JSSE Configuration Utility

The Netty component supports SSL/TLS configuration
through the xref:manual::camel-configuration-utilities.adoc[Camel JSSE
Configuration Utility].  This utility greatly decreases the amount of
component specific code you need to write and is configurable at the
endpoint and component levels.  The following examples demonstrate how
to use the utility with the Netty component.

[[Netty-Programmaticconfigurationofthecomponent]]
Programmatic configuration of the component

[source,java]
----
KeyStoreParameters ksp = new KeyStoreParameters();
ksp.setResource(""/users/home/server/keystore.jks"");
ksp.setPassword(""keystorePassword"");

KeyManagersParameters kmp = new KeyManagersParameters();
kmp.setKeyStore(ksp);
kmp.setKeyPassword(""keyPassword"");

SSLContextParameters scp = new SSLContextParameters();
scp.setKeyManagers(kmp);

NettyComponent nettyComponent = getContext().getComponent(""netty"", NettyComponent.class);
nettyComponent.setSslContextParameters(scp);
----

[[Netty-SpringDSLbasedconfigurationofendpoint]]
Spring DSL based configuration of endpoint

[source,xml]
----
...
  <camel:sslContextParameters
      id=""sslContextParameters"">
    <camel:keyManagers
        keyPassword=""keyPassword"">
      <camel:keyStore
          resource=""/users/home/server/keystore.jks""
          password=""keystorePassword""/>
    </camel:keyManagers>
  </camel:sslContextParameters>...
...
  <to uri=""netty:tcp://0.0.0.0:5150?sync=true&ssl=true&sslContextParameters=#sslContextParameters""/>
...
----

[[Netty-UsingBasicSSLTLSconfigurationontheJettyComponent]]
Using Basic SSL/TLS configuration on the Jetty Component

[source,java]
----
Registry registry = context.getRegistry();
registry.bind(""password"", ""changeit"");
registry.bind(""ksf"", new File(""src/test/resources/keystore.jks""));
registry.bind(""tsf"", new File(""src/test/resources/keystore.jks""));

context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty:tcp://0.0.0.0:5150?sync=true&ssl=true&passphrase=#password""
         + ""&keyStoreFile=#ksf&trustStoreFile=#tsf"";
      String return_string =
         ""When You Go Home, Tell Them Of Us And Say,""
         + ""For Your Tomorrow, We Gave Our Today."";

      from(netty_ssl_endpoint)
       .process(new Processor() {
          public void process(Exchange exchange) throws Exception {
            exchange.getOut().setBody(return_string);
          }
       }
  }
});
----

[[Netty-GettingaccesstoSSLSessionandtheclientcertificate]]
Getting access to SSLSession and the client certificate

You can get access to the `javax.net.ssl.SSLSession` if you eg need to
get details about the client certificate. When `ssl=true` then the
xref:netty-component.adoc[Netty] component will store the `SSLSession` as a
header on the Camel Message as shown below:

[source,java]
----
SSLSession session = exchange.getIn().getHeader(NettyConstants.NETTY_SSL_SESSION, SSLSession.class);
// get the first certificate which is client certificate
javax.security.cert.X509Certificate cert = session.getPeerCertificateChain()[0];
Principal principal = cert.getSubjectDN();
----

Remember to set `needClientAuth=true` to authenticate the client,
otherwise `SSLSession` cannot access information about the client
certificate, and you may get an exception
`javax.net.ssl.SSLPeerUnverifiedException: peer not authenticated`. You
may also get this exception if the client certificate is expired or not
valid etc.

[TIP]
====
The option `sslClientCertHeaders` can be set to `true` which then
enriches the Camel Message with headers having
details about the client certificate. For example the subject name is
readily available in the header `CamelNettySSLClientCertSubjectName`.
====

=== Using Multiple Codecs

In certain cases it may be necessary to add chains of encoders and
decoders to the netty pipeline. To add multpile codecs to a camel netty
endpoint the 'encoders' and 'decoders' uri parameters should be used.
Like the 'encoder' and 'decoder' parameters they are used to supply
references (lists of ChannelUpstreamHandlers and
ChannelDownstreamHandlers) that should be added to the pipeline. Note
that if encoders is specified then the encoder param will be ignored,
similarly for decoders and the decoder param.

[NOTE]
====
Read further above about using non shareable encoders/decoders.
====

The lists of codecs need to be added to the Camel's registry so they can
be resolved when the endpoint is created.

[source,java]
----
ChannelHandlerFactory lengthDecoder = ChannelHandlerFactories.newLengthFieldBasedFrameDecoder(1048576, 0, 4, 0, 4);

StringDecoder stringDecoder = new StringDecoder();
registry.bind(""length-decoder"", lengthDecoder);
registry.bind(""string-decoder"", stringDecoder);

LengthFieldPrepender lengthEncoder = new LengthFieldPrepender(4);
StringEncoder stringEncoder = new StringEncoder();
registry.bind(""length-encoder"", lengthEncoder);
registry.bind(""string-encoder"", stringEncoder);

List<ChannelHandler> decoders = new ArrayList<ChannelHandler>();
decoders.add(lengthDecoder);
decoders.add(stringDecoder);

List<ChannelHandler> encoders = new ArrayList<ChannelHandler>();
encoders.add(lengthEncoder);
encoders.add(stringEncoder);

registry.bind(""encoders"", encoders);
registry.bind(""decoders"", decoders);
----

Spring's native collections support can be used to specify the codec
lists in an application context

[source,xml]
----
<util:list id=""decoders"" list-class=""java.util.LinkedList"">
        <bean class=""org.apache.camel.component.netty.ChannelHandlerFactories"" factory-method=""newLengthFieldBasedFrameDecoder"">
            <constructor-arg value=""1048576""/>
            <constructor-arg value=""0""/>
            <constructor-arg value=""4""/>
            <constructor-arg value=""0""/>
            <constructor-arg value=""4""/>
        </bean>
        <bean class=""io.netty.handler.codec.string.StringDecoder""/>
    </util:list>

    <util:list id=""encoders"" list-class=""java.util.LinkedList"">
        <bean class=""io.netty.handler.codec.LengthFieldPrepender"">
            <constructor-arg value=""4""/>
        </bean>
        <bean class=""io.netty.handler.codec.string.StringEncoder""/>
    </util:list>

    <bean id=""length-encoder"" class=""io.netty.handler.codec.LengthFieldPrepender"">
        <constructor-arg value=""4""/>
    </bean>
    <bean id=""string-encoder"" class=""io.netty.handler.codec.string.StringEncoder""/>

    <bean id=""length-decoder"" class=""org.apache.camel.component.netty.ChannelHandlerFactories"" factory-method=""newLengthFieldBasedFrameDecoder"">
        <constructor-arg value=""1048576""/>
        <constructor-arg value=""0""/>
        <constructor-arg value=""4""/>
        <constructor-arg value=""0""/>
        <constructor-arg value=""4""/>
    </bean>
    <bean id=""string-decoder"" class=""io.netty.handler.codec.string.StringDecoder""/>
----

The bean names can then be used in netty endpoint definitions either as
a comma separated list or contained in a List e.g.

[source,java]
----
 from(""direct:multiple-codec"").to(""netty:tcp://0.0.0.0:{{port}}?encoders=#encoders&sync=false"");

 from(""netty:tcp://0.0.0.0:{{port}}?decoders=#length-decoder,#string-decoder&sync=false"").to(""mock:multiple-codec"");
----

or via XML.

[source,xml]
----
<camelContext id=""multiple-netty-codecs-context"" xmlns=""http://camel.apache.org/schema/spring"">
    <route>
        <from uri=""direct:multiple-codec""/>
        <to uri=""netty:tcp://0.0.0.0:5150?encoders=#encoders&amp;sync=false""/>
    </route>
    <route>
        <from uri=""netty:tcp://0.0.0.0:5150?decoders=#length-decoder,#string-decoder&amp;sync=false""/>
        <to uri=""mock:multiple-codec""/>
    </route>
</camelContext>
----

== Closing Channel When Complete

When acting as a server you sometimes want to close the channel when,
for example, a client conversion is finished. +
 You can do this by simply setting the endpoint option
`disconnect=true`.

However you can also instruct Camel on a per message basis as follows. +
 To instruct Camel to close the channel, you should add a header with
the key `CamelNettyCloseChannelWhenComplete` set to a boolean `true`
value. +
 For instance, the example below will close the channel after it has
written the bye message back to the client:

[source,java]
----
from(""netty:tcp://0.0.0.0:8080"").process(new Processor() {
    public void process(Exchange exchange) throws Exception {
        String body = exchange.getIn().getBody(String.class);
        exchange.getOut().setBody(""Bye "" + body);
        // some condition which determines if we should close
        if (close) {
            exchange.getOut().setHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, true);
        }
    }
});
----

[[Netty-Addingcustomchannelpipelinefactoriestogaincompletecontroloveracreatedpipeline]]
Adding custom channel pipeline factories to gain complete control over a created pipeline

== Custom pipeline

Custom channel pipelines provide complete control to the user over the
handler/interceptor chain by inserting custom handler(s), encoder(s) &
decoder(s) without having to specify them in the Netty Endpoint URL in a
very simple way.

In order to add a custom pipeline, a custom channel pipeline factory
must be created and registered with the context via the context registry
(Registry, or the camel-spring ApplicationContextRegistry etc).

A custom pipeline factory must be constructed as follows

* A Producer linked channel pipeline factory must extend the abstract
class `ClientPipelineFactory`.
* A Consumer linked channel pipeline factory must extend the abstract
class `ServerInitializerFactory`.
* The classes should override the initChannel() method in order to
insert custom handler(s), encoder(s) and decoder(s). Not overriding the
`initChannel()` method creates a pipeline with no handlers, encoders or
decoders wired to the pipeline.

The example below shows how ServerInitializerFactory factory may be
created

=== Using custom pipeline factory

[source,java]
----
public class SampleServerInitializerFactory extends ServerInitializerFactory {
    private int maxLineSize = 1024;

    protected void initChannel(Channel ch) throws Exception {
        ChannelPipeline channelPipeline = ch.pipeline();

        channelPipeline.addLast(""encoder-SD"", new StringEncoder(CharsetUtil.UTF_8));
        channelPipeline.addLast(""decoder-DELIM"", new DelimiterBasedFrameDecoder(maxLineSize, true, Delimiters.lineDelimiter()));
        channelPipeline.addLast(""decoder-SD"", new StringDecoder(CharsetUtil.UTF_8));
        // here we add the default Camel ServerChannelHandler for the consumer, to allow Camel to route the message etc.
        channelPipeline.addLast(""handler"", new ServerChannelHandler(consumer));
    }
}
----

The custom channel pipeline factory can then be added to the registry
and instantiated/utilized on a camel route in the following way

[source,java]
----
Registry registry = camelContext.getRegistry();
ServerInitializerFactory factory = new TestServerInitializerFactory();
registry.bind(""spf"", factory);
context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty:tcp://0.0.0.0:5150?serverInitializerFactory=#spf""
      String return_string =
         ""When You Go Home, Tell Them Of Us And Say,""
         + ""For Your Tomorrow, We Gave Our Today."";

      from(netty_ssl_endpoint)
       .process(new Processor() {
          public void process(Exchange exchange) throws Exception {
            exchange.getOut().setBody(return_string);
          }
       }
  }
});
----

== Reusing Netty boss and worker thread pools

Netty has two kind of thread pools: boss and worker. By default each
Netty consumer and producer has their private thread pools. If you want
to reuse these thread pools among multiple consumers or producers then
the thread pools must be created and enlisted in the
Registry.

For example using Spring XML we can create a shared worker thread pool
using the `NettyWorkerPoolBuilder` with 2 worker threads as shown below:

[source,xml]
----
<!-- use the worker pool builder to help create the shared thread pool -->
<bean id=""poolBuilder"" class=""org.apache.camel.component.netty.NettyWorkerPoolBuilder"">
  <property name=""workerCount"" value=""2""/>
</bean>

<!-- the shared worker thread pool -->
<bean id=""sharedPool"" class=""org.jboss.netty.channel.socket.nio.WorkerPool""
      factory-bean=""poolBuilder"" factory-method=""build"" destroy-method=""shutdown"">
</bean>
----

[TIP]
====
For boss thread pool there is a
`org.apache.camel.component.netty.NettyServerBossPoolBuilder` builder
for Netty consumers, and a
`org.apache.camel.component.netty.NettyClientBossPoolBuilder` for the
Netty producers.
====

Then in the Camel routes we can refer to this worker pools by
configuring the `workerPool` option in the URI as shown below:

[source,xml]
----
<route>
  <from uri=""netty:tcp://0.0.0.0:5021?textline=true&amp;sync=true&amp;workerPool=#sharedPool&amp;usingExecutorService=false""/>
  <to uri=""log:result""/>
  ...
</route>
----

And if we have another route we can refer to the shared worker pool:

[source,xml]
----
<route>
  <from uri=""netty:tcp://0.0.0.0:5022?textline=true&amp;sync=true&amp;workerPool=#sharedPool&amp;usingExecutorService=false""/>
  <to uri=""log:result""/>
  ...
</route>
----

and so forth.

== Multiplexing concurrent messages over a single connection with request/reply

When using Netty for request/reply messaging via the netty producer then by default each
message is sent via a non-shared connection (pooled). This ensures that replies are
automatic being able to map to the correct request thread for further routing in Camel.
In other words correlation between request/reply messages happens out-of-the-box because
the replies comes back on the same connection that was used for sending the request;
and this connection is not shared with others. When the response comes back, the connection
is returned back to the connection pool, where it can be reused by others.

However if you want to multiplex concurrent request/responses on a single shared connection,
then you need to turn off the connection pooling by setting `producerPoolEnabled=false`.
Now this means there is a potential issue with interleaved responses if replies comes back out-of-order.
Therefore you need to have a correlation id in both the request and reply messages so you can properly
correlate the replies to the Camel callback that is responsible for continue processing the message in Camel.
To do this you need to implement `NettyCamelStateCorrelationManager` as correlation manager and configure
it via the `correlationManager=#myManager` option.

[NOTE]
====
We recommend extending the `TimeoutCorrelationManagerSupport` when you build custom correlation managers.
This provides support for timeout and other complexities you otherwise would need to implement as well.
====

You can find an example with the Apache Camel source code in the examples directory
under the `camel-example-netty-custom-correlation` directory.


include::{page-component-version}@camel-spring-boot::page$netty-starter.adoc[]
",12480,False,2367.08091450998,median
"// Copyright 2014 The Chromium 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 ""extensions/browser/extension_prefs.h""

#include <stddef.h>
#include <stdint.h>

#include <iterator>
#include <utility>

#include ""base/debug/crash_logging.h""
#include ""base/debug/dump_without_crashing.h""
#include ""base/macros.h""
#include ""base/memory/ptr_util.h""
#include ""base/metrics/histogram_macros.h""
#include ""base/strings/string_number_conversions.h""
#include ""base/strings/string_util.h""
#include ""base/trace_event/trace_event.h""
#include ""build/build_config.h""
#include ""components/crx_file/id_util.h""
#include ""components/pref_registry/pref_registry_syncable.h""
#include ""components/prefs/pref_service.h""
#include ""extensions/browser/app_sorting.h""
#include ""extensions/browser/event_router.h""
#include ""extensions/browser/extension_pref_store.h""
#include ""extensions/browser/extension_prefs_factory.h""
#include ""extensions/browser/extension_prefs_observer.h""
#include ""extensions/browser/extension_system.h""
#include ""extensions/browser/install_flag.h""
#include ""extensions/browser/pref_names.h""
#include ""extensions/common/manifest.h""
#include ""extensions/common/permissions/permission_set.h""
#include ""extensions/common/permissions/permissions_info.h""
#include ""extensions/common/url_pattern.h""
#include ""extensions/common/user_script.h""

namespace extensions {

namespace {

// Additional preferences keys, which are not needed by external clients.

// True if this extension is running. Note this preference stops getting updated
// during Chrome shutdown (and won't be updated on a browser crash) and so can
// be used at startup to determine whether the extension was running when Chrome
// was last terminated.
const char kPrefRunning[] = ""running"";

// Whether this extension had windows when it was last running.
const char kIsActive[] = ""is_active"";

// Where an extension was installed from. (see Manifest::Location)
const char kPrefLocation[] = ""location"";

// Enabled, disabled, killed, etc. (see Extension::State)
const char kPrefState[] = ""state"";

// The path to the current version's manifest file.
const char kPrefPath[] = ""path"";

// The dictionary containing the extension's manifest.
const char kPrefManifest[] = ""manifest"";

// The version number.
const char kPrefVersion[] = ""manifest.version"";

// Indicates whether an extension is blacklisted.
const char kPrefBlacklist[] = ""blacklist"";

// If extension is greylisted.
const char kPrefBlacklistState[] = ""blacklist_state"";

// The count of how many times we prompted the user to acknowledge an
// extension.
const char kPrefAcknowledgePromptCount[] = ""ack_prompt_count"";

// Indicates whether the user has acknowledged various types of extensions.
const char kPrefExternalAcknowledged[] = ""ack_external"";
const char kPrefBlacklistAcknowledged[] = ""ack_blacklist"";

// Indicates whether the external extension was installed during the first
// run of this profile.
const char kPrefExternalInstallFirstRun[] = ""external_first_run"";

// A bitmask of all the reasons an extension is disabled.
const char kPrefDisableReasons[] = ""disable_reasons"";

// The key for a serialized Time value indicating the start of the day (from the
// server's perspective) an extension last included a ""ping"" parameter during
// its update check.
const char kLastPingDay[] = ""lastpingday"";

// Similar to kLastPingDay, but for ""active"" instead of ""rollcall"" pings.
const char kLastActivePingDay[] = ""last_active_pingday"";

// A bit we use to keep track of whether we need to do an ""active"" ping.
const char kActiveBit[] = ""active_bit"";

// Path for settings specific to blacklist update.
const char kExtensionsBlacklistUpdate[] = ""extensions.blacklistupdate"";

// Path for the delayed install info dictionary preference. The actual string
// value is a legacy artifact for when delayed installs only pertained to
// updates that were waiting for idle.
const char kDelayedInstallInfo[] = ""idle_install_info"";

// Reason why the extension's install was delayed.
const char kDelayedInstallReason[] = ""delay_install_reason"";

// Path for the suggested page ordinal of a delayed extension install.
const char kPrefSuggestedPageOrdinal[] = ""suggested_page_ordinal"";

// A preference that, if true, will allow this extension to run in incognito
// mode.
const char kPrefIncognitoEnabled[] = ""incognito"";

// A preference to control whether an extension is allowed to inject script in
// pages with file URLs.
const char kPrefAllowFileAccess[] = ""newAllowFileAccess"";
// TODO(jstritar): As part of fixing http://crbug.com/91577, we revoked all
// extension file access by renaming the pref. We should eventually clean up
// the old flag and possibly go back to that name.
// const char kPrefAllowFileAccessOld[] = ""allowFileAccess"";

// A preference specifying if the user dragged the app on the NTP.
const char kPrefUserDraggedApp[] = ""user_dragged_app_ntp"";

// Preferences that hold which permissions the user has granted the extension.
// We explicitly keep track of these so that extensions can contain unknown
// permissions, for backwards compatibility reasons, and we can still prompt
// the user to accept them once recognized. We store the active permission
// permissions because they may differ from those defined in the manifest.
const char kPrefActivePermissions[] = ""active_permissions"";
const char kPrefGrantedPermissions[] = ""granted_permissions"";

// The preference names for PermissionSet values.
const char kPrefAPIs[] = ""api"";
const char kPrefManifestPermissions[] = ""manifest_permissions"";
const char kPrefExplicitHosts[] = ""explicit_host"";
const char kPrefScriptableHosts[] = ""scriptable_host"";

// A preference that indicates when an extension was installed.
const char kPrefInstallTime[] = ""install_time"";

// A preference which saves the creation flags for extensions.
const char kPrefCreationFlags[] = ""creation_flags"";

// A preference that indicates whether the extension was installed from the
// Chrome Web Store.
const char kPrefFromWebStore[] = ""from_webstore"";

// A preference that indicates whether the extension was installed from a
// mock App created from a bookmark.
const char kPrefFromBookmark[] = ""from_bookmark"";

// A preference that indicates whether the extension was installed as a
// default app.
const char kPrefWasInstalledByDefault[] = ""was_installed_by_default"";

// A preference that indicates whether the extension was installed as an
// OEM app.
const char kPrefWasInstalledByOem[] = ""was_installed_by_oem"";

// Key for Geometry Cache preference.
const char kPrefGeometryCache[] = ""geometry_cache"";

// A preference that indicates when an extension is last launched.
const char kPrefLastLaunchTime[] = ""last_launch_time"";

// Am installation parameter bundled with an extension.
const char kPrefInstallParam[] = ""install_parameter"";

// A list of installed ids and a signature.
const char kInstallSignature[] = ""extensions.install_signature"";

// A boolean preference that indicates whether the extension should not be
// synced. Default value is false.
const char kPrefDoNotSync[] = ""do_not_sync"";

const char kCorruptedDisableCount[] = ""extensions.corrupted_disable_count"";

// A boolean preference that indicates whether the extension has local changes
// that need to be synced. Default value is false.
const char kPrefNeedsSync[] = ""needs_sync"";

// Provider of write access to a dictionary storing extension prefs.
class ScopedExtensionPrefUpdate : public DictionaryPrefUpdate {
 public:
  ScopedExtensionPrefUpdate(PrefService* service,
                            const std::string& extension_id) :
    DictionaryPrefUpdate(service, pref_names::kExtensions),
    extension_id_(extension_id) {}

  ~ScopedExtensionPrefUpdate() override {}

  // DictionaryPrefUpdate overrides:
  base::DictionaryValue* Get() override {
    base::DictionaryValue* dict = DictionaryPrefUpdate::Get();
    base::DictionaryValue* extension = NULL;
    if (!dict->GetDictionary(extension_id_, &extension)) {
      // Extension pref does not exist, create it.
      extension = new base::DictionaryValue();
      dict->SetWithoutPathExpansion(extension_id_, extension);
    }
    return extension;
  }

 private:
  const std::string extension_id_;

  DISALLOW_COPY_AND_ASSIGN(ScopedExtensionPrefUpdate);
};

std::string JoinPrefs(const std::string& parent, const char* child) {
  return parent + ""."" + child;
}

// Checks if kPrefBlacklist is set to true in the base::DictionaryValue.
// Return false if the value is false or kPrefBlacklist does not exist.
// This is used to decide if an extension is blacklisted.
bool IsBlacklistBitSet(const base::DictionaryValue* ext) {
  bool bool_value;
  return ext->GetBoolean(kPrefBlacklist, &bool_value) && bool_value;
}

void LoadExtensionControlledPrefs(ExtensionPrefs* prefs,
                                  ExtensionPrefValueMap* value_map,
                                  const std::string& extension_id,
                                  ExtensionPrefsScope scope) {
  std::string scope_string;
  if (!pref_names::ScopeToPrefName(scope, &scope_string))
    return;
  std::string key = extension_id + ""."" + scope_string;

  const base::DictionaryValue* source_dict =
      prefs->pref_service()->GetDictionary(pref_names::kExtensions);
  const base::DictionaryValue* preferences = NULL;
  if (!source_dict->GetDictionary(key, &preferences))
    return;

  for (base::DictionaryValue::Iterator iter(*preferences); !iter.IsAtEnd();
       iter.Advance()) {
    value_map->SetExtensionPref(
        extension_id, iter.key(), scope, iter.value().DeepCopy());
  }
}

}  // namespace

//
// TimeProvider
//

ExtensionPrefs::TimeProvider::TimeProvider() {
}

ExtensionPrefs::TimeProvider::~TimeProvider() {
}

base::Time ExtensionPrefs::TimeProvider::GetCurrentTime() const {
  return base::Time::Now();
}

//
// ScopedUpdate
//
template <typename T, base::Value::Type type_enum_value>
ExtensionPrefs::ScopedUpdate<T, type_enum_value>::ScopedUpdate(
    ExtensionPrefs* prefs,
    const std::string& extension_id,
    const std::string& key)
    : update_(prefs->pref_service(), pref_names::kExtensions),
      extension_id_(extension_id),
      key_(key) {
  DCHECK(crx_file::id_util::IdIsValid(extension_id_));
}

template <typename T, base::Value::Type type_enum_value>
ExtensionPrefs::ScopedUpdate<T, type_enum_value>::~ScopedUpdate() {
}

template <typename T, base::Value::Type type_enum_value>
T* ExtensionPrefs::ScopedUpdate<T, type_enum_value>::Get() {
  base::DictionaryValue* dict = update_.Get();
  base::DictionaryValue* extension = NULL;
  base::Value* key_value = NULL;
  if (!dict->GetDictionary(extension_id_, &extension) ||
      !extension->Get(key_, &key_value)) {
    return NULL;
  }
  return key_value->GetType() == type_enum_value ?
      static_cast<T*>(key_value) :
      NULL;
}

template <typename T, base::Value::Type type_enum_value>
T* ExtensionPrefs::ScopedUpdate<T, type_enum_value>::Create() {
  base::DictionaryValue* dict = update_.Get();
  base::DictionaryValue* extension = NULL;
  base::Value* key_value = NULL;
  T* value_as_t = NULL;
  if (!dict->GetDictionary(extension_id_, &extension)) {
    extension = new base::DictionaryValue;
    dict->SetWithoutPathExpansion(extension_id_, extension);
  }
  if (!extension->Get(key_, &key_value)) {
    value_as_t = new T;
    extension->SetWithoutPathExpansion(key_, value_as_t);
  } else {
    // It would be nice to CHECK that this doesn't happen, but since prefs can
    // get into a mangled state, we can't really do that. Instead, handle it
    // gracefully (by overwriting whatever was previously there).
    // TODO(devlin): It's unclear if there's anything we'll ever be able to do
    // here (corrupted prefs are sometimes a fact of life), but the debug info
    // might be useful. Remove the dumps after we analyze them.
    if (key_value->GetType() != type_enum_value) {
      NOTREACHED();
      base::debug::SetCrashKeyValue(
          ""existing_extension_pref_value_type"",
          base::IntToString(static_cast<int>(key_value->GetType())));
      base::debug::DumpWithoutCrashing();
      value_as_t = new T();
      extension->SetWithoutPathExpansion(key_, value_as_t);
    } else {
      value_as_t = static_cast<T*>(key_value);
    }
  }
  return value_as_t;
}

// Explicit instantiations for Dictionary and List value types.
template class ExtensionPrefs::ScopedUpdate<base::DictionaryValue,
                                            base::Value::TYPE_DICTIONARY>;
template class ExtensionPrefs::ScopedUpdate<base::ListValue,
                                            base::Value::TYPE_LIST>;

//
// ExtensionPrefs
//

// static
ExtensionPrefs* ExtensionPrefs::Create(
    content::BrowserContext* browser_context,
    PrefService* prefs,
    const base::FilePath& root_dir,
    ExtensionPrefValueMap* extension_pref_value_map,
    bool extensions_disabled,
    const std::vector<ExtensionPrefsObserver*>& early_observers) {
  return ExtensionPrefs::Create(browser_context, prefs, root_dir,
                                extension_pref_value_map, extensions_disabled,
                                early_observers,
                                base::WrapUnique(new TimeProvider()));
}

// static
ExtensionPrefs* ExtensionPrefs::Create(
    content::BrowserContext* browser_context,
    PrefService* pref_service,
    const base::FilePath& root_dir,
    ExtensionPrefValueMap* extension_pref_value_map,
    bool extensions_disabled,
    const std::vector<ExtensionPrefsObserver*>& early_observers,
    std::unique_ptr<TimeProvider> time_provider) {
  return new ExtensionPrefs(browser_context, pref_service, root_dir,
                            extension_pref_value_map, std::move(time_provider),
                            extensions_disabled, early_observers);
}

ExtensionPrefs::~ExtensionPrefs() {
}

// static
ExtensionPrefs* ExtensionPrefs::Get(content::BrowserContext* context) {
  return ExtensionPrefsFactory::GetInstance()->GetForBrowserContext(context);
}

static base::FilePath::StringType MakePathRelative(const base::FilePath& parent,
                                             const base::FilePath& child) {
  if (!parent.IsParent(child))
    return child.value();

  base::FilePath::StringType retval = child.value().substr(
      parent.value().length());
  if (base::FilePath::IsSeparator(retval[0]))
    return retval.substr(1);
  else
    return retval;
}

void ExtensionPrefs::MakePathsRelative() {
  const base::DictionaryValue* dict =
      prefs_->GetDictionary(pref_names::kExtensions);
  if (!dict || dict->empty())
    return;

  // Collect all extensions ids with absolute paths in |absolute_keys|.
  std::set<std::string> absolute_keys;
  for (base::DictionaryValue::Iterator i(*dict); !i.IsAtEnd(); i.Advance()) {
    const base::DictionaryValue* extension_dict = NULL;
    if (!i.value().GetAsDictionary(&extension_dict))
      continue;
    int location_value;
    if (extension_dict->GetInteger(kPrefLocation, &location_value) &&
        Manifest::IsUnpackedLocation(
            static_cast<Manifest::Location>(location_value))) {
      // Unpacked extensions can have absolute paths.
      continue;
    }
    base::FilePath::StringType path_string;
    if (!extension_dict->GetString(kPrefPath, &path_string))
      continue;
    base::FilePath path(path_string);
    if (path.IsAbsolute())
      absolute_keys.insert(i.key());
  }
  if (absolute_keys.empty())
    return;

  // Fix these paths.
  DictionaryPrefUpdate update(prefs_, pref_names::kExtensions);
  base::DictionaryValue* update_dict = update.Get();
  for (std::set<std::string>::iterator i = absolute_keys.begin();
       i != absolute_keys.end(); ++i) {
    base::DictionaryValue* extension_dict = NULL;
    if (!update_dict->GetDictionaryWithoutPathExpansion(*i, &extension_dict)) {
      NOTREACHED() << ""Control should never reach here for extension "" << *i;
      continue;
    }
    base::FilePath::StringType path_string;
    extension_dict->GetString(kPrefPath, &path_string);
    base::FilePath path(path_string);
    extension_dict->SetString(kPrefPath,
        MakePathRelative(install_directory_, path));
  }
}

const base::DictionaryValue* ExtensionPrefs::GetExtensionPref(
    const std::string& extension_id) const {
  const base::DictionaryValue* extensions =
      prefs_->GetDictionary(pref_names::kExtensions);
  const base::DictionaryValue* extension_dict = NULL;
  if (!extensions ||
      !extensions->GetDictionary(extension_id, &extension_dict)) {
    return NULL;
  }
  return extension_dict;
}

void ExtensionPrefs::UpdateExtensionPref(const std::string& extension_id,
                                         const std::string& key,
                                         base::Value* data_value) {
  if (!crx_file::id_util::IdIsValid(extension_id)) {
    NOTREACHED() << ""Invalid extension_id "" << extension_id;
    return;
  }
  ScopedExtensionPrefUpdate update(prefs_, extension_id);
  if (data_value)
    update->Set(key, data_value);
  else
    update->Remove(key, NULL);
}

void ExtensionPrefs::DeleteExtensionPrefs(const std::string& extension_id) {
  extension_pref_value_map_->UnregisterExtension(extension_id);
  FOR_EACH_OBSERVER(ExtensionPrefsObserver,
                    observer_list_,
                    OnExtensionPrefsDeleted(extension_id));
  DictionaryPrefUpdate update(prefs_, pref_names::kExtensions);
  base::DictionaryValue* dict = update.Get();
  dict->Remove(extension_id, NULL);
}

bool ExtensionPrefs::ReadPrefAsBoolean(const std::string& extension_id,
                                       const std::string& pref_key,
                                       bool* out_value) const {
  const base::DictionaryValue* ext = GetExtensionPref(extension_id);
  if (!ext || !ext->GetBoolean(pref_key, out_value))
    return false;

  return true;
}

bool ExtensionPrefs::ReadPrefAsInteger(const std::string& extension_id,
                                       const std::string& pref_key,
                                       int* out_value) const {
  const base::DictionaryValue* ext = GetExtensionPref(extension_id);
  if (!ext || !ext->GetInteger(pref_key, out_value))
    return false;

  return true;
}

bool ExtensionPrefs::ReadPrefAsString(const std::string& extension_id,
                                      const std::string& pref_key,
                                      std::string* out_value) const {
  const base::DictionaryValue* ext = GetExtensionPref(extension_id);
  if (!ext || !ext->GetString(pref_key, out_value))
    return false;

  return true;
}

bool ExtensionPrefs::ReadPrefAsList(const std::string& extension_id,
                                    const std::string& pref_key,
                                    const base::ListValue** out_value) const {
  const base::DictionaryValue* ext = GetExtensionPref(extension_id);
  const base::ListValue* out = NULL;
  if (!ext || !ext->GetList(pref_key, &out))
    return false;
  if (out_value)
    *out_value = out;

  return true;
}

bool ExtensionPrefs::ReadPrefAsDictionary(
    const std::string& extension_id,
    const std::string& pref_key,
    const base::DictionaryValue** out_value) const {
  const base::DictionaryValue* ext = GetExtensionPref(extension_id);
  const base::DictionaryValue* out = NULL;
  if (!ext || !ext->GetDictionary(pref_key, &out))
    return false;
  if (out_value)
    *out_value = out;

  return true;
}

bool ExtensionPrefs::HasPrefForExtension(
    const std::string& extension_id) const {
  return GetExtensionPref(extension_id) != NULL;
}

bool ExtensionPrefs::ReadPrefAsURLPatternSet(const std::string& extension_id,
                                             const std::string& pref_key,
                                             URLPatternSet* result,
                                             int valid_schemes) const {
  const base::ListValue* value = NULL;
  if (!ReadPrefAsList(extension_id, pref_key, &value))
    return false;
  const base::DictionaryValue* extension = GetExtensionPref(extension_id);
  if (!extension)
    return false;
  int location;
  if (extension->GetInteger(kPrefLocation, &location) &&
      static_cast<Manifest::Location>(location) == Manifest::COMPONENT) {
    valid_schemes |= URLPattern::SCHEME_CHROMEUI;
  }

  bool allow_file_access = AllowFileAccess(extension_id);
  return result->Populate(*value, valid_schemes, allow_file_access, NULL);
}

void ExtensionPrefs::SetExtensionPrefURLPatternSet(
    const std::string& extension_id,
    const std::string& pref_key,
    const URLPatternSet& new_value) {
  UpdateExtensionPref(extension_id, pref_key, new_value.ToValue().release());
}

bool ExtensionPrefs::ReadPrefAsBooleanAndReturn(
    const std::string& extension_id,
    const std::string& pref_key) const {
  bool out_value = false;
  return ReadPrefAsBoolean(extension_id, pref_key, &out_value) && out_value;
}

std::unique_ptr<const PermissionSet> ExtensionPrefs::ReadPrefAsPermissionSet(
    const std::string& extension_id,
    const std::string& pref_key) const {
  if (!GetExtensionPref(extension_id))
    return nullptr;

  // Retrieve the API permissions. Please refer SetExtensionPrefPermissionSet()
  // for api_values format.
  APIPermissionSet apis;
  const base::ListValue* api_values = NULL;
  std::string api_pref = JoinPrefs(pref_key, kPrefAPIs);
  if (ReadPrefAsList(extension_id, api_pref, &api_values)) {
    APIPermissionSet::ParseFromJSON(api_values,
                                    APIPermissionSet::kAllowInternalPermissions,
                                    &apis, NULL, NULL);
  }

  // Retrieve the Manifest Keys permissions. Please refer to
  // |SetExtensionPrefPermissionSet| for manifest_permissions_values format.
  ManifestPermissionSet manifest_permissions;
  const base::ListValue* manifest_permissions_values = NULL;
  std::string manifest_permission_pref =
      JoinPrefs(pref_key, kPrefManifestPermissions);
  if (ReadPrefAsList(extension_id, manifest_permission_pref,
                     &manifest_permissions_values)) {
    ManifestPermissionSet::ParseFromJSON(
        manifest_permissions_values, &manifest_permissions, NULL, NULL);
  }

  // Retrieve the explicit host permissions.
  URLPatternSet explicit_hosts;
  ReadPrefAsURLPatternSet(
      extension_id, JoinPrefs(pref_key, kPrefExplicitHosts),
      &explicit_hosts, Extension::kValidHostPermissionSchemes);

  // Retrieve the scriptable host permissions.
  URLPatternSet scriptable_hosts;
  ReadPrefAsURLPatternSet(
      extension_id, JoinPrefs(pref_key, kPrefScriptableHosts),
      &scriptable_hosts, UserScript::ValidUserScriptSchemes());

  return base::WrapUnique(new PermissionSet(apis, manifest_permissions,
                                            explicit_hosts, scriptable_hosts));
}

// Set the API or Manifest permissions.
// The format of api_values is:
// [ ""permission_name1"",   // permissions do not support detail.
//   ""permission_name2"",
//   {""permission_name3"": value },
//   // permission supports detail, permission detail will be stored in value.
//   ...
// ]
template<typename T>
static base::ListValue* CreatePermissionList(const T& permissions) {
  base::ListValue* values = new base::ListValue();
  for (typename T::const_iterator i = permissions.begin();
      i != permissions.end(); ++i) {
    std::unique_ptr<base::Value> detail(i->ToValue());
    if (detail) {
      std::unique_ptr<base::DictionaryValue> tmp(new base::DictionaryValue());
      tmp->Set(i->name(), detail.release());
      values->Append(std::move(tmp));
    } else {
      values->AppendString(i->name());
    }
  }
  return values;
}

void ExtensionPrefs::SetExtensionPrefPermissionSet(
    const std::string& extension_id,
    const std::string& pref_key,
    const PermissionSet& new_value) {
  std::string api_pref = JoinPrefs(pref_key, kPrefAPIs);
  base::ListValue* api_values = CreatePermissionList(new_value.apis());
  UpdateExtensionPref(extension_id, api_pref, api_values);

  std::string manifest_permissions_pref =
      JoinPrefs(pref_key, kPrefManifestPermissions);
  base::ListValue* manifest_permissions_values =
      CreatePermissionList(new_value.manifest_permissions());
  UpdateExtensionPref(extension_id,
                      manifest_permissions_pref,
                      manifest_permissions_values);

  // Set the explicit host permissions.
  if (!new_value.explicit_hosts().is_empty()) {
    SetExtensionPrefURLPatternSet(extension_id,
                                  JoinPrefs(pref_key, kPrefExplicitHosts),
                                  new_value.explicit_hosts());
  }

  // Set the scriptable host permissions.
  if (!new_value.scriptable_hosts().is_empty()) {
    SetExtensionPrefURLPatternSet(extension_id,
                                  JoinPrefs(pref_key, kPrefScriptableHosts),
                                  new_value.scriptable_hosts());
  }
}

int ExtensionPrefs::IncrementAcknowledgePromptCount(
    const std::string& extension_id) {
  int count = 0;
  ReadPrefAsInteger(extension_id, kPrefAcknowledgePromptCount, &count);
  ++count;
  UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount,
                      new base::FundamentalValue(count));
  return count;
}

bool ExtensionPrefs::IsExternalExtensionAcknowledged(
    const std::string& extension_id) const {
  return ReadPrefAsBooleanAndReturn(extension_id, kPrefExternalAcknowledged);
}

void ExtensionPrefs::AcknowledgeExternalExtension(
    const std::string& extension_id) {
  DCHECK(crx_file::id_util::IdIsValid(extension_id));
  UpdateExtensionPref(extension_id, kPrefExternalAcknowledged,
                      new base::FundamentalValue(true));
  UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount, NULL);
}

bool ExtensionPrefs::IsBlacklistedExtensionAcknowledged(
    const std::string& extension_id) const {
  return ReadPrefAsBooleanAndReturn(extension_id, kPrefBlacklistAcknowledged);
}

void ExtensionPrefs::AcknowledgeBlacklistedExtension(
    const std::string& extension_id) {
  DCHECK(crx_file::id_util::IdIsValid(extension_id));
  UpdateExtensionPref(extension_id, kPrefBlacklistAcknowledged,
                      new base::FundamentalValue(true));
  UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount, NULL);
}

bool ExtensionPrefs::IsExternalInstallFirstRun(
    const std::string& extension_id) const {
  return ReadPrefAsBooleanAndReturn(extension_id, kPrefExternalInstallFirstRun);
}

void ExtensionPrefs::SetExternalInstallFirstRun(
    const std::string& extension_id) {
  DCHECK(crx_file::id_util::IdIsValid(extension_id));
  UpdateExtensionPref(extension_id, kPrefExternalInstallFirstRun,
                      new base::FundamentalValue(true));
}

bool ExtensionPrefs::SetAlertSystemFirstRun() {
  if (prefs_->GetBoolean(pref_names::kAlertsInitialized)) {
    return true;
  }
  prefs_->SetBoolean(pref_names::kAlertsInitialized, true);
  return false;
}

bool ExtensionPrefs::DidExtensionEscalatePermissions(
    const std::string& extension_id) const {
  return HasDisableReason(extension_id,
                          Extension::DISABLE_PERMISSIONS_INCREASE) ||
         HasDisableReason(extension_id, Extension::DISABLE_REMOTE_INSTALL);
}

int ExtensionPrefs::GetDisableReasons(const std::string& extension_id) const {
  int value = -1;
  if (ReadPrefAsInteger(extension_id, kPrefDisableReasons, &value) &&
      value >= 0) {
    return value;
  }
  return Extension::DISABLE_NONE;
}

bool ExtensionPrefs::HasDisableReason(
    const std::string& extension_id,
    Extension::DisableReason disable_reason) const {
  return (GetDisableReasons(extension_id) & disable_reason) != 0;
}

void ExtensionPrefs::AddDisableReason(const std::string& extension_id,
                                      Extension::DisableReason disable_reason) {
  DCHECK(!DoesExtensionHaveState(extension_id, Extension::ENABLED));
  ModifyDisableReasons(extension_id, disable_reason, DISABLE_REASON_ADD);
}

void ExtensionPrefs::AddDisableReasons(const std::string& extension_id,
                                       int disable_reasons) {
  DCHECK(!DoesExtensionHaveState(extension_id, Extension::ENABLED));
  ModifyDisableReasons(extension_id, disable_reasons, DISABLE_REASON_ADD);
}

void ExtensionPrefs::RemoveDisableReason(
    const std::string& extension_id,
    Extension::DisableReason disable_reason) {
  ModifyDisableReasons(extension_id, disable_reason, DISABLE_REASON_REMOVE);
}

void ExtensionPrefs::ReplaceDisableReasons(const std::string& extension_id,
                                           int disable_reasons) {
  ModifyDisableReasons(extension_id, disable_reasons, DISABLE_REASON_REPLACE);
}

void ExtensionPrefs::ClearDisableReasons(const std::string& extension_id) {
  ModifyDisableReasons(extension_id, Extension::DISABLE_NONE,
                       DISABLE_REASON_CLEAR);
}

void ExtensionPrefs::ModifyDisableReasons(const std::string& extension_id,
                                          int reasons,
                                          DisableReasonChange change) {
  int old_value = GetDisableReasons(extension_id);
  int new_value = old_value;
  switch (change) {
    case DISABLE_REASON_ADD:
      new_value |= reasons;
      break;
    case DISABLE_REASON_REMOVE:
      new_value &= ~reasons;
      break;
    case DISABLE_REASON_REPLACE:
      new_value = reasons;
      break;
    case DISABLE_REASON_CLEAR:
      new_value = Extension::DISABLE_NONE;
      break;
  }

  if (old_value == new_value)  // no change, return.
    return;

  if (new_value == Extension::DISABLE_NONE) {
    UpdateExtensionPref(extension_id, kPrefDisableReasons, NULL);
  } else {
    UpdateExtensionPref(extension_id,
                        kPrefDisableReasons,
                        new base::FundamentalValue(new_value));
  }

  FOR_EACH_OBSERVER(ExtensionPrefsObserver,
                    observer_list_,
                    OnExtensionDisableReasonsChanged(extension_id, new_value));
}

std::set<std::string> ExtensionPrefs::GetBlacklistedExtensions() const {
  std::set<std::string> ids;

  const base::DictionaryValue* extensions =
      prefs_->GetDictionary(pref_names::kExtensions);
  if (!extensions)
    return ids;

  for (base::DictionaryValue::Iterator it(*extensions);
       !it.IsAtEnd(); it.Advance()) {
    if (!it.value().IsType(base::Value::TYPE_DICTIONARY)) {
      NOTREACHED() << ""Invalid pref for extension "" << it.key();
      continue;
    }
    if (IsBlacklistBitSet(
            static_cast<const base::DictionaryValue*>(&it.value()))) {
      ids.insert(it.key());
    }
  }

  return ids;
}

void ExtensionPrefs::SetExtensionBlacklisted(const std::string& extension_id,
                                             bool is_blacklisted) {
  bool currently_blacklisted = IsExtensionBlacklisted(extension_id);
  if (is_blacklisted == currently_blacklisted)
    return;

  // Always make sure the ""acknowledged"" bit is cleared since the blacklist bit
  // is changing.
  UpdateExtensionPref(extension_id, kPrefBlacklistAcknowledged, NULL);

  if (is_blacklisted) {
    UpdateExtensionPref(extension_id,
                        kPrefBlacklist,
                        new base::FundamentalValue(true));
  } else {
    UpdateExtensionPref(extension_id, kPrefBlacklist, NULL);
    const base::DictionaryValue* dict = GetExtensionPref(extension_id);
    if (dict && dict->empty())
      DeleteExtensionPrefs(extension_id);
  }
}

bool ExtensionPrefs::IsExtensionBlacklisted(const std::string& id) const {
  const base::DictionaryValue* ext_prefs = GetExtensionPref(id);
  return ext_prefs && IsBlacklistBitSet(ext_prefs);
}

namespace {

// Serializes a 64bit integer as a string value.
void SaveInt64(base::DictionaryValue* dictionary,
               const char* key,
               const int64_t value) {
  if (!dictionary)
    return;

  std::string string_value = base::Int64ToString(value);
  dictionary->SetString(key, string_value);
}

// Deserializes a 64bit integer stored as a string value.
bool ReadInt64(const base::DictionaryValue* dictionary,
               const char* key,
               int64_t* value) {
  if (!dictionary)
    return false;

  std::string string_value;
  if (!dictionary->GetString(key, &string_value))
    return false;

  return base::StringToInt64(string_value, value);
}

// Serializes |time| as a string value mapped to |key| in |dictionary|.
void SaveTime(base::DictionaryValue* dictionary,
              const char* key,
              const base::Time& time) {
  SaveInt64(dictionary, key, time.ToInternalValue());
}

// The opposite of SaveTime. If |key| is not found, this returns an empty Time
// (is_null() will return true).
base::Time ReadTime(const base::DictionaryValue* dictionary, const char* key) {
  int64_t value;
  if (ReadInt64(dictionary, key, &value))
    return base::Time::FromInternalValue(value);

  return base::Time();
}

}  // namespace

base::Time ExtensionPrefs::LastPingDay(const std::string& extension_id) const {
  DCHECK(crx_file::id_util::IdIsValid(extension_id));
  return ReadTime(GetExtensionPref(extension_id), kLastPingDay);
}

void ExtensionPrefs::SetLastPingDay(const std::string& extension_id,
                                    const base::Time& time) {
  DCHECK(crx_file::id_util::IdIsValid(extension_id));
  ScopedExtensionPrefUpdate update(prefs_, extension_id);
  SaveTime(update.Get(), kLastPingDay, time);
}

base::Time ExtensionPrefs::BlacklistLastPingDay() const {
  return ReadTime(prefs_->GetDictionary(kExtensionsBlacklistUpdate),
                  kLastPingDay);
}

void ExtensionPrefs::SetBlacklistLastPingDay(const base::Time& time) {
  DictionaryPrefUpdate update(prefs_, kExtensionsBlacklistUpdate);
  SaveTime(update.Get(), kLastPingDay, time);
}

base::Time ExtensionPrefs::LastActivePingDay(
    const std::string& extension_id) const {
  DCHECK(crx_file::id_util::IdIsValid(extension_id));
  return ReadTime(GetExtensionPref(extension_id), kLastActivePingDay);
}

void ExtensionPrefs::SetLastActivePingDay(const std::string& extension_id,
                                          const base::Time& time) {
  DCHECK(crx_file::id_util::IdIsValid(extension_id));
  ScopedExtensionPrefUpdate update(prefs_, extension_id);
  SaveTime(update.Get(), kLastActivePingDay, time);
}

bool ExtensionPrefs::GetActiveBit(const std::string& extension_id) const {
  const base::DictionaryValue* dictionary = GetExtensionPref(extension_id);
  bool result = false;
  if (dictionary && dictionary->GetBoolean(kActiveBit, &result))
    return result;
  return false;
}

void ExtensionPrefs::SetActiveBit(const std::string& extension_id,
                                  bool active) {
  UpdateExtensionPref(extension_id, kActiveBit,
                      new base::FundamentalValue(active));
}

std::unique_ptr<const PermissionSet> ExtensionPrefs::GetGrantedPermissions(
    const std::string& extension_id) const {
  CHECK(crx_file::id_util::IdIsValid(extension_id));
  return ReadPrefAsPermissionSet(extension_id, kPrefGrantedPermissions);
}

void ExtensionPrefs::AddGrantedPermissions(const std::string& extension_id,
                                           const PermissionSet& permissions) {
  CHECK(crx_file::id_util::IdIsValid(extension_id));
  std::unique_ptr<const PermissionSet> granted =
      GetGrantedPermissions(extension_id);
  std::unique_ptr<const PermissionSet> union_set;
  if (granted)
    union_set = PermissionSet::CreateUnion(permissions, *granted);
  // The new granted permissions are the union of the already granted
  // permissions and the newly granted permissions.
  SetExtensionPrefPermissionSet(extension_id, kPrefGrantedPermissions,
                                union_set ? *union_set : permissions);
}

void ExtensionPrefs::RemoveGrantedPermissions(
    const std::string& extension_id,
    const PermissionSet& permissions) {
  CHECK(crx_file::id_util::IdIsValid(extension_id));

  // The new granted permissions are the difference of the already granted
  // permissions and the newly ungranted permissions.
  SetExtensionPrefPermissionSet(
      extension_id, kPrefGrantedPermissions,
      *PermissionSet::CreateDifference(*GetGrantedPermissions(extension_id),
                                       permissions));
}

std::unique_ptr<const PermissionSet> ExtensionPrefs::GetActivePermissions(
    const std::string& extension_id) const {
  CHECK(crx_file::id_util::IdIsValid(extension_id));
  return ReadPrefAsPermissionSet(extension_id, kPrefActivePermissions);
}

void ExtensionPrefs::SetActivePermissions(const std::string& extension_id,
                                          const PermissionSet& permissions) {
  SetExtensionPrefPermissionSet(
      extension_id, kPrefActivePermissions, permissions);
}

void ExtensionPrefs::SetExtensionRunning(const std::string& extension_id,
    bool is_running) {
  base::Value* value = new base::FundamentalValue(is_running);
  UpdateExtensionPref(extension_id, kPrefRunning, value);
}

bool ExtensionPrefs::IsExtensionRunning(const std::string& extension_id) const {
  const base::DictionaryValue* extension = GetExtensionPref(extension_id);
  if (!extension)
    return false;
  bool running = false;
  extension->GetBoolean(kPrefRunning, &running);
  return running;
}

void ExtensionPrefs::SetIsActive(const std::string& extension_id,
                                 bool is_active) {
  base::Value* value = new base::FundamentalValue(is_active);
  UpdateExtensionPref(extension_id, kIsActive, value);
}

bool ExtensionPrefs::IsActive(const std::string& extension_id) const {
  const base::DictionaryValue* extension = GetExtensionPref(extension_id);
  if (!extension)
    return false;
  bool is_active = false;
  extension->GetBoolean(kIsActive, &is_active);
  return is_active;
}

bool ExtensionPrefs::IsIncognitoEnabled(const std::string& extension_id) const {
  return ReadPrefAsBooleanAndReturn(extension_id, kPrefIncognitoEnabled);
}

void ExtensionPrefs::SetIsIncognitoEnabled(const std::string& extension_id,
                                           bool enabled) {
  UpdateExtensionPref(extension_id, kPrefIncognitoEnabled,
                      new base::FundamentalValue(enabled));
  extension_pref_value_map_->SetExtensionIncognitoState(extension_id, enabled);
}

bool ExtensionPrefs::AllowFileAccess(const std::string& extension_id) const {
  return ReadPrefAsBooleanAndReturn(extension_id, kPrefAllowFileAccess);
}

void ExtensionPrefs::SetAllowFileAccess(const std::string& extension_id,
                                        bool allow) {
  UpdateExtensionPref(extension_id, kPrefAllowFileAccess,
                      new base::FundamentalValue(allow));
}

bool ExtensionPrefs::HasAllowFileAccessSetting(
    const std::string& extension_id) const {
  const base::DictionaryValue* ext = GetExtensionPref(extension_id);
  return ext && ext->HasKey(kPrefAllowFileAccess);
}

bool ExtensionPrefs::DoesExtensionHaveState(
    const std::string& id, Extension::State check_state) const {
  const base::DictionaryValue* extension = GetExtensionPref(id);
  int state = -1;
  if (!extension || !extension->GetInteger(kPrefState, &state))
    return false;

  if (state < 0 || state >= Extension::NUM_STATES) {
    LOG(ERROR) << ""Bad pref 'state' for extension '"" << id << ""'"";
    return false;
  }

  return state == check_state;
}

bool ExtensionPrefs::IsExternalExtensionUninstalled(
    const std::string& id) const {
  return DoesExtensionHaveState(id, Extension::EXTERNAL_EXTENSION_UNINSTALLED);
}

bool ExtensionPrefs::IsExtensionDisabled(const std::string& id) const {
  return DoesExtensionHaveState(id, Extension::DISABLED);
}

ExtensionIdList ExtensionPrefs::GetToolbarOrder() const {
  ExtensionIdList id_list_out;
  GetUserExtensionPrefIntoContainer(pref_names::kToolbar, &id_list_out);
  return id_list_out;
}

void ExtensionPrefs::SetToolbarOrder(const ExtensionIdList& extension_ids) {
  SetExtensionPrefFromContainer(pref_names::kToolbar, extension_ids);
}

void ExtensionPrefs::OnExtensionInstalled(
    const Extension* extension,
    Extension::State initial_state,
    const syncer::StringOrdinal& page_ordinal,
    int install_flags,
    const std::string& install_parameter) {
  ScopedExtensionPrefUpdate update(prefs_, extension->id());
  base::DictionaryValue* extension_dict = update.Get();
  const base::Time install_time = time_provider_->GetCurrentTime();
  PopulateExtensionInfoPrefs(extension,
                             install_time,
                             initial_state,
                             install_flags,
                             install_parameter,
                             extension_dict);

  FinishExtensionInfoPrefs(extension->id(), install_time,
                           extension->RequiresSortOrdinal(), page_ordinal,
                           extension_dict);
}

void ExtensionPrefs::OnExtensionUninstalled(const std::string& extension_id,
                                            const Manifest::Location& location,
                                            bool external_uninstall) {
  app_sorting()->ClearOrdinals(extension_id);

  // For external extensions, we save a preference reminding ourself not to try
  // and install the extension anymore (except when |external_uninstall| is
  // true, which signifies that the registry key was deleted or the pref file
  // no longer lists the extension).
  if (!external_uninstall && Manifest::IsExternalLocation(location)) {
    UpdateExtensionPref(extension_id, kPrefState,
                        new base::FundamentalValue(
                            Extension::EXTERNAL_EXTENSION_UNINSTALLED));
    extension_pref_value_map_->SetExtensionState(extension_id, false);
    FOR_EACH_OBSERVER(ExtensionPrefsObserver,
                      observer_list_,
                      OnExtensionStateChanged(extension_id, false));
  } else {
    DeleteExtensionPrefs(extension_id);
  }
}

void ExtensionPrefs::SetExtensionEnabled(const std::string& extension_id) {
  UpdateExtensionPref(extension_id, kPrefState,
                      new base::FundamentalValue(Extension::ENABLED));
  extension_pref_value_map_->SetExtensionState(extension_id, true);
  UpdateExtensionPref(extension_id, kPrefDisableReasons, nullptr);
  FOR_EACH_OBSERVER(ExtensionPrefsObserver, observer_list_,
                    OnExtensionStateChanged(extension_id, true));
}

void ExtensionPrefs::SetExtensionDisabled(const std::string& extension_id,
                                          int disable_reasons) {
  if (!IsExternalExtensionUninstalled(extension_id)) {
    UpdateExtensionPref(extension_id, kPrefState,
                        new base::FundamentalValue(Extension::DISABLED));
    extension_pref_value_map_->SetExtensionState(extension_id, false);
  }
  UpdateExtensionPref(extension_id, kPrefDisableReasons,
                      new base::FundamentalValue(disable_reasons));
  FOR_EACH_OBSERVER(ExtensionPrefsObserver, observer_list_,
                    OnExtensionStateChanged(extension_id, false));
}

void ExtensionPrefs::SetExtensionBlacklistState(const std::string& extension_id,
                                                BlacklistState state) {
  SetExtensionBlacklisted(extension_id, state == BLACKLISTED_MALWARE);
  UpdateExtensionPref(extension_id, kPrefBlacklistState,
                      new base::FundamentalValue(state));
}

BlacklistState ExtensionPrefs::GetExtensionBlacklistState(
    const std::string& extension_id) const {
  if (IsExtensionBlacklisted(extension_id))
    return BLACKLISTED_MALWARE;
  const base::DictionaryValue* ext_prefs = GetExtensionPref(extension_id);
  int int_value = 0;
  if (ext_prefs && ext_prefs->GetInteger(kPrefBlacklistState, &int_value))
    return static_cast<BlacklistState>(int_value);

  return NOT_BLACKLISTED;
}

std::string ExtensionPrefs::GetVersionString(
    const std::string& extension_id) const {
  const base::DictionaryValue* extension = GetExtensionPref(extension_id);
  if (!extension)
    return std::string();

  std::string version;
  extension->GetString(kPrefVersion, &version);

  return version;
}

void ExtensionPrefs::UpdateManifest(const Extension* extension) {
  if (!Manifest::IsUnpackedLocation(extension->location())) {
    const base::DictionaryValue* extension_dict =
        GetExtensionPref(extension->id());
    if (!extension_dict)
      return;
    const base::DictionaryValue* old_manifest = NULL;
    bool update_required =
        !extension_dict->GetDictionary(kPrefManifest, &old_manifest) ||
        !extension->manifest()->value()->Equals(old_manifest);
    if (update_required) {
      UpdateExtensionPref(extension->id(), kPrefManifest,
                          extension->manifest()->value()->DeepCopy());
    }
  }
}

std::unique_ptr<ExtensionInfo> ExtensionPrefs::GetInstalledInfoHelper(
    const std::string& extension_id,
    const base::DictionaryValue* extension) const {
  int location_value;
  if (!extension->GetInteger(kPrefLocation, &location_value))
    return std::unique_ptr<ExtensionInfo>();

  Manifest::Location location = static_cast<Manifest::Location>(location_value);
  if (location == Manifest::COMPONENT) {
    // Component extensions are ignored. Component extensions may have data
    // saved in preferences, but they are already loaded at this point (by
    // ComponentLoader) and shouldn't be populated into the result of
    // GetInstalledExtensionsInfo, otherwise InstalledLoader would also want to
    // load them.
    return std::unique_ptr<ExtensionInfo>();
  }

  // Only the following extension types have data saved in the preferences.
  if (location != Manifest::INTERNAL &&
      !Manifest::IsUnpackedLocation(location) &&
      !Manifest::IsExternalLocation(location)) {
    NOTREACHED();
    return std::unique_ptr<ExtensionInfo>();
  }

  const base::DictionaryValue* manifest = NULL;
  if (!Manifest::IsUnpackedLocation(location) &&
      !extension->GetDictionary(kPrefManifest, &manifest)) {
    LOG(WARNING) << ""Missing manifest for extension "" << extension_id;
    // Just a warning for now.
  }

  base::FilePath::StringType path;
  if (!extension->GetString(kPrefPath, &path))
    return std::unique_ptr<ExtensionInfo>();

  // Make path absolute. Most (but not all) extension types have relative paths.
  if (!base::FilePath(path).IsAbsolute())
    path = install_directory_.Append(path).value();

  return std::unique_ptr<ExtensionInfo>(new ExtensionInfo(
      manifest, extension_id, base::FilePath(path), location));
}

std::unique_ptr<ExtensionInfo> ExtensionPrefs::GetInstalledExtensionInfo(
    const std::string& extension_id) const {
  const base::DictionaryValue* ext = NULL;
  const base::DictionaryValue* extensions =
      prefs_->GetDictionary(pref_names::kExtensions);
  if (!extensions ||
      !extensions->GetDictionaryWithoutPathExpansion(extension_id, &ext))
    return std::unique_ptr<ExtensionInfo>();
  int state_value;
  if (ext->GetInteger(kPrefState, &state_value) &&
      state_value == Extension::EXTERNAL_EXTENSION_UNINSTALLED) {
    LOG(WARNING) << ""External extension with id "" << extension_id
                 << "" has been uninstalled by the user"";
    return std::unique_ptr<ExtensionInfo>();
  }

  return GetInstalledInfoHelper(extension_id, ext);
}

std::unique_ptr<ExtensionPrefs::ExtensionsInfo>
ExtensionPrefs::GetInstalledExtensionsInfo() const {
  std::unique_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo);

  const base::DictionaryValue* extensions =
      prefs_->GetDictionary(pref_names::kExtensions);
  for (base::DictionaryValue::Iterator extension_id(*extensions);
       !extension_id.IsAtEnd(); extension_id.Advance()) {
    if (!crx_file::id_util::IdIsValid(extension_id.key()))
      continue;

    std::unique_ptr<ExtensionInfo> info =
        GetInstalledExtensionInfo(extension_id.key());
    if (info)
      extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release()));
  }

  return extensions_info;
}

std::unique_ptr<ExtensionPrefs::ExtensionsInfo>
ExtensionPrefs::GetUninstalledExtensionsInfo() const {
  std::unique_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo);

  const base::DictionaryValue* extensions =
      prefs_->GetDictionary(pref_names::kExtensions);
  for (base::DictionaryValue::Iterator extension_id(*extensions);
       !extension_id.IsAtEnd(); extension_id.Advance()) {
    const base::DictionaryValue* ext = NULL;
    if (!crx_file::id_util::IdIsValid(extension_id.key()) ||
        !IsExternalExtensionUninstalled(extension_id.key()) ||
        !extension_id.value().GetAsDictionary(&ext))
      continue;

    std::unique_ptr<ExtensionInfo> info =
        GetInstalledInfoHelper(extension_id.key(), ext);
    if (info)
      extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release()));
  }

  return extensions_info;
}

void ExtensionPrefs::SetDelayedInstallInfo(
    const Extension* extension,
    Extension::State initial_state,
    int install_flags,
    DelayReason delay_reason,
    const syncer::StringOrdinal& page_ordinal,
    const std::string& install_parameter) {
  base::DictionaryValue* extension_dict = new base::DictionaryValue();
  PopulateExtensionInfoPrefs(extension,
                             time_provider_->GetCurrentTime(),
                             initial_state,
                             install_flags,
                             install_parameter,
                             extension_dict);

  // Add transient data that is needed by FinishDelayedInstallInfo(), but
  // should not be in the final extension prefs. All entries here should have
  // a corresponding Remove() call in FinishDelayedInstallInfo().
  if (extension->RequiresSortOrdinal()) {
    extension_dict->SetString(
        kPrefSuggestedPageOrdinal,
        page_ordinal.IsValid() ? page_ordinal.ToInternalValue()
                               : std::string());
  }
  extension_dict->SetInteger(kDelayedInstallReason,
                             static_cast<int>(delay_reason));

  UpdateExtensionPref(extension->id(), kDelayedInstallInfo, extension_dict);
}

bool ExtensionPrefs::RemoveDelayedInstallInfo(
    const std::string& extension_id) {
  if (!GetExtensionPref(extension_id))
    return false;
  ScopedExtensionPrefUpdate update(prefs_, extension_id);
  bool result = update->Remove(kDelayedInstallInfo, NULL);
  return result;
}

bool ExtensionPrefs::FinishDelayedInstallInfo(
    const std::string& extension_id) {
  CHECK(crx_file::id_util::IdIsValid(extension_id));
  ScopedExtensionPrefUpdate update(prefs_, extension_id);
  base::DictionaryValue* extension_dict = update.Get();
  base::DictionaryValue* pending_install_dict = NULL;
  if (!extension_dict->GetDictionary(kDelayedInstallInfo,
                                     &pending_install_dict)) {
    return false;
  }

  // Retrieve and clear transient values populated by SetDelayedInstallInfo().
  // Also do any other data cleanup that makes sense.
  std::string serialized_ordinal;
  syncer::StringOrdinal suggested_page_ordinal;
  bool needs_sort_ordinal = false;
  if (pending_install_dict->GetString(kPrefSuggestedPageOrdinal,
                                      &serialized_ordinal)) {
    suggested_page_ordinal = syncer::StringOrdinal(serialized_ordinal);
    needs_sort_ordinal = true;
    pending_install_dict->Remove(kPrefSuggestedPageOrdinal, NULL);
  }
  pending_install_dict->Remove(kDelayedInstallReason, NULL);

  const base::Time install_time = time_provider_->GetCurrentTime();
  pending_install_dict->Set(
      kPrefInstallTime,
      new base::StringValue(
          base::Int64ToString(install_time.ToInternalValue())));

  // Commit the delayed install data.
  for (base::DictionaryValue::Iterator it(*pending_install_dict); !it.IsAtEnd();
       it.Advance()) {
    extension_dict->Set(it.key(), it.value().DeepCopy());
  }
  FinishExtensionInfoPrefs(extension_id, install_time, needs_sort_ordinal,
                           suggested_page_ordinal, extension_dict);
  return true;
}

std::unique_ptr<ExtensionInfo> ExtensionPrefs::GetDelayedInstallInfo(
    const std::string& extension_id) const {
  const base::DictionaryValue* extension_prefs =
      GetExtensionPref(extension_id);
  if (!extension_prefs)
    return std::unique_ptr<ExtensionInfo>();

  const base::DictionaryValue* ext = NULL;
  if (!extension_prefs->GetDictionary(kDelayedInstallInfo, &ext))
    return std::unique_ptr<ExtensionInfo>();

  return GetInstalledInfoHelper(extension_id, ext);
}

ExtensionPrefs::DelayReason ExtensionPrefs::GetDelayedInstallReason(
    const std::string& extension_id) const {
  const base::DictionaryValue* extension_prefs =
      GetExtensionPref(extension_id);
  if (!extension_prefs)
    return DELAY_REASON_NONE;

  const base::DictionaryValue* ext = NULL;
  if (!extension_prefs->GetDictionary(kDelayedInstallInfo, &ext))
    return DELAY_REASON_NONE;

  int delay_reason;
  if (!ext->GetInteger(kDelayedInstallReason, &delay_reason))
    return DELAY_REASON_NONE;

  return static_cast<DelayReason>(delay_reason);
}

std::unique_ptr<ExtensionPrefs::ExtensionsInfo>
ExtensionPrefs::GetAllDelayedInstallInfo() const {
  std::unique_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo);

  const base::DictionaryValue* extensions =
      prefs_->GetDictionary(pref_names::kExtensions);
  for (base::DictionaryValue::Iterator extension_id(*extensions);
       !extension_id.IsAtEnd(); extension_id.Advance()) {
    if (!crx_file::id_util::IdIsValid(extension_id.key()))
      continue;

    std::unique_ptr<ExtensionInfo> info =
        GetDelayedInstallInfo(extension_id.key());
    if (info)
      extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release()));
  }

  return extensions_info;
}

bool ExtensionPrefs::WasAppDraggedByUser(
    const std::string& extension_id) const {
  return ReadPrefAsBooleanAndReturn(extension_id, kPrefUserDraggedApp);
}

void ExtensionPrefs::SetAppDraggedByUser(const std::string& extension_id) {
  UpdateExtensionPref(extension_id, kPrefUserDraggedApp,
                      new base::FundamentalValue(true));
}

bool ExtensionPrefs::IsFromWebStore(
    const std::string& extension_id) const {
  const base::DictionaryValue* dictionary = GetExtensionPref(extension_id);
  bool result = false;
  if (dictionary && dictionary->GetBoolean(kPrefFromWebStore, &result))
    return result;
  return false;
}

bool ExtensionPrefs::IsFromBookmark(
    const std::string& extension_id) const {
  const base::DictionaryValue* dictionary = GetExtensionPref(extension_id);
  bool result = false;
  if (dictionary && dictionary->GetBoolean(kPrefFromBookmark, &result))
    return result;
  return false;
}

int ExtensionPrefs::GetCreationFlags(const std::string& extension_id) const {
  int creation_flags = Extension::NO_FLAGS;
  if (!ReadPrefAsInteger(extension_id, kPrefCreationFlags, &creation_flags)) {
    // Since kPrefCreationFlags was added later, it will be missing for
    // previously installed extensions.
    if (IsFromBookmark(extension_id))
      creation_flags |= Extension::FROM_BOOKMARK;
    if (IsFromWebStore(extension_id))
      creation_flags |= Extension::FROM_WEBSTORE;
    if (WasInstalledByDefault(extension_id))
      creation_flags |= Extension::WAS_INSTALLED_BY_DEFAULT;
    if (WasInstalledByOem(extension_id))
      creation_flags |= Extension::WAS_INSTALLED_BY_OEM;
  }
  return creation_flags;
}

int ExtensionPrefs::GetDelayedInstallCreationFlags(
    const std::string& extension_id) const {
  int creation_flags = Extension::NO_FLAGS;
  const base::DictionaryValue* delayed_info = NULL;
  if (ReadPrefAsDictionary(extension_id, kDelayedInstallInfo, &delayed_info)) {
    delayed_info->GetInteger(kPrefCreationFlags, &creation_flags);
  }
  return creation_flags;
}

bool ExtensionPrefs::WasInstalledByDefault(
    const std::string& extension_id) const {
  const base::DictionaryValue* dictionary = GetExtensionPref(extension_id);
  bool result = false;
  if (dictionary &&
      dictionary->GetBoolean(kPrefWasInstalledByDefault, &result))
    return result;
  return false;
}

bool ExtensionPrefs::WasInstalledByOem(const std::string& extension_id) const {
  const base::DictionaryValue* dictionary = GetExtensionPref(extension_id);
  bool result = false;
  if (dictionary && dictionary->GetBoolean(kPrefWasInstalledByOem, &result))
    return result;
  return false;
}

base::Time ExtensionPrefs::GetInstallTime(
    const std::string& extension_id) const {
  const base::DictionaryValue* extension = GetExtensionPref(extension_id);
  if (!extension) {
    NOTREACHED();
    return base::Time();
  }
  std::string install_time_str;
  if (!extension->GetString(kPrefInstallTime, &install_time_str))
    return base::Time();
  int64_t install_time_i64 = 0;
  if (!base::StringToInt64(install_time_str, &install_time_i64))
    return base::Time();
  return base::Time::FromInternalValue(install_time_i64);
}

bool ExtensionPrefs::DoNotSync(const std::string& extension_id) const {
  bool do_not_sync;
  if (!ReadPrefAsBoolean(extension_id, kPrefDoNotSync, &do_not_sync))
    return false;

  return do_not_sync;
}

base::Time ExtensionPrefs::GetLastLaunchTime(
    const std::string& extension_id) const {
  const base::DictionaryValue* extension = GetExtensionPref(extension_id);
  if (!extension)
    return base::Time();

  std::string launch_time_str;
  if (!extension->GetString(kPrefLastLaunchTime, &launch_time_str))
    return base::Time();
  int64_t launch_time_i64 = 0;
  if (!base::StringToInt64(launch_time_str, &launch_time_i64))
    return base::Time();
  return base::Time::FromInternalValue(launch_time_i64);
}

void ExtensionPrefs::SetLastLaunchTime(const std::string& extension_id,
                                       const base::Time& time) {
  DCHECK(crx_file::id_util::IdIsValid(extension_id));
  ScopedExtensionPrefUpdate update(prefs_, extension_id);
  SaveTime(update.Get(), kPrefLastLaunchTime, time);
}

void ExtensionPrefs::ClearLastLaunchTimes() {
  const base::DictionaryValue* dict =
      prefs_->GetDictionary(pref_names::kExtensions);
  if (!dict || dict->empty())
    return;

  // Collect all the keys to remove the last launched preference from.
  DictionaryPrefUpdate update(prefs_, pref_names::kExtensions);
  base::DictionaryValue* update_dict = update.Get();
  for (base::DictionaryValue::Iterator i(*update_dict); !i.IsAtEnd();
       i.Advance()) {
    base::DictionaryValue* extension_dict = NULL;
    if (!update_dict->GetDictionary(i.key(), &extension_dict))
      continue;

    if (extension_dict->HasKey(kPrefLastLaunchTime))
      extension_dict->Remove(kPrefLastLaunchTime, NULL);
  }
}

void ExtensionPrefs::GetExtensions(ExtensionIdList* out) const {
  CHECK(out);

  std::unique_ptr<ExtensionsInfo> extensions_info(GetInstalledExtensionsInfo());

  for (size_t i = 0; i < extensions_info->size(); ++i) {
    ExtensionInfo* info = extensions_info->at(i).get();
    out->push_back(info->extension_id);
  }
}

// static
ExtensionIdList ExtensionPrefs::GetExtensionsFrom(
    const PrefService* pref_service) {
  ExtensionIdList result;

  const base::DictionaryValue* extension_prefs = NULL;
  const base::Value* extension_prefs_value =
      pref_service->GetUserPrefValue(pref_names::kExtensions);
  if (!extension_prefs_value ||
      !extension_prefs_value->GetAsDictionary(&extension_prefs)) {
    return result;  // Empty set
  }

  for (base::DictionaryValue::Iterator it(*extension_prefs); !it.IsAtEnd();
       it.Advance()) {
    const base::DictionaryValue* ext = NULL;
    if (!it.value().GetAsDictionary(&ext)) {
      NOTREACHED() << ""Invalid pref for extension "" << it.key();
      continue;
    }
    if (!IsBlacklistBitSet(ext))
      result.push_back(it.key());
  }
  return result;
}

void ExtensionPrefs::AddObserver(ExtensionPrefsObserver* observer) {
  observer_list_.AddObserver(observer);
}

void ExtensionPrefs::RemoveObserver(ExtensionPrefsObserver* observer) {
  observer_list_.RemoveObserver(observer);
}

void ExtensionPrefs::InitPrefStore() {
  TRACE_EVENT0(""browser,startup"", ""ExtensionPrefs::InitPrefStore"")
  SCOPED_UMA_HISTOGRAM_TIMER(""Extensions.InitPrefStoreTime"");

  if (extensions_disabled_) {
    extension_pref_value_map_->NotifyInitializationCompleted();
    return;
  }

  // When this is called, the PrefService is initialized and provides access
  // to the user preferences stored in a JSON file.
  ExtensionIdList extension_ids;
  {
    SCOPED_UMA_HISTOGRAM_TIMER(""Extensions.InitPrefGetExtensionsTime"");
    GetExtensions(&extension_ids);
  }
  // Create empty preferences dictionary for each extension (these dictionaries
  // are pruned when persisting the preferences to disk).
  for (ExtensionIdList::iterator ext_id = extension_ids.begin();
       ext_id != extension_ids.end(); ++ext_id) {
    ScopedExtensionPrefUpdate update(prefs_, *ext_id);
    // This creates an empty dictionary if none is stored.
    update.Get();
  }

  InitExtensionControlledPrefs(extension_pref_value_map_);

  extension_pref_value_map_->NotifyInitializationCompleted();
}

bool ExtensionPrefs::HasIncognitoPrefValue(const std::string& pref_key) const {
  bool has_incognito_pref_value = false;
  extension_pref_value_map_->GetEffectivePrefValue(pref_key,
                                                   true,
                                                   &has_incognito_pref_value);
  return has_incognito_pref_value;
}

const base::DictionaryValue* ExtensionPrefs::GetGeometryCache(
    const std::string& extension_id) const {
  const base::DictionaryValue* extension_prefs = GetExtensionPref(extension_id);
  if (!extension_prefs)
    return NULL;

  const base::DictionaryValue* ext = NULL;
  if (!extension_prefs->GetDictionary(kPrefGeometryCache, &ext))
    return NULL;

  return ext;
}

void ExtensionPrefs::SetGeometryCache(
    const std::string& extension_id,
    std::unique_ptr<base::DictionaryValue> cache) {
  UpdateExtensionPref(extension_id, kPrefGeometryCache, cache.release());
}

const base::DictionaryValue* ExtensionPrefs::GetInstallSignature() const {
  return prefs_->GetDictionary(kInstallSignature);
}

void ExtensionPrefs::SetInstallSignature(
    const base::DictionaryValue* signature) {
  if (signature) {
    prefs_->Set(kInstallSignature, *signature);
    DVLOG(1) << ""SetInstallSignature - saving"";
  } else {
    DVLOG(1) << ""SetInstallSignature - clearing"";
    prefs_->ClearPref(kInstallSignature);
  }
}

std::string ExtensionPrefs::GetInstallParam(
    const std::string& extension_id) const {
  const base::DictionaryValue* extension = GetExtensionPref(extension_id);
  if (!extension)  // Expected during unit testing.
    return std::string();
  std::string install_parameter;
  if (!extension->GetString(kPrefInstallParam, &install_parameter))
    return std::string();
  return install_parameter;
}

void ExtensionPrefs::SetInstallParam(const std::string& extension_id,
                                     const std::string& install_parameter) {
  UpdateExtensionPref(extension_id,
                      kPrefInstallParam,
                      new base::StringValue(install_parameter));
}

int ExtensionPrefs::GetCorruptedDisableCount() const {
  return prefs_->GetInteger(kCorruptedDisableCount);
}

void ExtensionPrefs::IncrementCorruptedDisableCount() {
  int count = prefs_->GetInteger(kCorruptedDisableCount);
  prefs_->SetInteger(kCorruptedDisableCount, count + 1);
}

bool ExtensionPrefs::NeedsSync(const std::string& extension_id) const {
  return ReadPrefAsBooleanAndReturn(extension_id, kPrefNeedsSync);
}

void ExtensionPrefs::SetNeedsSync(const std::string& extension_id,
                                  bool needs_sync) {
  UpdateExtensionPref(extension_id, kPrefNeedsSync,
                      needs_sync ? new base::FundamentalValue(true) : nullptr);
}

ExtensionPrefs::ExtensionPrefs(
    content::BrowserContext* browser_context,
    PrefService* prefs,
    const base::FilePath& root_dir,
    ExtensionPrefValueMap* extension_pref_value_map,
    std::unique_ptr<TimeProvider> time_provider,
    bool extensions_disabled,
    const std::vector<ExtensionPrefsObserver*>& early_observers)
    : browser_context_(browser_context),
      prefs_(prefs),
      install_directory_(root_dir),
      extension_pref_value_map_(extension_pref_value_map),
      time_provider_(std::move(time_provider)),
      extensions_disabled_(extensions_disabled) {
  MakePathsRelative();

  // Ensure that any early observers are watching before prefs are initialized.
  for (std::vector<ExtensionPrefsObserver*>::const_iterator iter =
           early_observers.begin();
       iter != early_observers.end();
       ++iter) {
    AddObserver(*iter);
  }

  InitPrefStore();
}

AppSorting* ExtensionPrefs::app_sorting() const {
  return ExtensionSystem::Get(browser_context_)->app_sorting();
}

void ExtensionPrefs::SetNeedsStorageGarbageCollection(bool value) {
  prefs_->SetBoolean(pref_names::kStorageGarbageCollect, value);
}

bool ExtensionPrefs::NeedsStorageGarbageCollection() const {
  return prefs_->GetBoolean(pref_names::kStorageGarbageCollect);
}

// static
void ExtensionPrefs::RegisterProfilePrefs(
    user_prefs::PrefRegistrySyncable* registry) {
  registry->RegisterDictionaryPref(pref_names::kExtensions);
  registry->RegisterListPref(pref_names::kToolbar,
                             user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
  registry->RegisterIntegerPref(pref_names::kToolbarSize, -1);
  registry->RegisterDictionaryPref(kExtensionsBlacklistUpdate);
  registry->RegisterListPref(pref_names::kInstallAllowList);
  registry->RegisterListPref(pref_names::kInstallDenyList);
  registry->RegisterDictionaryPref(pref_names::kInstallForceList);
  registry->RegisterListPref(pref_names::kAllowedTypes);
  registry->RegisterBooleanPref(pref_names::kStorageGarbageCollect, false);
  registry->RegisterInt64Pref(pref_names::kLastUpdateCheck, 0);
  registry->RegisterInt64Pref(pref_names::kNextUpdateCheck, 0);
  registry->RegisterListPref(pref_names::kAllowedInstallSites);
  registry->RegisterStringPref(pref_names::kLastChromeVersion, std::string());
  registry->RegisterDictionaryPref(kInstallSignature);

  registry->RegisterListPref(pref_names::kNativeMessagingBlacklist);
  registry->RegisterListPref(pref_names::kNativeMessagingWhitelist);
  registry->RegisterBooleanPref(pref_names::kNativeMessagingUserLevelHosts,
                                true);
  registry->RegisterIntegerPref(kCorruptedDisableCount, 0);

#if !defined(OS_MACOSX)
  registry->RegisterBooleanPref(pref_names::kAppFullscreenAllowed, true);
#endif
}

template <class ExtensionIdContainer>
bool ExtensionPrefs::GetUserExtensionPrefIntoContainer(
    const char* pref,
    ExtensionIdContainer* id_container_out) const {
  DCHECK(id_container_out->empty());

  const base::Value* user_pref_value = prefs_->GetUserPrefValue(pref);
  const base::ListValue* user_pref_as_list;
  if (!user_pref_value || !user_pref_value->GetAsList(&user_pref_as_list))
    return false;

  std::insert_iterator<ExtensionIdContainer> insert_iterator(
      *id_container_out, id_container_out->end());
  std::string extension_id;
  for (base::ListValue::const_iterator value_it = user_pref_as_list->begin();
       value_it != user_pref_as_list->end(); ++value_it) {
    if (!(*value_it)->GetAsString(&extension_id)) {
      NOTREACHED();
      continue;
    }
    insert_iterator = extension_id;
  }
  return true;
}

template <class ExtensionIdContainer>
void ExtensionPrefs::SetExtensionPrefFromContainer(
    const char* pref,
    const ExtensionIdContainer& strings) {
  ListPrefUpdate update(prefs_, pref);
  base::ListValue* list_of_values = update.Get();
  list_of_values->Clear();
  for (typename ExtensionIdContainer::const_iterator iter = strings.begin();
       iter != strings.end(); ++iter) {
    list_of_values->AppendString(*iter);
  }
}

void ExtensionPrefs::PopulateExtensionInfoPrefs(
    const Extension* extension,
    const base::Time install_time,
    Extension::State initial_state,
    int install_flags,
    const std::string& install_parameter,
    base::DictionaryValue* extension_dict) const {
  extension_dict->Set(kPrefState, new base::FundamentalValue(initial_state));
  extension_dict->Set(kPrefLocation,
                      new base::FundamentalValue(extension->location()));
  extension_dict->Set(kPrefCreationFlags,
                      new base::FundamentalValue(extension->creation_flags()));
  extension_dict->Set(kPrefFromWebStore,
                      new base::FundamentalValue(extension->from_webstore()));
  extension_dict->Set(kPrefFromBookmark,
                      new base::FundamentalValue(extension->from_bookmark()));
  extension_dict->Set(
      kPrefWasInstalledByDefault,
      new base::FundamentalValue(extension->was_installed_by_default()));
  extension_dict->Set(
      kPrefWasInstalledByOem,
      new base::FundamentalValue(extension->was_installed_by_oem()));
  extension_dict->Set(kPrefInstallTime,
                      new base::StringValue(
                          base::Int64ToString(install_time.ToInternalValue())));
  if (install_flags & kInstallFlagIsBlacklistedForMalware)
    extension_dict->Set(kPrefBlacklist, new base::FundamentalValue(true));

  base::FilePath::StringType path = MakePathRelative(install_directory_,
                                                     extension->path());
  extension_dict->Set(kPrefPath, new base::StringValue(path));
  if (!install_parameter.empty()) {
    extension_dict->Set(kPrefInstallParam,
                        new base::StringValue(install_parameter));
  }
  // We store prefs about LOAD extensions, but don't cache their manifest
  // since it may change on disk.
  if (!Manifest::IsUnpackedLocation(extension->location())) {
    extension_dict->Set(kPrefManifest,
                        extension->manifest()->value()->DeepCopy());
  }

  // Only writes kPrefDoNotSync when it is not the default.
  if (install_flags & kInstallFlagDoNotSync)
    extension_dict->Set(kPrefDoNotSync, new base::FundamentalValue(true));
  else
    extension_dict->Remove(kPrefDoNotSync, NULL);
}

void ExtensionPrefs::InitExtensionControlledPrefs(
    ExtensionPrefValueMap* value_map) {
  TRACE_EVENT0(""browser,startup"",
               ""ExtensionPrefs::InitExtensionControlledPrefs"")
  SCOPED_UMA_HISTOGRAM_TIMER(""Extensions.InitExtensionControlledPrefsTime"");

  ExtensionIdList extension_ids;
  GetExtensions(&extension_ids);

  for (ExtensionIdList::iterator extension_id = extension_ids.begin();
       extension_id != extension_ids.end();
       ++extension_id) {
    base::Time install_time = GetInstallTime(*extension_id);
    bool is_enabled = !IsExtensionDisabled(*extension_id);
    bool is_incognito_enabled = IsIncognitoEnabled(*extension_id);
    value_map->RegisterExtension(
        *extension_id, install_time, is_enabled, is_incognito_enabled);

    FOR_EACH_OBSERVER(
        ExtensionPrefsObserver,
        observer_list_,
        OnExtensionRegistered(*extension_id, install_time, is_enabled));

    // Set regular extension controlled prefs.
    LoadExtensionControlledPrefs(
        this, value_map, *extension_id, kExtensionPrefsScopeRegular);
    // Set incognito extension controlled prefs.
    LoadExtensionControlledPrefs(this,
                                 value_map,
                                 *extension_id,
                                 kExtensionPrefsScopeIncognitoPersistent);
    // Set regular-only extension controlled prefs.
    LoadExtensionControlledPrefs(
        this, value_map, *extension_id, kExtensionPrefsScopeRegularOnly);

    FOR_EACH_OBSERVER(ExtensionPrefsObserver,
                      observer_list_,
                      OnExtensionPrefsLoaded(*extension_id, this));
  }
}

void ExtensionPrefs::FinishExtensionInfoPrefs(
    const std::string& extension_id,
    const base::Time install_time,
    bool needs_sort_ordinal,
    const syncer::StringOrdinal& suggested_page_ordinal,
    base::DictionaryValue* extension_dict) {
  // Reinitializes various preferences with empty dictionaries.
  if (!extension_dict->HasKey(pref_names::kPrefPreferences)) {
    extension_dict->Set(pref_names::kPrefPreferences,
                        new base::DictionaryValue);
  }

  if (!extension_dict->HasKey(pref_names::kPrefIncognitoPreferences)) {
    extension_dict->Set(pref_names::kPrefIncognitoPreferences,
                        new base::DictionaryValue);
  }

  if (!extension_dict->HasKey(pref_names::kPrefRegularOnlyPreferences)) {
    extension_dict->Set(pref_names::kPrefRegularOnlyPreferences,
                        new base::DictionaryValue);
  }

  if (!extension_dict->HasKey(pref_names::kPrefContentSettings))
    extension_dict->Set(pref_names::kPrefContentSettings, new base::ListValue);

  if (!extension_dict->HasKey(pref_names::kPrefIncognitoContentSettings)) {
    extension_dict->Set(pref_names::kPrefIncognitoContentSettings,
                        new base::ListValue);
  }

  // If this point has been reached, any pending installs should be considered
  // out of date.
  extension_dict->Remove(kDelayedInstallInfo, NULL);

  // Clear state that may be registered from a previous install.
  extension_dict->Remove(EventRouter::kRegisteredEvents, NULL);

  // FYI, all code below here races on sudden shutdown because |extension_dict|,
  // |app_sorting|, |extension_pref_value_map_|, and (potentially) observers
  // are updated non-transactionally. This is probably not fixable without
  // nested transactional updates to pref dictionaries.
  if (needs_sort_ordinal)
    app_sorting()->EnsureValidOrdinals(extension_id, suggested_page_ordinal);

  bool is_enabled = false;
  int initial_state;
  if (extension_dict->GetInteger(kPrefState, &initial_state)) {
    is_enabled = initial_state == Extension::ENABLED;
  }
  bool is_incognito_enabled = IsIncognitoEnabled(extension_id);

  extension_pref_value_map_->RegisterExtension(
      extension_id, install_time, is_enabled, is_incognito_enabled);

  FOR_EACH_OBSERVER(
      ExtensionPrefsObserver,
      observer_list_,
      OnExtensionRegistered(extension_id, install_time, is_enabled));
}

}  // namespace extensions
",16195,True,3348.05161803113,median
"////
This guide is maintained in the main Quarkus repository
and pull requests should be submitted there:
https://github.com/quarkusio/quarkus/tree/main/docs/src/main/asciidoc
////
= Building applications with Maven

include::./attributes.adoc[]
:devtools-no-gradle:

[[project-creation]]
== Creating a new project

You can scaffold a new Maven project with:

:create-app-group-id: my-groupId
:create-app-artifact-id: my-artifactId
:create-app-code:
:create-app-post-command:
include::includes/devtools/create-app.adoc[]

If you are using the CLI, you can get the list of available options with:

[source,bash]
----
quarkus create app --help
----

If you are using the Maven command, the following table lists the attributes you can pass to the `create` command:

[cols=3*,options=""header""]
|===
| Attribute
| Default Value
| Description

| `projectGroupId`
| `org.acme.sample`
| The group id of the created project

| `projectArtifactId`
| _mandatory_
| The artifact id of the created project. Not passing it triggers the interactive mode.

| `projectVersion`
| `1.0.0-SNAPSHOT`
| The version of the created project

| `platformGroupId`
| `io.quarkus.platform`
| The group id of the target platform.

| `platformArtifactId`
| `quarkus-bom`
| The artifact id of the target platform BOM.

| `platformVersion`
| The version currently recommended by the https://quarkus.io/guides/extension-registry-user[Quarkus Extension Registry]
| The version of the platform you want the project to use. It can also accept a version range, in which case the latest from the specified range will be used.

| `className`
| _Not created if omitted_
| The fully qualified name of the generated resource

| `path`
| `/hello`
| The resource path, only relevant if `className` is set.

| `extensions`
| _[]_
| The list of extensions to add to the project (comma-separated)

| `quarkusRegistryClient`
| `true`
| Whether or not Quarkus should use the online registry to resolve extension catalogs. If this is set to false, the extension catalog will be narrowed to the defined (or default) platform BOM.

|===

By default, the command will target the `io.quarkus.platform:quarkus-bom:{quarkus-version}` platform release (unless the coordinates of the desired platform release have been specified).

The project is generated in a directory named after the passed artifactId.
If the directory already exists, the generation fails.

A pair of Dockerfiles for native and jvm mode are also generated in `src/main/docker`.
Instructions to build the image and run the container are written in those Dockerfiles.

== Dealing with extensions

From inside a Quarkus project, you can obtain a list of the available extensions with:

include::includes/devtools/extension-list.adoc[]

You can add an extension using:

:add-extension-extensions: hibernate-validator
include::includes/devtools/extension-add.adoc[]

Extensions are passed using a comma-separated list.

The extension name is the GAV name of the extension: e.g. `io.quarkus:quarkus-agroal`.
But you can pass a partial name and Quarkus will do its best to find the right extension.
For example, `agroal`, `Agroal` or `agro`  will expand to `io.quarkus:quarkus-agroal`.
If no extension is found or if more than one extensions match, you will see a red check mark  ❌ in the command result.

[source,shell]
----
$ ./mvnw quarkus:add-extensions -Dextensions=jdbc,agroal,non-exist-ent
[...]
❌ Multiple extensions matching 'jdbc'
     * io.quarkus:quarkus-jdbc-h2
     * io.quarkus:quarkus-jdbc-mariadb
     * io.quarkus:quarkus-jdbc-postgresql
     Be more specific e.g using the exact name or the full gav.
✅ Adding extension io.quarkus:quarkus-agroal
❌ Cannot find a dependency matching 'non-exist-ent', maybe a typo?
[...]
----

You can install all extensions which match a globbing pattern :

:add-extension-extensions: smallrye-*
include::includes/devtools/extension-add.adoc[]

[[dev-mode]]
== Development mode

Quarkus comes with a built-in development mode.
Run your application with:

include::includes/devtools/dev.adoc[]

You can then update the application sources, resources and configurations.
The changes are automatically reflected in your running application.
This is great to do development spanning UI and database as you see changes reflected immediately.

Dev mode enables hot deployment with background compilation, which means
that when you modify your Java files or your resource files and refresh your browser these changes will automatically take effect.
This works too for resource files like the configuration property file.
The act of
refreshing the browser triggers a scan of the workspace, and if any changes are detected the Java files are compiled,
and the application is redeployed, then your request is serviced by the redeployed application. If there are any issues
with compilation or deployment an error page will let you know.

Hit `CTRL+C` to stop the application.

[NOTE]
====
By default, `quarkus:dev` sets the debug host to `localhost` (for security reasons). If you need to change this, for example to enable debugging on all hosts, you can use the `-DdebugHost` option like so:

:dev-additional-parameters: -DdebugHost=0.0.0.0
include::includes/devtools/dev-parameters.adoc[]
:!dev-additional-parameters:
====

=== Remote Development Mode

It is possible to use development mode remotely, so that you can run Quarkus in a container environment (such as OpenShift)
and have changes made to your local files become immediately visible.

This allows you to develop in the same environment you will actually run your app in, and with access to the same services.

WARNING: Do not use this in production. This should only be used in a development environment. You should not run production application in dev mode.

To do this you must build a mutable application, using the `mutable-jar` format. Set the following properties in `application.properties`:

[source,properties]
----
quarkus.package.type=mutable-jar <1>
quarkus.live-reload.password=changeit <2>
quarkus.live-reload.url=http://my.cluster.host.com:8080 <3>
----
<1> This tells Quarkus to use the mutable-jar format. Mutable applications also include the deployment time parts of Quarkus,
so they take up a bit more disk space. If run normally they start just as fast and use the same memory as an immutable application,
however they can also be started in dev mode.
<2> The password that is used to secure communication between the remote side and the local side.
<3> The URL that your app is going to be running in dev mode at. This is only needed on the local side, so you
may want to leave it out of the properties file and specify it as a system property on the command line.

The `mutable-jar` is then built in the same way that a regular Quarkus jar is built, i.e. by issuing:

include::includes/devtools/build.adoc[]

Before you start Quarkus on the remote host set the environment variable `QUARKUS_LAUNCH_DEVMODE=true`. If you are
on bare metal you can set it via the `export QUARKUS_LAUNCH_DEVMODE=true` command and then run the application with the proper `java -jar ...` command to run the application.

If you plan on running the application via Docker, then you'll need to add `-e QUARKUS_LAUNCH_DEVMODE=true` to the `docker run` command.
When the application starts you should now see the following line in the logs: `Profile dev activated. Live Coding activated`.

NOTE: The remote side does not need to include Maven or any other development tools. The normal `fast-jar` Dockerfile
that is generated with a new Quarkus application is all you need. If you are using bare metal launch the Quarkus runner
jar, do not attempt to run normal devmode.

Now you need to connect your local agent to the remote host, using the `remote-dev` command:

[source,bash]
----
./mvnw quarkus:remote-dev -Dquarkus.live-reload.url=http://my-remote-host:8080
----

Now every time you refresh the browser you should see any changes you have made locally immediately visible in the remote
app. This is done via a HTTP based long polling transport, that will synchronize your local workspace and the remote
application via HTTP calls.

If you do not want to use the HTTP feature then you can simply run the `remote-dev` command without specifying the URL.
In this mode the command will continuously rebuild the local application, so you can use an external tool such as odo or
rsync to sync to the remote application.

All the config options are shown below:

include::{generated-dir}/config/quarkus-live-reload-live-reload-config.adoc[opts=optional, leveloffset=+1]

NOTE: It is recommended you use SSL when using remote dev mode, however even if you are using an unencrypted connection
your password is never sent directly over the wire. For the initial connection request the password is hashed with the
initial state data, and subsequent requests hash it with a random session id generated by the server and any body contents
for POST requests, and the path for DELETE requests, as well as an incrementing counter to prevent replay attacks.

=== Configuring Development Mode

By default, the Maven plugin picks up compiler flags to pass to
`javac` from `maven-compiler-plugin`.

If you need to customize the compiler flags used in development mode,
add a `configuration` section to the `plugin` block and set the
`compilerArgs` property just as you would when configuring
`maven-compiler-plugin`.  You can also set `source`, `target`, and
`jvmArgs`.  For example, to pass `--enable-preview` to both the JVM
and `javac`:

[source,xml]
----
<plugin>
  <groupId>${quarkus.platform.group-id}</groupId>
  <artifactId>quarkus-maven-plugin</artifactId>
  <version>${quarkus.platform.version}</version>

  <configuration>
    <source>${maven.compiler.source}</source>
    <target>${maven.compiler.target}</target>
    <compilerArgs>
      <arg>--enable-preview</arg>
    </compilerArgs>
    <jvmArgs>--enable-preview</jvmArgs>
  </configuration>

  ...
</plugin>
----


== Debugging

In development mode, Quarkus starts by default with debug mode enabled, listening to port `5005` without suspending the JVM.

This behavior can be changed by giving the `debug` system property one of the following values:

* `false` - the JVM will start with debug mode disabled
* `true` - The JVM is started in debug mode and will be listening on port `5005`
* `client` - the JVM will start in client mode and attempt to connect to `localhost:5005`
* `{port}` - The JVM is started in debug mode and will be listening on `{port}`

An additional system property `suspend` can be used to suspend the JVM, when launched in debug mode. `suspend` supports the following values:

* `y` or `true` - The debug mode JVM launch is suspended
* `n` or `false` - The debug mode JVM is started without suspending


[TIP]
====
You can also run a Quarkus application in debug mode with a suspended JVM using:

:dev-additional-parameters: -Dsuspend -Ddebug
include::includes/devtools/dev-parameters.adoc[]
:!dev-additional-parameters:

Then, attach your debugger to `localhost:5005`.
====

== Import in your IDE

Once you have a <<project-creation, project generated>>, you can import it in your favorite IDE.
The only requirement is the ability to import a Maven project.

**Eclipse**

In Eclipse, click on: `File -> Import`.
In the wizard, select: `Maven -> Existing Maven Project`.
On the next screen, select the root location of the project.
The next screen list the found modules; select the generated project and click on `Finish`. Done!

In a separated terminal, run:

include::includes/devtools/dev.adoc[]

and enjoy a highly productive environment.

**IntelliJ**

In IntelliJ:

1. From inside IntelliJ select `File -> New -> Project From Existing Sources...` or, if you are on the welcome dialog, select `Import project`.
2. Select the project root
3. Select `Import project from external model` and `Maven`
4. Next a few times (review the different options if needed)
5. On the last screen click on Finish

In a separated terminal or in the embedded terminal, run:

include::includes/devtools/dev.adoc[]

Enjoy!

**Apache NetBeans**

In NetBeans:

1. Select `File -> Open Project`
2. Select the project root
3. Click on `Open Project`

In a separated terminal or the embedded terminal, go to the project root and run:

include::includes/devtools/dev.adoc[]

Enjoy!

**Visual Studio Code**

Open the project directory in VS Code. If you have installed the Java Extension Pack (grouping a set of Java extensions), the project is loaded as a Maven project.

== Logging Quarkus application build classpath tree

Usually, dependencies of an application (which is a Maven project) could be displayed using `mvn dependency:tree` command. In case of a Quarkus application, however, this command will list only the runtime dependencies of the application.
Given that the Quarkus build process adds deployment dependencies of the extensions used in the application to the original application classpath, it could be useful to know which dependencies and which versions end up on the build classpath.
Luckily, the `quarkus` Maven plugin includes the `dependency-tree` goal which displays the build dependency tree for the application.

Executing `./mvnw quarkus:dependency-tree` on your project should result in an output similar to:

[source,text,subs=attributes+]
----
[INFO] --- quarkus-maven-plugin:{quarkus-version}:dependency-tree (default-cli) @ getting-started ---
[INFO] org.acme:getting-started:jar:1.0.0-SNAPSHOT
[INFO] └─ io.quarkus:quarkus-resteasy-deployment:jar:{quarkus-version} (compile)
[INFO]    ├─ io.quarkus:quarkus-resteasy-server-common-deployment:jar:{quarkus-version} (compile)
[INFO]    │  ├─ io.quarkus:quarkus-core-deployment:jar:{quarkus-version} (compile)
[INFO]    │  │  ├─ commons-beanutils:commons-beanutils:jar:1.9.3 (compile)
[INFO]    │  │  │  ├─ commons-logging:commons-logging:jar:1.2 (compile)
[INFO]    │  │  │  └─ commons-collections:commons-collections:jar:3.2.2 (compile)
...
----

The goal accepts the following optional parameters:

* `mode` - the default value is `prod`, i.e. the production build dependency tree. Alternatively, it accepts values `test` to display the test dependency tree and `dev` to display the dev mode dependency tree;
* `outputFile` - specifies the file to persist the dependency tree to;
* `appendOutput` - the default value is `false`, indicates whether the output to the command should be appended to the file specified with the `outputFile` parameter or it should be overriden.

== Downloading Maven artifact dependencies for offline development and testing

Quarkus extension dependencies are divided into the runtime extension dependencies that end up on the application runtime classpath and the deployment (or build time) extension dependencies that are resolved by Quarkus only at application build time to create
the build classpath. Application developers are expected to express dependencies only on the runtime artifacts of Quarkus extensions. As a consequence, the deployment extension dependencies aren't visible to Maven plugins that aren't aware of the Quarkus
extension dependency model, such as the `maven-dependency-plugin`, `go-offline-maven-plugin`, etc. That means those plugins can not be used to pre-download all the application dependencies to be able to build and test the application later in offline mode.

To enable the use-case of building and testing a Quarkus application offline, the `quarkus-maven-plugin` includes the `go-offline` goal that could be called from the command line like this:

[source,bash]
----
./mvnw quarkus:go-offline
----

This goal will resolve all the runtime, build time, test and dev mode dependencies of the application downloading them to the configured local Maven repository.

== Building a native executable

Native executables make Quarkus applications ideal for containers and serverless workloads.

Make sure to have `GRAALVM_HOME` configured and pointing to GraalVM version {graalvm-version} (Make sure to use a Java 11 version of GraalVM).
Verify that your `pom.xml` has the proper `native` profile (see <<build-tool-maven>>).

Create a native executable using:

include::includes/devtools/build-native.adoc[]

A native executable will be present in `target/`.

To run Integration Tests on the native executable, make sure to have the proper Maven plugin configured (see <<build-tool-maven>>) and launch the `verify` goal.

[source,shell]
----
$ ./mvnw verify -Pnative
...
[quarkus-quickstart-runner:50955]     universe:     391.96 ms
[quarkus-quickstart-runner:50955]      (parse):     904.37 ms
[quarkus-quickstart-runner:50955]     (inline):   1,143.32 ms
[quarkus-quickstart-runner:50955]    (compile):   6,228.44 ms
[quarkus-quickstart-runner:50955]      compile:   9,130.58 ms
[quarkus-quickstart-runner:50955]        image:   2,101.42 ms
[quarkus-quickstart-runner:50955]        write:     803.18 ms
[quarkus-quickstart-runner:50955]      [total]:  33,520.15 ms
[INFO]
[INFO] --- maven-failsafe-plugin:2.22.0:integration-test (default) @ quarkus-quickstart-native ---
[INFO]
[INFO] -------------------------------------------------------
[INFO]  T E S T S
[INFO] -------------------------------------------------------
[INFO] Running org.acme.quickstart.GreetingResourceIT
Executing [/Users/starksm/Dev/JBoss/Quarkus/starksm64-quarkus-quickstarts/getting-started-native/target/quarkus-quickstart-runner, -Dquarkus.http.port=8081, -Dtest.url=http://localhost:8081, -Dquarkus.log.file.path=target/quarkus.log]
2019-02-28 16:52:42,020 INFO  [io.quarkus] (main) Quarkus started in 0.007s. Listening on: http://localhost:8080
2019-02-28 16:52:42,021 INFO  [io.quarkus] (main) Installed features: [cdi, resteasy]
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.081 s - in org.acme.quickstart.GreetingResourceIT
[INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0

...
----

=== Build a container friendly executable

The native executable will be specific to your operating system.
To create an executable that will run in a container, use the following:

:build-additional-parameters: -Dquarkus.native.container-build=true
include::includes/devtools/build-native.adoc[]
:!build-additional-parameters:

The produced executable will be a 64 bit Linux executable, so depending on your operating system it may no longer be runnable.
However, it's not an issue as we are going to copy it to a Docker container.
Note that in this case the build itself runs in a Docker container too, so you don't need to have GraalVM installed locally.

[TIP]
====
By default, the native executable will be generated using the `quay.io/quarkus/ubi-quarkus-native-image:{graalvm-flavor}` Docker image.

If you want to build a native executable with a different Docker image (for instance to use a different GraalVM version),
use the `-Dquarkus.native.builder-image=<image name>` build argument.

The list of the available Docker images can be found on https://quay.io/repository/quarkus/ubi-quarkus-native-image?tab=tags[quay.io].
Be aware that a given Quarkus version might not be compatible with all the images available.
====

You can follow the xref:building-native-image.adoc[Build a native executable guide] as well as xref:deploying-to-kubernetes.adoc[Deploying Application to Kubernetes and OpenShift] for more information.

[[build-tool-maven]]
== Maven configuration

If you have not used <<project-creation,project scaffolding>>, add the following elements in your `pom.xml`

[source,xml,subs=attributes+]
----
<dependencyManagement>
    <dependencies>
        <dependency> <1>
            <groupId>${quarkus.platform.group-id}</groupId>
            <artifactId>quarkus-bom</artifactId>
            <version>${quarkus.platform.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<build>
    <plugins>
        <plugin> <2>
            <groupId>${quarkus.platform.group-id}</groupId>
            <artifactId>quarkus-maven-plugin</artifactId>
            <version>${quarkus.platform.version}</version>
            <extensions>true</extensions> <3>
            <executions>
                <execution>
                    <goals>
                        <goal>build</goal>
                        <goal>generate-code</goal>
                        <goal>generate-code-tests</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        <plugin> <4>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>${surefire-plugin.version}</version>
            <configuration>
                <systemPropertyVariables>
                    <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
                    <maven.home>${maven.home}</maven.home>
                </systemPropertyVariables>
            </configuration>
        </plugin>
    </plugins>
</build>

<profiles>
    <profile> <5>
        <id>native</id>
        <properties> <6>
            <quarkus.package.type>native</quarkus.package.type>
        </properties>
        <build>
            <plugins>
                <plugin> <7>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-failsafe-plugin</artifactId>
                    <version>${surefire-plugin.version}</version>
                    <executions>
                        <execution>
                            <goals>
                                <goal>integration-test</goal>
                                <goal>verify</goal>
                            </goals>
                            <configuration>
                                <systemPropertyVariables>
                                    <native.image.path>${project.build.directory}/${project.build.finalName}-runner</native.image.path>
                                    <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
                                    <maven.home>${maven.home}</maven.home>
                                </systemPropertyVariables>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>
----

<1> Optionally use a BOM file to omit the version of the different Quarkus dependencies.
<2> Use the Quarkus Maven plugin that will hook into the build process.
<3> Enabling Maven plugin extensions will register a Quarkus `MavenLifecycleParticipant` which will make sure the Quarkus classloaders used during the build are properly closed. During the `generate-code` and `generate-code-tests` goals the Quarkus application bootstrap is initialized and re-used in the `build` goal (which actually builds and packages a production application). The Quarkus classloaders will be properly closed in the `build` goal of the `quarkus-maven-plugin`. However, if the build fails in between the `generate-code` or `generate-code-tests` and `build` then the Quarkus augmentation classloader won't be properly closed, which may lead to locking of JAR files that happened to be on the classpath on Windows OS.
<4> Add system properties to `maven-surefire-plugin`. +
`maven.home` is only required if you have custom configuration in `${maven.home}/conf/settings.xml`.
<5> Use a specific `native` profile for native executable building.
<6> Enable the `native` package type. The build will therefore produce a native executable.
<7> If you want to test your native executable with Integration Tests, add the following plugin configuration. Test names `*IT` and annotated `@NativeImageTest` or `@QuarkusIntegrationTest` will be run against the native executable. See the xref:building-native-image.adoc[Native executable guide] for more info.

[[fast-jar]]
=== Using fast-jar

`fast-jar` is the default quarkus package type.

The result of the build is a directory under `target` named `quarkus-app`.

You can run the application using: `java -jar target/quarkus-app/quarkus-run.jar`.

WARNING: In order to successfully run the produced jar, you need to have the entire contents of the `quarkus-app` directory. If any of the files are missing, the application will not start or
might not function correctly.

TIP: The `fast-jar` packaging results in creating an artifact that starts a little faster and consumes slightly less memory than a legacy Quarkus jar
because it has indexed information about which dependency jar contains classes and resources. It can thus avoid the lookup into potentially every jar
on the classpath that the legacy jar necessitates, when loading a class or resource.

[[uber-jar-maven]]
=== Uber-Jar Creation

Quarkus Maven plugin supports the generation of Uber-Jars by specifying a `quarkus.package.type=uber-jar` configuration option in your `application.properties`
(or `<quarkus.package.type>uber-jar</quarkus.package.type>` in your `pom.xml`).

The original jar will still be present in the `target` directory but it will be renamed to contain the `.original` suffix.

When building an Uber-Jar you can specify entries that you want to exclude from the generated jar by using the `quarkus.package.ignored-entries` configuration
option, this takes a comma separated list of entries to ignore.

Uber-Jar creation by default excludes link:https://docs.oracle.com/javase/tutorial/deployment/jar/intro.html[signature files] that might be present in the dependencies of the application.

Uber-Jar's final name is configurable via a Maven's build settings `finalName` option.

[[multi-module-maven]]
=== Working with multi-module projects

By default, Quarkus will not discover CDI beans inside another module.

The best way to enable CDI bean discovery for a module in a multi-module project would be to include the `jandex-maven-plugin`,
unless it is the main application module already configured with the quarkus-maven-plugin, in which case it will indexed automatically.

[source,xml,subs=""attributes+""]
----
<build>
  <plugins>
    <plugin>
      <groupId>org.jboss.jandex</groupId>
      <artifactId>jandex-maven-plugin</artifactId>
      <version>{jandex-maven-plugin-version}</version>
      <executions>
        <execution>
          <id>make-index</id>
          <goals>
            <goal>jandex</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>
----

More information on this topic can be found on the xref:cdi-reference.adoc#bean_discovery[Bean Discovery] section of the CDI guide.

[[maven-configuration-profile]]
=== Building with a specific configuration profile

Quarkus supports xref:config-reference.adoc#profiles[configuration profiles] in order to provide a specific configuration according to the target environment.

The profile can be provided directly in the Maven build's command thanks to the system property `quarkus.profile` with a command of type:

// TODO switch to <profile-name-here> once escaping issue is fixed in Asciidoctor
:build-additional-parameters: -Dquarkus.profile=profile-name-here
include::includes/devtools/build.adoc[]
:!build-additional-parameters:

However it is also possible to specify the profile directly in the POM file of the project using project properties, the Quarkus Maven plugin configuration properties or system properties set in the Quarkus Maven plugin configuration.

In order of precedence (greater precedence first):

.1. System properties set in the Quarkus Maven plugin configuration

[source,xml]
----
<project xsi:schemaLocation=""http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"" xmlns=""http://maven.apache.org/POM/4.0.0""
    xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
  ...
  <build>
    <plugins>
      ...
      <plugin>
        <groupId>${quarkus.platform.group-id}</groupId>
        <artifactId>quarkus-maven-plugin</artifactId>
        <version>${quarkus.platform.version}</version>
        <extensions>true</extensions>
        <configuration>
          <systemProperties>
            <quarkus.profile>prod-aws</quarkus.profile> <1>
          </systemProperties>
        </configuration>
     </plugin>
     ...
    </plugins>
  </build>
...
</project>
----
<1> The default configuration profile of this project is `prod-aws`.

.2. Quarkus Maven plugin configuration properties

[source,xml]
----
<project xsi:schemaLocation=""http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"" xmlns=""http://maven.apache.org/POM/4.0.0""
    xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
  ...
  <build>
    <plugins>
      ...
      <plugin>
        <groupId>${quarkus.platform.group-id}</groupId>
        <artifactId>quarkus-maven-plugin</artifactId>
        <version>${quarkus.platform.version}</version>
        <extensions>true</extensions>
        <configuration>
          <properties>
            <quarkus.profile>prod-aws</quarkus.profile> <1>
          </properties>
        </configuration>
     </plugin>
     ...
    </plugins>
  </build>
...
</project>
----
<1> The default configuration profile of this project is `prod-aws`.

.3. Project properties

[source,xml]
----
<project xsi:schemaLocation=""http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"" xmlns=""http://maven.apache.org/POM/4.0.0""
    xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
  ...
  <properties>
    <quarkus.profile>prod-aws</quarkus.profile> <1>
    ...
  </properties>
...
</project>
----
<1> The default configuration profile of this project is `prod-aws`.

NOTE: Whatever the approach is chosen, the profile can still be overridden with the `quarkus.profile` system property or the `QUARKUS_PROFILE` environment variable.

[[maven-multi-build]]
=== Building several artifacts from a single module

In some particular use cases, it can be interesting to build several artifacts of your application from the same module.
A typical example is when you want to build your application with different configuration profiles.

In that case, it is possible to add as many executions as needed to the Quarkus Maven plugin configuration.

Below is an example of a Quarkus Maven plugin configuration that will produce two builds of the same application: one using the `prod-oracle` profile and the other one using the `prod-postgresql` profile.

[source,xml]
----
<project xsi:schemaLocation=""http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"" xmlns=""http://maven.apache.org/POM/4.0.0""
    xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
  ...
  <build>
    <plugins>
      ...
      <plugin>
        <groupId>${quarkus.platform.group-id}</groupId>
        <artifactId>quarkus-maven-plugin</artifactId>
        <version>${quarkus.platform.version}</version>
        <extensions>true</extensions>
        <executions>
          <execution>
            <id>oracle</id>
            <goals>
              <goal>build</goal>
            </goals>
            <configuration>
              <properties>
                <quarkus.profile>prod-oracle</quarkus.profile> <1>
                <quarkus.package.output-directory>oracle-quarkus-app</quarkus.package.output-directory> <2>
              </properties>
            </configuration>
          </execution>
          <execution>
            <id>postgresql</id>
            <goals>
              <goal>build</goal>
            </goals>
            <configuration>
              <properties>
                <quarkus.profile>prod-postgresql</quarkus.profile> <3>
                <quarkus.package.output-directory>postgresql-quarkus-app</quarkus.package.output-directory> <4>
              </properties>
            </configuration>
          </execution>
        </executions>
     </plugin>
     ...
    </plugins>
  </build>
...
</project>
----
<1> The default configuration profile of the first execution of the plugin is `prod-oracle`.
<2> The output directory of the first execution of the plugin is set to `oracle-quarkus-app` instead of `quarkus-app` to have a dedicated directory.
<3> The default configuration profile of the second execution of the plugin is `prod-postgresql`.
<4> The output directory of the second execution of the plugin is set to `postgresql-quarkus-app` instead of `quarkus-app` to have a dedicated directory.

NOTE: With the configuration above, both profile builds will be using the same dependencies, so if we added dependencies on the Oracle and PostgreSQL drivers to the application, both of the drivers will appear in both builds.


To isolate profile-specific dependencies from other profiles, the JDBC drivers could be added as optional dependencies to the application but configured to be included in each profile that requires them, e.g.:

[source,xml]
----
<project xsi:schemaLocation=""http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"" xmlns=""http://maven.apache.org/POM/4.0.0""
    xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
  ...
  <dependencies>
    ...
    <dependency>
      <groupId>org.postgresql</groupId>
      <artifactId>postgresql</artifactId>
      <version>${postgresql.driver.version}</version>
      <optional>true</optional> <1>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      ...
      <plugin>
        <groupId>${quarkus.platform.group-id}</groupId>
        <artifactId>quarkus-maven-plugin</artifactId>
        <version>${quarkus.platform.version}</version>
        <extensions>true</extensions>
        <executions>
          ...
          <execution>
            <id>postgresql</id>
            <goals>
              <goal>build</goal>
            </goals>
            <configuration>
              <properties>
                <quarkus.profile>prod-postgresql</quarkus.profile>
                <quarkus.package.output-directory>postgresql-quarkus-app</quarkus.package.output-directory>
                <quarkus.package.filter-optional-dependencies>true</quarkus.package.filter-optional-dependencies> <2>
                <quarkus.package.included-optional-dependencies>org.postgresql:postgresql::jar</quarkus.package.included-optional-dependencies> <3>
              </properties>
            </configuration>
          </execution>
        </executions>
     </plugin>
     ...
    </plugins>
  </build>
...
</project>
----
<1> The JDBC driver of PostgreSQL is defined as an optional dependency
<2> For backward compatibility reasons, it is necessary to explicitly indicate that the optional dependencies need to be filtered.
<3> Only the optional dependency corresponding to the JDBC driver of PostgreSQL is expected in the final artifact.

[[configuration-reference]]
== Configuring the Project Output

There are a several configuration options that will define what the output of your project build will be.
These are provided in `application.properties` the same as any other config property.

The properties are shown below:

include::{generated-dir}/config/quarkus-package-pkg-package-config.adoc[opts=optional]

[[custom-test-configuration-profile]]
=== Custom test configuration profile in JVM mode

By default, Quarkus tests in JVM mode are run using the `test` configuration profile. If you are not familiar with Quarkus
configuration profiles, everything you need to know is explained in the
xref:config.adoc#configuration-profiles[Configuration Profiles Documentation].

It is however possible to use a custom configuration profile for your tests with the Maven Surefire and Maven Failsafe
configurations shown below. This can be useful if you need for example to run some tests using a specific database which is not
your default testing database.

[source,xml,subs=attributes+]
----
<project>
  [...]
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>${surefire-plugin.version}</version>
        <configuration>
          <systemPropertyVariables>
            <quarkus.test.profile>foo</quarkus.test.profile> <1>
            <buildDirectory>${project.build.directory}</buildDirectory>
            [...]
          </systemPropertyVariables>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-failsafe-plugin</artifactId>
        <version>${failsafe-plugin.version}</version>
        <configuration>
          <systemPropertyVariables>
            <quarkus.test.profile>foo</quarkus.test.profile> <1>
            <buildDirectory>${project.build.directory}</buildDirectory>
            [...]
          </systemPropertyVariables>
        </configuration>
      </plugin>
    </plugins>
  </build>
  [...]
</project>
----

<1> The `foo` configuration profile will be used to run the tests.

[WARNING]
====
It is not possible to use a custom test configuration profile in native mode for now. Native tests are always run using the
`prod` profile.
====

[[bootstrap-maven-properties]]
=== Bootstrap Maven properties

Quarkus bootstrap includes a Maven resolver implementation that is used to resolve application runtime and build time dependencies. The Quarkus Maven resolver is initialized from the same Maven command line that launched the build, test or dev mode. Typically, there is no need to add any extra configuration for it. However, there could be cases where an extra configuration option may be necessary to properly resolve application dependencies in test or dev modes, or IDEs.

Maven test plugins (such as `surefire` and `failsafe`), for example, are not propagating build system properties to the running tests by default. Which means some of the system properties set by the Maven CLI aren't available for the Quarkus Maven resolver initialized for the tests, which may result in test dependencies being resolved using different settings than the main Maven build.

Here is a list of system properties the Quarkus bootstrap Maven resolver checks during its initialization.

[cols=3*,options=""header""]
|===
| Property name
| Default Value
| Description

| `maven.home`
| `MAVEN_HOME` envvar
| The Maven home dir is used to resolve the global settings file unless it was explicitly provided on the command line with the `-gs` argument

| `maven.settings`
| `~/m2/settings.xml`
| Unless the custom settings file has been provided with the `-s` argument, this property can be used to point the resolver to a custom Maven settings file

| `maven.repo.local`
| `~/m2/repository`
| This property could be used to configure a custom local Maven repository directory, if it is different from the default one and the one specified in the `settings.xml`

| `maven.top-level-basedir`
| none
| This property may be useful to help the Maven resolver identify the top-level Maven project in the workspace. By default, the Maven resolver will be discovering a project's workspace by navigating the parent-module POM relationship. However there could be project layouts that are using an aggregator module which isn't appearing as the parent for its modules. In this case, this property will help the Quarkus Maven resolver to properly discover the workspace.

| `quarkus.bootstrap.effective-model-builder`
| `false`
| By default, the Quarkus Maven resolver is reading project's POMs directly when discovering the project's layout. While in most cases it works well enough and relatively fast, reading raw POMs has its limitation. E.g. if a POM includes modules in a profile, these modules will not be discovered. This system property enables project's layout discovery based on the effective POM models, that are properly interpolated, instead of the raw ones. The reason this option is not enabled by default is it may appear to be significantly more time consuming that could increase, e.g. CI testing times. Until there is a better approach found that could be used by default, projects that require it should enable this option.

|===

These system properties above could be added to, e.g., a `surefire` and/or `failsafe` plugin configuration as
[source,xml,subs=attributes+]
----
<project>
  [...]
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>${surefire-plugin.version}</version>
        <configuration>
          <systemPropertyVariables>
            <maven.home>${maven.hom}</maven.home> <1>
            <maven.repo.local>${settings.localRepository}</maven.repo.local> <2>
            <maven.settings>${session.request.userSettingsFile.path}</maven.settings> <3>
            <maven.top-level-basedir>${session.topLevelProject.basedir.absolutePath}</maven.top-level-basedir> <4>
            <quarkus.bootstrap.effective-model-builder>true</quarkus.bootstrap.effective-model-builder> <5>
          </systemPropertyVariables>
        </configuration>
      </plugin>
    </plugins>
  </build>
  [...]
</project>
----

<1> Propagate `maven.home` system property set by the Maven CLI to the tests
<2> Set the Maven local repository directory for the tests
<3> Set the Maven settings file the tests
<4> Point to the top-level project directory for the tests
<5> Enable effective POM-based project layout discovery

==== Top-level vs Multi-module project directory

In Maven there appears to be a notion of the top-level project (that is exposed as a project property `${session.topLevelProject.basedir.absolutePath}`)
and the multi-module project directory (that is available as property `${maven.multiModuleProjectDirectory}`). These directories might not always match!

IMPORTANT: `maven.multiModuleProjectDirectory` is meant to be consulted by the Maven code itself and not something to be relied upon by user code. So, if you find it useful, use it at your own risk!

The `${maven.multiModuleProjectDirectory}` will be resolved to the first directory that contains `.mvn` directory as its child going up the workspace file system tree
starting from the current directory (or the one specified with the `-f` argument) from which the `mvn` command was launched. If the `.mvn` directory was not found, however,
the `${maven.multiModuleProjectDirectory}` will be pointing to the directory from which the `mvn` command was launched (or the one targeted with the `-f` argument).

The `${session.topLevelProject.basedir.absolutePath}` will be pointing either to the directory from which the `mvn` command was launched or to the directory targeted with
the `-f` argument, if it was specified.

[[project-info]]
== Quarkus project info

The Quarkus Maven plugin includes a goal called `info` (currently marked as 'experimental') that logs Quarkus-specific information about the project, such as: the imported Quarkus platform BOMs and the Quarkus extensions found among the project dependencies.
In a multi-module project `quarkus:info` will assume that the current module, in which it is executed, is the main module of the application.

NOTE: The report generated by `quarkus:info` is not currently including the Quarkus Maven plugin information, however it's planned to be added in the future releases.

Here is an example `info` output for a simple project:
[source,text,subs=attributes+]
----
[aloubyansky@localhost code-with-quarkus]$ mvn quarkus:info
[INFO] Scanning for projects...
[INFO] 
[INFO] ---------------------< org.acme:code-with-quarkus >---------------------
[INFO] Building code-with-quarkus 1.0.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- quarkus-maven-plugin:{quarkus-version}:info (default-cli) @ code-with-quarkus ---
[WARNING] quarkus:info goal is experimental, its options and output may change in future versions
[INFO] Quarkus platform BOMs: <1>
[INFO]   io.quarkus.platform:quarkus-bom:pom:{quarkus-version}
[INFO]   io.quarkus.platform:quarkus-kogito-bom:pom:{quarkus-version}
[INFO]   io.quarkus.platform:quarkus-camel-bom:pom:{quarkus-version}
[INFO] 
[INFO] Extensions from io.quarkus.platform:quarkus-bom: <2>
[INFO]   io.quarkus:quarkus-resteasy-reactive
[INFO] 
[INFO] Extensions from io.quarkus.platform:quarkus-kogito-bom: <3>
[INFO]   org.kie.kogito:kogito-quarkus-decisions
[INFO] 
[INFO] Extensions from io.quarkus.platform:quarkus-camel-bom: <4>
[INFO]   org.apache.camel.quarkus:camel-quarkus-rabbitmq
[INFO] 
[INFO] Extensions from registry.quarkus.io: <5>
[INFO]   io.quarkiverse.prettytime:quarkus-prettytime:0.2.1
----

<1> Quarkus platform BOMs imported in the project (BOMs imported by parent POMs will also be reported)
<2> Direct Quarkus extension dependencies managed by the `quarkus-bom`
<3> Direct Quarkus extension dependencies managed by the `quarkus-kogito-bom`
<4> Direct Quarkus extension dependencies managed by the `quarkus-camel-bom`
<5> Direct Quarkus extensions dependencies that aren't managed by Quarkus BOMs but found in the Quarkus extension registry

NOTE: `quarkus:info` will also report Quarkus extensions that aren't found in the Quarkus extension registries if those are present among the project dependencies, indicating they have an 'unknown origin'.

[[project-info-misaligned]]
=== Highlighing misaligned versions

`quarkus:info` will also highlight basic Quarkus dependency version misalignments, in case they are detected. For example, if we modify the project mentioned above by removing the `kogito-quarkus-decisions` extension from the dependencies and adding a `2.6.3.Final` `<version>` element to the `quarkus-resteasy-reactive` dependency that is managed by the `quarkus-bom` and then run `quarkus:info` again, we'll see something like:

[source,text,subs=attributes+]
----
[INFO] --- quarkus-maven-plugin:{quarkus-version}:info (default-cli) @ code-with-quarkus ---
[WARNING] quarkus:info goal is experimental, its options and output may change in future versions
[INFO] Quarkus platform BOMs:
[INFO]   io.quarkus.platform:quarkus-bom:pom:{quarkus-version}
[INFO]   io.quarkus.platform:quarkus-kogito-bom:pom:{quarkus-version} | unnecessary <1>
[INFO]   io.quarkus.platform:quarkus-camel-bom:pom:{quarkus-version}
[INFO] 
[INFO] Extensions from io.quarkus.platform:quarkus-bom:
[INFO]   io.quarkus:quarkus-resteasy-reactive:2.6.3.Final | misaligned <2>
[INFO] 
[INFO] Extensions from io.quarkus.platform:quarkus-camel-bom:
[INFO]   org.apache.camel.quarkus:camel-quarkus-rabbitmq
[INFO] 
[INFO] Extensions from registry.quarkus.io:
[INFO]   io.quarkiverse.prettytime:quarkus-prettytime:0.2.1
[INFO]
[WARNING] Non-recommended Quarkus platform BOM and/or extension versions were found. For more details, please, execute 'mvn quarkus:update -Drectify'
----

<1> The `quarkus-kogito-bom` import is now reported as 'unnecessary' since none of the Quarkus extensions it includes are found among the project dependencies
<2> The version `2.6.3.Final` of the `quarkus-resteasy-reactive` is now reported as being misaligned with the version managed by the Quarkus platform BOM imported in the project, which is {quarkus-version}

[[project-update]]
== Quarkus project update

The `quarkus:update` goal (currently marked as 'experimental') provided by the Quarkus Maven plugin can be used to check whether there are Quarkus-related updates available for a project, such as: new releases of the relevant Quarkus platform BOMs and non-platform Quarkus extensions present in the project. In a multi-module project the `update` goal is meant to be executed from the main Quarkus application module.

IMPORTANT: At this point, the `quarkus:update` goal does not actually apply the recommended updates but simply reports what they are and how to apply them manually.

NOTE: The Quarkus Maven plugin version isn't currently included in the update report, however it's planned to be added in the future releases.

The way `quarkus:update` works, first, all the direct Quarkus extension dependencies of the project are collected (those that are managed by the Quarkus platform BOMs and those that aren't but found in the Quarkus extension registries). Then the configured Quarkus extension registries (typically the `registry.quarkus.io`) will be queried for the latest recommended/supported Quarkus platform versions and non-platform Quarkus extensions compatible with them. The algorithm will then select the latest compatible combination of all the extensions found in the project, assuming such a combination actually exists. Otherwise, no updates will be suggested.

Assuming we have a project including Kogito, Camel and core Quarkus extensions available in the Quarkus platform based on Quarkus `2.7.1.Final`, the output of the `quarkus:update` would look like:
[source,text,subs=attributes+]
----
[aloubyansky@localhost code-with-quarkus]$ mvn quarkus:update
[INFO] Scanning for projects...
[INFO] 
[INFO] ---------------------< org.acme:code-with-quarkus >---------------------
[INFO] Building code-with-quarkus 1.0.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- quarkus-maven-plugin:{quarkus-version}:update (default-cli) @ code-with-quarkus ---
[WARNING] quarkus:update goal is experimental, its options and output might change in future versions
[INFO] 
[INFO] Recommended Quarkus platform BOM updates: <1>
[INFO] Update: io.quarkus.platform:quarkus-bom:pom:2.7.1.Final -> {quarkus-version}
[INFO] Update: io.quarkus.platform:quarkus-kogito-bom:pom:2.7.1.Final -> {quarkus-version}
[INFO] Update: io.quarkus.platform:quarkus-camel-bom:pom:2.7.1.Final -> {quarkus-version}
----

<1> A list of currently recommended Quarkus platform BOM updates

NOTE: Typically, a single project property will be used to manage all the Quarkus platform BOMs but the implementation isn't currently smart enough to point that out and will report updates for each BOM individually.

If we modify the project to remove all the Kogito extensions from the project, change the version of the `quarkus-resteasy-reactive` extension to `2.6.3.Final` and downgrade `quarkus-prettytime` which is not included in the Quarkus platform BOMs to `0.2.0`, `quarkus:update` will report something like:

[source,text,subs=attributes+]
----
[INFO] Recommended Quarkus platform BOM updates: <1>
[INFO] Update: io.quarkus.platform:quarkus-bom:pom:2.7.1.Final -> {quarkus-version}
[INFO] Update: io.quarkus.platform:quarkus-camel-bom:pom:2.7.1.Final -> {quarkus-version}
[INFO] Remove: io.quarkus.platform:quarkus-kogito-bom:pom:2.7.1.Final <2>
[INFO] 
[INFO] Extensions from io.quarkus.platform:quarkus-bom:
[INFO] Update: io.quarkus:quarkus-resteasy-reactive:2.6.3.Final -> remove version (managed) <3>
[INFO] 
[INFO] Extensions from registry.quarkus.io:
[INFO] Update: io.quarkiverse.prettytime:quarkus-prettytime:0.2.0 -> 0.2.1 <4>
----

<1> A list of the currently recommended Quarkus platform BOM updates for the project
<2> Given that the project does not include any Kogito extensions, the BOM import is recommended to be removed
<3> An outdated version of the `quarkus-resteasy-reactive` is recommended to be removed in favor of the one managed by the `quarkus-bom`
<4> The latest compatible version of the `quarkus-prettytime` extension

=== Quarkus project rectify

As was mentioned above, `quarkus:info`, besides reporting Quarkus platform and extension versions, performs a quick version alignment check, to make sure the extension versions used in the project are compatible with the imported Quarkus platform BOMs. If misalignments are detected, the following warning message will be logged:

[source,text,subs=attributes+]
----
[WARNING] Non-recommended Quarkus platform BOM and/or extension versions were found. For more details, please, execute 'mvn quarkus:update -Drectify'
----

When the `rectify` option is enabled, `quarkus:update`, instead of suggesting the latest recommended Quarkus version updates, will log update instructions to simply align the extension dependency versions found in the project with the currently imported Quarkus platform BOMs.
",12486,False,2210.4379176854172,median
"= Volant - Developer Guide
:site-section: DeveloperGuide
:toc:
:toc-title: Table of Contents
:toc-placement: preamble
:sectnums:
:imagesDir: images
:stylesDir: stylesheets
:xrefstyle: full
ifdef::env-github[]
:tip-caption: :bulb:
:note-caption: :information_source:
:warning-caption: :warning:
endif::[]
:repoURL: https://github.com/AY1920S2-CS2103T-F09-4/main

By: `AY1920S2-CS2103T-F09-4`      Since: `Jan 2020`      Licence: `MIT`

== Introduction

This document is a Developer Guide written for developers who wish to contribute to or extend our project.
It is technical, and explains the inner workings of Volant and how the different components of our
application work together.

====
*Reading this Developer Guide*

* *Important Notations* +
[TIP]
This icon denotes useful tips to note of during development.
[NOTE]
This icon denotes important details to take note of during development.

* *Understanding Diagrams* +
The diagrams in this Developer Guide are colour coded according to the different components.
+
image::dg-diagram-legend.png[]

====

== Setting up

Refer to the guide <<SettingUp#, here>>.

== Design

[[Design-Architecture]]
=== Architecture

.Architecture Diagram
image::ArchitectureDiagram.png[align=""center""]

The *_Architecture Diagram_* given above explains the high-level design of the App. Given below is a quick overview of each component.


`Main` has two classes called link:{repoURL}/src/main/java/seedu/location/Main.java[`Main`] and link:{repoURL}/src/main/java/seedu/location/MainApp.java[`MainApp`]. It is responsible for,

* At app launch: Initializes the components in the correct sequence, and connects them up with each other.
* At shut down: Shuts down the components and invokes cleanup method where necessary.

* <<Design-Commons,*`Commons`*>> represents a collection of classes used by multiple other components.
The following class plays an important role at the architecture level:

* `LogsCenter` is used by many classes to write log messages to the App's log file, `volant.log`.

The rest of the App consists of four main components.

* <<Design-Ui,*`UI`*>>: The UI of the App.
* <<Design-Logic,*`Logic`*>>: The command executor depending on the view the user is on.
* <<Design-Model,*`Model`*>>: Holds the data of the App in-memory depending in the view the user is on.
* <<Design-Storage,*`Storage`*>>: Reads data from, and writes data to, the hard disk.

Each of the four components

* Defines its _API_ in an `interface` with the same name as the Component.
* Exposes its functionality using a `{Component Name} Manager` class.

For example, the `Logic` component (see the class diagram given below) defines its
API in the `Logic.java` interface and exposes its functionality using the `LogicManager.java` class.

==== Views in Volant

There are 4 types of pages/views in this App: `HOME`, `TRIP`, `ITINERARY`, `JOURNAL`.
Each view has their own `{Component Name} Manager` classes for both `Logic` and `Model`.

These individual `{Component Name} Manager` classes for `Logic` and `Model` provide a context for commands to be executed in,
e.g. when the user is on the `HOME` page, the `add` command modifies the trip list, when the user
is on the `ITINERARY` page, the `add` command modifies the itinerary.

For example, the `JOURNAL` view has its own `JournalLogicManager` and `JournalModelManager` to provide the context
for command execution on the `JOURNAL` page.

.Class Diagram of the Journal Logic Component
image::JournalLogic.png[align=""center""]

[discrete]
==== How the architecture components interact with each other

The _Sequence Diagram_ below shows how the components interact with each other for the scenario where the user issues
the command `back` when in a `TRIP` view. View switching is executed by the `Ui` component.

[[view-switch-sequence]]
.Component interactions for `home` command in the `JOURNAL` page.
image::home-command-sequence.png[align=""center""]


The _Sequence Diagram_ below illustrates how the components interact with each other for the scenario where the user
issues the command `goto 1` when in a `HOME` page view.
View switching is executed by the `Ui` component.

.Component interactions for `goto 1` command in the `HOME` page view.

image::gotoCommandSequenceDiagram.png[align=""center""]

The sections below give more details about each component.

[[Design-Ui]]
=== UI component

.Structure of the UI Component when a user is on a `TRIP` page
image::UIClassDiagram.png[align=""center""]

*API* : link:{repoURL}/src/main/java/seedu/location/ui/Ui.java[`Ui.java`]

The UI consists of a `MainWindow` that is made up of parts e.g.`CommandBox`, `ResultDisplay`, `StatusBarFooter`, `mainPanel` etc. All these, including the `MainWindow`, inherit from the abstract `UiPart` class.

The `UI` component uses JavaFx UI framework. The layout of these UI parts are defined in matching `.fxml` files that are in the `src/main/resources/view` folder. For example, the layout of the link:{repoURL}/src/main/java/seedu/location/ui/MainWindow.java[`MainWindow`] is specified in link:{repoURL}/src/main/resources/view/MainWindow.fxml[`MainWindow.fxml`]

The `UI` component,

* Executes user commands using the `Logic` component.
* Listens for changes to `Model` data so that the UI can be updated with the modified data.

==== View Switching
As there are four different views in Volant. Upon startup of the App, the `mainPanel` is set to `HomePage`.
There are certain commands will cause the `MainWindow` display to switch views.
For example, `goto`, `back` and `home` navigation commands.

When a view is switched, `MainWindow` will do the following:

====
For example, if a user is switching from a `TRIP` view to the `HOME` view through the command, `back`.

. Reassign the `Logic` component from `TripPageLogicManager` to a new `HomePageLogicManager`.
. Reassign the `Model` component from `TripPageModelManager` to a new `HomePageModelManager`.
. Reassign the value of `StackPane` `mainPanel` from `TripPage` to `HomePage`.

<<view-switch-sequence, You can view the sequence diagram for this process here.>>
====

_More details on the implementation of view switching can be found in <<implementation-view-switching>>._

[[Design-Logic]]
=== Logic component

[[fig-LogicClassDiagram1]]
.Structure of the Logic Component
image::JournalLogic.png[align=""center""]

*API* :
link:https://github.com/AY1920S2-CS2103T-F09-4/main/blob/master/src/main/java/seedu/volant/commons/logic/Logic.java[`Logic.java`]

.  `Logic` uses the `JournalInputParser` class of the current feature to parse the user command.
.  This results in a `Command` object which is executed by the `JournalLogicManager` of the current feature.
.  The command execution can affect the `Model` of the current feature (e.g. adding a trip).
.  The result of the command execution is encapsulated as a `CommandResult` object which is passed back to the `Ui`.
.  In addition, the `CommandResult` object can also instruct the `Ui` to perform certain actions, such as displaying help to the user.

Given below is the Sequence Diagram for interactions within the `Logic` component of the Itinerary feature for the `execute(""delete 1"")` API call.

.Interactions Inside the Logic Component for the `delete 1` Command
image::DeleteItinerary.png[align=""center""]

[[Design-Model]]
=== Model component

.Class Diagram for the Model component on the `HOME` page
image::HomeClassDiagram.png[align=""center""]

.Structure of the Model Component in Journal
image::JournalModelDiagram.png[align=""center""]

*API* : link:{repoURL}/src/main/java/seedu/location/model/Model.java[`Model.java`]

The `Model` for `JOURNAL`,

* stores a `UserPref` object that represents the user's preferences.
* stores an `Entry` 's data.
* exposes an unmodifiable `ObservableList<Entry>` that can be 'observed' e.g. the UI can be bound to this list so that the UI automatically updates when the data in the list change.
* does not depend on any of the other three components.

.Structure of the Model Component in Itinerary
image::ItineraryModelDiagram.png[align=""center""]

The `Model` for `ITINERARY`,
*API* : link:https://github.com/AY1920S2-CS2103T-F09-4/main/blob/master/src/main/java/seedu/volant/commons/model/Model.java[`Model.java`]

* stores a `UserPref` object that represents the user's preferences.
* stores an `Activity` 's data.
* exposes an unmodifiable `ObservableList<Activity>` that can be 'observed' e.g. the UI can be bound to this list so that the UI automatically updates when the data in the list change.
* does not depend on any of the other three components.


[[Design-Storage]]
=== Storage component

.Structure of the Storage Component
image::StorageClassDiagram.png[align=""center""]

*API* : link:https://github.com/AY1920S2-CS2103T-F09-4/main/blob/master/src/main/java/seedu/volant/commons/storage/Storage.java[`Storage.java`]

The `Storage` component,

* can save `UserPref` objects in json format and read it back.
* can save the `LMNList` data in json format and read it back.

[[Design-Commons]]
=== Common classes

Classes used by multiple components are in the `seedu.volant.commons` package.

== Implementation

This section describes some noteworthy details on how certain features are implemented.

[[implementation-view-switching]]
=== View Switching for Navigation Commands
The entire process of view switching is executed in the `MainWindow.java` class.

[TIP]
====
*List of Navigation Commands*

* `goto` on the `HOME` page
* `goto` on the `TRIP` page
* `back`
* `home`
====

==== Implementation
Each `CommandResult` from an execution in the `MainWindow` class stores data on
*if a command is a navigation command or not, and which navigation command it is.* If the command is a navigation command, the `MainWindow` will execute the
appropriate functions to facilitate view switching.

In the view switching process, the `MainWindow` will do the following: +

. Switch the logic component of the program to the logic component of the next page
. Switch the model component of the program to the model component of the next page
. Switch the current storage of the program to the storage component of the next page
. Load the GUI components for the next page

For example, for the `back` command, the `MainWindow`:

.Activity diagram for view switching process in `MainWindow` for `back` command
image::back-activity-diagram.png[]

==== Design Considerations
Pros: +

* As each page has its own components, the back end of the program is neater and better abstracted.
* Specialised logic components for each page allow for the same keywords to be used (e.g `add`, `delete`) on certain
pages.

Cons: +

* There are many steps to switching views
* If there are more pages, there will be many logic and model components to keep track of.

==== Special Cases
* When `back` command is used in the <<root-page>>, this would not have any effect on the current GUI being
displayed.
* When the `home` command is used in the <<root-page>>, this would not have any effect on the current GUI being
displayed as the user is already on the HOME page.


=== Specific Help Windows for different pages
==== Implementation
Each page in Volant has its own `{Page}HelpWindow` class.
<<implementation-view-switching, Upon switching views>>, the `MainWindow` will create a new `{Page}HelpWindow` containing
details of the commands that can be used on that page.

==== Design Considerations
===== Aspect: Syntax of the find command
* **Alternative 1 (current choice):**
Help Window specifically details the commands that can be used on the page that the user is currently on.
** Pros: Very specific and allows added convenience for users when they want to use commands with many fields that they
cannot remember without having to refer to the User Guide.
** Cons: Every single page has to have its own class file for the Help Window, if there are many pages, there will be many files to keep track of.
* **Alternative 2:** Use a general Help Window that lists every single command for every page in Volant
** Pros: Only one Help Window class file needed and it is easy to implement.
** Cons: If all the commands are detailed on a single long Help Window, the user will have to inconveniently scroll through
the window to reach the section that details commands for the page that they are on.




=== Adding a trip in Home Page
==== Implementation
Adding a trip

The add trip feature allows user to add a trip to Volant. This feature is facilitated by `HomeInputParser`, `AddCommandParser`, and `AddCommand`.

Given below is an example usage scenario and how the trip add mechanism behaves at each step:

1. The user executes the add command in `HOME` page and provides the required metadata in the correct format to be added.
2. `HomeInputParser` parses the input by the user to check if the input provided contains a valid command keyword.
3. `AddCommandParser` parses the remaining input by the user for metadata denoted with prefixes.
4. `AddCommandParser` checks if the metadata input by the user is in the desired format.
5. `AddCommandParser` creates a new `AddCommand` based on the metadata provided.
6. `HomeLogicManager` executes the `AddCommand`.
7. `HomeModelManager` checks if the new `TRIP` has any logical conflicts with existing `TRIP`(s)
8. `HomeModelManager` adds the module to the `UniqueTripList`.
9. A new folder with the `TRIP` name is created.
10. `HomeLogicManager` updates storage with updated `UniqueTripList`.
11. `MainWindow` receives `CommandResult` from `HomeLogicManager` containing success message to be displayed to user.
12. Trips displayed in `MainWindow` are updated and `MainWindow` displays success message.

The following activity diagram summarises what happens when a user executes a add trip command:

.Activity Diagram for `add` Command
image::AddTripActivityDiagram.png[align=""center""]

==== Design Considerations

===== Aspect: How data is stored
* **Alternative 1 (current choice):** Saves the trip details in main volant json folder and create a folder corresponding to `TRIP` name.
** Pros: Easy to implement.
** Cons: Less organised as all trip details are stored in one location. Any error in the way one trip is stored will cause all trips not to be loaded.
* **Alternative 2:** Create a individual json file for each trip details.
** Pros: An error in the file of one trip will not affect the loading of other trips.
** Cons: Harder to implement retrieval.

=== Sorting entries in Journal Page
==== Implementation
Sorting journal entries
The sort feature allows user to sort the entries in the `JOURNAL` of a trip. This feature is facilitated by `JournalInputParser`, `SortCommandParser`, and `SortCommand`.

Given below is an example usage scenario and how the journal sort mechanism behaves at each step:

1. The user executes the sort command in `JOURNAL` page and provides a field which they want the entries to be sorted by.
2. `JournalInputParser` parses the input by the user to check if the input provided contains a valid command keyword.
3. `SortCommandParser` parses the remaining input by the user for field.
4. `SortCommandParser` checks if the field input by the user is a valid field to sort by.
5. `SortCommandParser` creates a new `SortCommand` based on the field provided.
6. `JournalLogicManager` executes the `SortCommand`.
7. `JournalModelManager` sorts the entries according to the input field.
8. `JournalLogicManager` updates storage with updated `UniqueEntryList`.
9. `MainWindow` receives `CommandResult` from `HomeLogicManager` containing success message to be displayed to user.
10. Jounral entries displayed in `MainWindow` are updated and `MainWindow` displays success message.

The following activity diagram summarizes what happens when a user executes a sort journal command:

.Activity Diagram for `sort` Command
image::sortActivityDiagram.png[align=""center""]]

=== Adding activities in Itinerary Page
==== Implementation
Adding an activity

The add activity feature allows user to add an activity to a current trip. This feature is faciliated by `ItineraryInputParser`, `AddCommandParser`, and `AddCommand`.

Given below is an example usage scenario and how the activity add mechanism behaves at each step:

1. The user executes the add command in `ITINERARY` page and provides the required metadata in the correct format to be added.
2. `ItineraryInputParser` parses the input by the user to check if the input provided contains a valid command keyword.
3. `AddCommandParser` parses the remaining input by the user for metadata denoted with prefixes.
4. `AddCommandParser` checks if the metadata input by the user is in the desired format.
5. `AddCommandParser` creates a new `AddCommand` based on the metadata provided.
6. `ItineraryLogicManager` executes the `AddCommand`.
7. `ItineraryModelManager` checks if the new `ACTIVITY` has any logical conflicts with existing `ACTIVITY`(s)
8. `ItineraryModelManager` adds the activity to the `UniqueActivityList`.
9. The `itinerary.json` file in the current trip folder in storage is updated
10. `ItineraryLogicManager` updates storage with updated `UniqueActivityList`.
11. `MainWindow` receives `CommandResult` from `ItineraryLogicManager` containing success message to be displayed to user.
12. Activities displayed in `MainWindow` are updated and `MainWindow` displays success message.

The following activity diagram summarizes what happens when a user executes a add activity command:

.Activity Diagram for `add` Command
image::AddActivity.png[align=""center""]]

==== Design Considerations

===== Aspect: Prerequisite of the command
Since each trip is associated with one itinerary, when the user wants to use the add activity command, a trip must have already been created. This is why the order of the scence switching is important as it disallows user to create an activity that is not associated with any trip.


=== Finding activities in Itinerary Page
==== Implementation
Finding an activity

The find activity feature allows user to find one or several activities in the current trip with matching keywords provided. This feature is faciliated by `ItineraryInputParser`, `FindCommandParser`, and `FindCommand`.

Given below is an example usage scenario and how the activity find mechanism behaves at each step:

1. The user executes the find command in `ITINERARY` page and provides one or several field(s) which they want to be displayed with the current keyword.
2. `ItineraryInputParser` parses the input by the user to check if the input provided contains a valid command keyword.
3. `FindCommandParser` parses the remaining input by the user for fields to be found.
4. `FindCommandParser` checks if the field input by the user is a valid field to find.
5. `FindCommandParser` creates a new `FindCommand` based on the fields provided.
6. `ItineraryLogicManager` executes the `FindCommand`.
7. A new find predicate is created to check for matching keyword from the current list of activities.
8. `ItineraryModelManager` checks the current `UniqueActivityList` to find activities with matching keywords provided based on the predicate created.
9. `ItineraryModelManager` updates the activities that matched in the `FilteredActivityList`.
10. `MainWindow` receives `CommandResult` from `ItineraryLogicManager` containing success message to be displayed to user.
11. Jounral entries displayed in `MainWindow` are updated and `MainWindow` displays success message.

The following activity diagram summarizes what happens when a user executes a find activity command:

.Activity Diagram for `find` Command
image::FindItinerary.png[align=""center""]]

==== Design Considerations

===== Aspect: Syntax of the find command
* **Alternative 1 (current choice):** Users are allowed to find according to specific fields. This is done by adding the prefixes(t/ for `title`, l/ for `location`, d/ for `date`, and t/ for `time`) before the keyword to be found
** Pros: Allows users to be very specific in the find command. This means that users can find activities with the keywords in the specific field that they want. This implementation also allows users to append one find command with multiple fields to narrow down the search in less steps.
** Cons: Cannot find the same keyword for multiple fields. The current implementation can also cause the CLI by the users to be longer as there is a need to specify the fields to find. Furthermore, this implementation is more troublesome to implement.
* **Alternative 2:** Users can find with one or a few keywords without the need to specify the fields.
** Pros: The commands would be a lot shorter and easy to use. This allows for cross-field search which is not possible with the current implementation. This implementation is also easier to implement.
** Cons: This makes it difficult to narrow down the search if the users want to be specific about which field the keyword is in. The current implementation allows for greater freedom in choosing the fields to search for, something this implementation would not be able to accomplish. Furthermore, as `date` and `time` have different format from `location` and `title`, the specified field would make it easier for users to search for activities with the same `date` or `time`.

The following activity diagram summarises what happens when a user executes a sort journal command:

.Activity Diagram for `sort` Command
image::SortActivityDiagram.png[align=""center""]

=== Deleting Trip in Home Page

==== Implementation

The delete trip feature allows user to delete a trip in Volant. This feature is faciliated by `HomeInputParser`, `DeleteCommandParser`, and `DeleteCommand`.

Given below is an example usage scenario and how the delete mechanism behaves at each step:

1. The user executes the delete command in `HOME` page and provides the desired index for deletion.
2. `HomeInputParser` parses the input by the user to check if the input provided contains a valid command keyword.
3. `DeleteCommandParser` parses the remaining input by the user for the index.
4. `DeleteCommandParser` checks if the index provided is valid; at most the number of trips in the list.
5. `DeleteCommandParser` creates a new `DeleteCommand` with the index provided.
6. `HomeLogicManager` executes the `DeleteCommand`.
7. `The trip folder in the file path along with its contents are deleted during execution.
8. `HomeModelManager` updates the `UniqueTripList`.
9. `HomeLogicManager` updates storage with updated `UniqueTripList`.
10. `MainWindow` receives `CommandResult` from `HomeLogicManager` containing success message to be displayed to user.
11. Trips displayed in `MainWindow` are updated and `MainWindow` displays success message.

The following activity diagram summarises what happens when a user executes an add activity command:

.Activity Diagram for `delete` Command
image::deleteTripActivityDiagram.png[align=""center""]]

==== Design Considerations

===== Aspect: How to delete the trip
Since each trip is a folder containing the data of the trip's itinerary and journal. If the trip is deleted, the corresponding itinerary and journal json files should also be deleted. This prevents unnecessary files from being stored in the program.

=== Adding an activity in Itinerary Page

==== Implementation

The add activity feature allows user to add an activity to a current trip. This feature is faciliated by `ItineraryInputParser`, `AddCommandParser`, and `AddCommand`.

Given below is an example usage scenario and how the activity add mechanism behaves at each step:

1. The user executes the add command in `ITINERARY` page and provides the required metadata in the correct format to be added.
2. `ItineraryInputParser` parses the input by the user to check if the input provided contains a valid command keyword.
3. `AddCommandParser` parses the remaining input by the user for metadata denoted with prefixes.
4. `AddCommandParser` checks if the metadata input by the user is in the desired format.
5. `AddCommandParser` creates a new `AddCommand` based on the metadata provided.
6. `ItineraryLogicManager` executes the `AddCommand`.
7. `ItineraryModelManager` checks if the new `ACTIVITY` has any logical conflicts with existing `ACTIVITY`(s)
8. `ItineraryModelManager` adds the activity to the `UniqueActivityList`.
9. The `itinerary.json` file in the current trip folder in storage is updated
10. `ItineraryLogicManager` updates storage with updated `UniqueActivityList`.
11. `MainWindow` receives `CommandResult` from `ItineraryLogicManager` containing success message to be displayed to user.
12. Activities displayed in `MainWindow` are updated and `MainWindow` displays success message.

The following activity diagram summarises what happens when a user executes an add activity command:

.Activity Diagram for `add` Command
image::AddActivity.png[align=""center""]]

==== Design Considerations

===== Aspect: Prerequisite of the command
Since each trip is associated with one itinerary, when the user wants to use the add activity command, a trip must have already been created. This is why the order of the scence switching is important as it disallows user to create an activity that is not associated with any trip.


=== Finding activities in Itinerary Page
==== Implementation
The find activity feature allows user to find one or several activities in the current trip with matching keywords provided. This feature is faciliated by `ItineraryInputParser`, `FindCommandParser`, and `FindCommand`.

Given below is an example usage scenario and how the activity find mechanism behaves at each step:

1. The user executes the find command in `ITINERARY` page and provides one or several field(s) which they want to be displayed with the current keyword.
2. `ItineraryInputParser` parses the input by the user to check if the input provided contains a valid command keyword.
3. `FindCommandParser` parses the remaining input by the user for fields to be found.
4. `FindCommandParser` checks if the field input by the user is a valid field to find.
5. `FindCommandParser` creates a new `FindCommand` based on the fields provided.
6. `ItineraryLogicManager` executes the `FindCommand`.
7. A new find predicate is created to check for matching keyword from the current list of activities.
8. `ItineraryModelManager` checks the current `UniqueActivityList` to find activities with matching keywords provided based on the predicate created.
9. `ItineraryModelManager` updates the activities that matched in the `FilteredActivityList`.
10. `MainWindow` receives `CommandResult` from `ItineraryLogicManager` containing success message to be displayed to user.
11. Journal entries displayed in `MainWindow` are updated and `MainWindow` displays success message.

The following activity diagram summarises what happens when a user executes a find activity command:

.Activity Diagram for `find` Command
image::FindItinerary.png[align=""center""]]

==== Design Considerations

===== Aspect: Syntax of the find command
* **Alternative 1 (current choice):** Users are allowed to find according to specific fields. This is done by adding the prefixes(t/ for `title`, l/ for `location`, d/ for `date`, and t/ for `time`) before the keyword to be found
** Pros: Allows users to be very specific in the find command. This means that users can find activities with the keywords in the specific field that they want. This implementation also allows users to append one find command with multiple fields to narrow down the search in less steps.
** Cons: Cannot find the same keyword for multiple fields. The current implementation can also cause the CLI by the users to be longer as there is a need to specify the fields to find. Furthermore, this implementation is more troublesome to implement.
* **Alternative 2:** Users can find with one or a few keywords without the need to specify the fields.
** Pros: The commands would be a lot shorter and easy to use. This allows for cross-field search which is not possible with the current implementation. This implementation is also easier to implement.
** Cons: This makes it difficult to narrow down the search if the users want to be specific about which field the keyword is in. The current implementation allows for greater freedom in choosing the fields to search for, something this implementation would not be able to accomplish. Furthermore, as `date` and `time` have different format from `location` and `title`, the specified field would make it easier for users to search for activities with the same `date` or `time`.

=== Refreshing trips in Home Page

==== Implementation
The refresh feature allows user to repopulate the current page with the same data in the storage. This feature is faciliated by `HomeInputParser`, `RefreshCommandParser`, and `RefreshCommand`.

Given below is an example usage scenario and how the refresh mechanism behaves at each step:

1. The user executes the rf command in `HOME` page.
2. `HomeInputParser` parses the input by the user to check if the input provided contains a valid command keyword.
3. `FindCommandParser` creates a new `RefreshCommand`.
4. `HomeLogicManager` executes the `RefreshCommand`.
5. `MainWindow` receives `CommandResult` and success message from `HomeLogicManager`.
6. `MainWindow` checks the current page user is on and repopulates display with list from `HomeModelManager`.
7. `MainWindow` displays success message.

The following activity diagram summarises what happens when a user executes a find activity command:

.Activity Diagram for `rf` Command
image::rfActivityDiagram.png[align=""center""]]

==== Design Considerations

===== Aspect: How to get the list to repopulate the data with
After sorting or finding a list, the user needed a way to view the original data. The construction of each model includes a list that contains the relevant data in storage. Using that list, the view can be repopulated with the original data.

=== Data Storage
All data (trip details, journal entry details and itinerary details) is saved in the `main.data` directory.

==== Organisation

.Data Storage in Volant
image::user-guide/data-storage.png[align=""center""]

The data files are organised in a way that trip details are stored in `volant.json`, while journal and itinerary details
are stored in a `journal.json` file and a `itinerary.json` file respectively. Both of these data files are organised
under a directory that represents the trip that the journal and itinerary are associated with.

The following explanation provides more details about these data files:

* Within the `main.data` directory, the `volant.json` file contains a list of JSON objects, each representing a trip,
with key-value pairs identifying the trip name, location and date range.Upon creation of a trip named ""ABC"", the
`volant.json` file is updated with a new JSON object representing the trip. The `main.data.ABC` directory is also
created.

* When an activity is added to the itinerary, a `itinerary.json` file is created in the `main.data.ABC` directory,
containing a list of JSON objects, each representing an activity, with key-value pairs identifying the activity title,
location, date and time.

* When an entry is added to the journal, a `journal.json` file is created in the `main.data.ABC` directory, containing
a list of JSON objects, each representing a journal entry, with key-value pairs identifying the entry content, date,
time, location, feeling and weather.

==== Design Considerations
Pros:

* Each data file can be kept small in size.
* This allows for faster retrieval of trip/journal/itinerary information from these data files.

Cons:

* There is no single data file that provides an overview of all of a user's data.

==== Data storage implementation: Adding a new trip/activity
Given below is an example usage scenario where a user adds a new trip:

1. The user executes the add command and provides the name, location and date range.
2. A new `Trip` object is created with the specified name, location and date range.
3. In `HomeModelManager`, the `Trip` object is added to the `TripList`.
4. A new folder is created in the `main.data` directory with the specified trip name.
5. `HomeLogicManager` accesses the `volant.json` file in the `main.data` directory.
6. Each `Trip` object in the `TripList` is converted into a `JsonAdaptedTrip` object.
7. A new `JsonSerializableTripList` object is created with the `JsonAdaptedTrip` objects.
8. The new `JsonSerializableTripList` object is saved to the `volant.json` data file.
9. The program log displays a success message.

The following activity diagram summarises what happens when a user adds a new trip:

.Activity diagram for adding a new trip
image::addTripStorageActivityDiagram.png[align=""center""]

The process is similar for the scenario where the user adds a new activity to the itinerary, and the `itinerary.json`
data file is updated. The following activity diagram summarises this process:

.Activity diagram for adding a new activity
image::addActivityStorageActivityDiagram.png[align=""center""]

==== Data storage implementation: Editing a trip
Given below is an example usage scenario where a user edits a trip:

1. The user executes the edit command and provides the updated details.
2. `HomeLogicManager` checks if the name of the trip was updated. If it was, a new directory will be created with the
new trip name. Data files in the previous folder are moved into this new folder. Following that, the old folder is
deleted.
3. `HomeLogicManager` accesses the `volant.json` file in the `main.data` directory.
4. Each `Trip` object in the `TripList` is converted into a `JsonAdaptedTrip` object.
5. A new `JsonSerializableTripList` object is created with the `JsonAdaptedTrip` objects.
6. The new `JsonSerializableTripList` object is saved to the `volant.json` data file.
7. The program log displays a success message.

The following activity diagram summarises what happens when a user edits a trip:

.Activity diagram for editing a trip
image::editTripStorageActivityDiagram.png[align=""center""]

==== Data storage implementation: Deleting a journal entry/itinerary activity
Given below is an example usage scenario where a user deletes a journal entry:

1. The user executes the delete command.
2. In `JournalModelManager`, the identified `Entry` is removed from the `EntryList`.
3. `JournalLogicManager` accesses the `journal.json` file in the specific trip directory.
4. Each remaining `Entry` object in the `EntryList` is converted into a `JsonAdaptedEntry` object.
5. A new `JsonSerializableEntryList` object is created with the `JsonAdaptedEntry` objects.
6. The new `JsonSerializableEntryList` object is saved to the `journal.json` data file.
7. The program log displays a success message.

This process is the same for scenarios where the user deletes an itinerary activity. The following activity diagram
summarises what happens when a user deletes a journal entry or itinerary activity:

.Activity diagram for deleting a journal entry/itinerary activity
image::deleteStorageActivityDiagram.png[align=""center""]

=== Logging

We are using `java.util.logging` package for logging. The `LogsCenter` class is used to manage the logging levels and logging destinations.

* The logging level can be controlled using the `logLevel` setting in the configuration file (See <<Implementation-Configuration>>)
* The `Logger` for a class can be obtained using `LogsCenter.getLogger(Class)` which will log messages according to the specified logging level
* Currently log messages are output through: `Console` and to a `.log` file.

*Logging Levels*

* `SEVERE` : Critical problem detected which may possibly cause the termination of the application
* `WARNING` : Can continue, but with caution
* `INFO` : Information showing the noteworthy actions by the App
* `FINE` : Details that is not usually noteworthy but may be useful in debugging e.g. print the actual list instead of just its size

[[Implementation-Configuration]]
=== Configuration

Certain properties of the application can be controlled (e.g user prefs file location, logging level) through the configuration file (default: `config.json`).

== Documentation

Refer to the guide <<Documentation#, here>>.

== Testing

Refer to the guide <<Testing#, here>>.

== Dev Ops

Refer to the guide <<DevOps#, here>>.

[appendix]
== Product Scope

*Target user profile*:

* is a solo traveller
* prefers desktop apps over other types
* can type fast
* prefers typing over mouse input
* is reasonably comfortable using CLI apps

*Value proposition*: convenient travel assistant to for solo travelers who are always on their feet.

[appendix]
== User Stories

*Priorities*

* High (must have) - `* * *`
* Medium (nice to have) - `* *`
* Low (not useful) - `*`

[width=""80%"",cols=""22%,<23%,<25%,<30%"",options=""header"",]
|=======================================================================
|Priority |As a ... |I want to ... |So that I can ...
|`* * *` | frequent traveler | add a travel entry with weather, location and time metadata | document my past travels

|`* * *` | traveler always on the go | record short text entries recording my travels, similar to that of a Tweet on Twitter | can keep track of my activities without excessive typing

|`* * *` |user |add an activity into an itinerary list |see my planned activities at a glance and better plan my trip

|`* * *` |user |tag a location to each activity in the itinerary |view where each activity is taking place

|`* * *` |user |edit the entries in my itinerary list |amend any mistakes when entering data, or change my travel plans

|`* * *` |user |see a chronological timeline of the activities in the itinerary |have a clear idea of my travel plans and schedule

|`* * *` |user |view my itinerary and journal separately |view them in a less cluttered manner

|`* * *` |frequent traveler |see a record of all my past itineraries |can review my past travels

|`* * *` |traveler always meeting new people overseas |add a contact that I met during my trip with metadata including their name, age, phone number, location where I met them, and their country of origin |can keep in contact with them

|`* * *` |user |delete contacts |get rid of contacts that I have not been in touch with for some time

|`* * *` |user |view my itineraries, contact lists and journals specific to the trip they are relevant to |effectively plan for multiple trips simultaneously

|`* * *` |user |customize trip names |distinguish between different trips that happen in the same location within similar date ranges

|`* *` |frequent traveler |to be able to see a timeline view of all my short journal entries and photos, including the location and time of the photos and entries, per trip |relieve the memories of the trip in its original sequence

|`* *` |food lover |add a meal with description, photo, price and location |keep track of what I ate

|`* *` |user |sort my travel entries by category depending on the ‘feeling’ tag of each travel entry |see my best moments

|`* *` |user |record items in a packing list|remind myself what I will need on a trip

|`* *` |busy user |list |easily reference what I need for a trip at a glance

|`* *` |fickle-minded user |delete packing list entries |remove items I feel I no longer need for the trip from the packing list

|=======================================================================

_{All user stories can be viewed in our issue tracker.}_

[appendix]
== Use Cases

(For all use cases below, the *System* is `Volant (V)` and the *Actor* is the `user`, unless specified otherwise)

[discrete]
=== UC01 - Adding New Trip

**Precondition: **Start from home page

*Guarantee:* A new Trip will be created

*<<mss, MSS>>*

1. User enters details of trip to be added
2. V adds new trip to trip list
+
Use case ends

*<<extensions, Extensions>>*

[none]
* 1a. V detects invalid characters in trip details
* 1a1. V outputs error informing user of invalid command
+
Use case ends

[none]
* 1b. V detects missing fields in trip details
* 1b1. V outputs error informing user of missing fields
+
Use case ends

[none]
* 1c. V detects that trip has a clashing date range with another trip on the trip list
* 1c1. V outputs error informing user of clashing date range between trip and another trip on the list
+
Use case ends

[none]
* 1d. V detects that trip has the same name as another trip on the trip list
* 1d1. V outputs error informing user that the trip already exists on the trip list
+
Use case ends

[none]
* 1e. V is unable to detect a valid command keyword
* 1e1. V outputs error informing user of invalid command
+
Use case ends

[discrete]
=== UC02 - Editing Existing Trip

**Precondition: **User is in the home page

**Guarantee: **Metadata of existing trip will be changed

*MSS*

1. User inputs command to edit an existing trip
2. V updates metadata of corresponding trip according to user input
3. Trip list is updated and the changes are reflected for user to see
+
Use case ends

*Extensions*

[none]
* 1a. V is unable to detect any specified fields to edit
* 1a1. V outputs error informing user that a field to edit must be specified
+
Use case ends

[none]
* 1b. V detects an invalid index i.e. index out of range or negative index
* 1b1. V outputs error informing user of invalid index specified
+
Use case ends

[none]
* 1c. V detects invalid characters for the fields
* 1c1. V outputs error informing user of invalid command
+
Use case ends

[none]
* 1d. V is unable to detect a valid command keyword
* 1d1. V outputs error informing user of invalid command
+
Use case ends

[discrete]
=== UC03 - Navigating to Trip Page

*Precondition:* User has added a trip

*Guarantee:* User will be moved to the Trip page

*MSS*

1. User changes directory to specific trip folder in trip list using index
2. V loads and displays trip page
+
Use case ends

*Extensions*

[none]
* 1a. V detects an invalid index i.e. index out of range or negative index
* 1a1. V outputs error informing user of invalid index specified
+
Use case ends

[none]
* 1b. V is unable to detect a valid command keyword
* 1b1. V outputs error informing user of invalid command
+
Use case ends

[discrete]
=== UC04 - Accessing Trip Feature Pages (Itinerary / Journal)

*Precondition:* User is in the home page

*Guarantee:* User will be moved to the desired page

*MSS*

1. User navigates to a specific trip (UC03)
2. User requests to navigate to the desired page in current trip
3. V loads and displays the desired page
+
Use case ends

*Extensions*

[none]
* 2a. V detects invalid field to navigate to the page
* 2a1. V outputs error informing user of invalid command
+
Use case ends

[none]
* 2b. V is unable to detect a valid command keyword
* 2b1. V outputs error informing user of invalid command
+
Use case ends

[discrete]
=== UC05 - Adding a travel Entry into Journal of a Trip

**Precondition: **User is already in the Journal page of Trip

**Guarantee: **A new travel entry will be added to the Travel Journal

*MSS*

1. User enters details of the travel entry
2. V confirms successful entry and displays new entry in the journal
+
Use case ends

*Extensions*

[none]
* 1a. V detects invalid characters in travel entry
* 1a1. V outputs error informing user of invalid command
+
Use case ends

[none]
* 1b. V detects missing fields in travel entry
* 1b1. V outputs error informing user of missing travel entry
+
Use case ends

[none]
* 1c. V is unable to detect a valid command keyword
* 1c1. V outputs error informing user of invalid command
+
Use case ends

[none]
* 1d. V detects that text field is greater 280 characters long
* 1d1. V outputs error informing user of character limit and how many characters over the limit their input was
+
Use case ends


[discrete]
=== UC06 - Adding Activities into Itinerary

**Precondition: **User is already in the Itinerary page of the Trip

**Guarantee: **A new activity will be added to the Itinerary

*MSS*

1. User enters details of activity
2. V confirms successful entry and displays updated itinerary
+
Use case ends

*Extensions*

[none]
* 1a. V detects invalid characters into activity entry
* 1a1. V outputs error informing user of invalid command
+
Use case ends

[none]
* 1b. V detects missing fields in activity entry
* 1b1. V outputs error informing user of missing activity entry
+
Use case ends

[none]
* 1c. V is unable to detect a valid command keyword
* 1c1. V outputs error informing user of invalid command
+
Use case ends

[discrete]
=== UC07 - Editing Existing Journal Entry

**Precondition: **User is on the Journal page and has added one or more entries already

**Guarantee: **Metadata of an existing entry will be changed

*MSS*

1. User inputs command to edit an entry
2. V updates metadata of corresponding entry according to user input
3. Entry list is updated and the changes are reflected for user to see
+
Use case ends

*Extensions*

[none]
* 1a. V is unable to detect any specified fields to edit
* 1a1. V outputs error informing user that a field to edit must be specified
+
Use case ends

[none]
* 1b. V detects incorrect date or time format
* 1b1. V outputs error informing user that the acceptable format for date and time input
+
Use case ends

[none]
* 1c. V detects an invalid index i.e. index out of range or negative index
* 1c1. V outputs error informing user of invalid index specified
+
Use case ends

[none]
* 1d. V detects invalid characters for the fields
* 1d1. V outputs error informing user of invalid command
+
Use case ends

[none]
* 1e. V is unable to detect a valid command keyword
* 1e1. V outputs error informing user of invalid command
+
Use case ends

[discrete]
=== UC08 - Editing Existing Activity
**Precondition: **User is on the Itinerary page and has added one or more activities already

**Guarantee: **Metadata of an existing activity will be changed

*MSS*

1. User inputs command to edit an activity.
2. V updates metadata of corresponding activity according to user input
3. Activity list is updated and the changes are reflected for user to see
+
Use case ends

*Extensions*

[none]
* 1a. V is unable to detect any specified fields to edit
* 1a1. V outputs error informing user that a field to edit must be specified
+
Use case ends

[none]
* 1b. V detects incorrect date or time format
* 1b1. V outputs error informing user that the acceptable format for date and time input
+
Use case ends

[none]
* 1c. V detects an invalid index i.e. index out of range or negative index
* 1c1. V outputs error informing user of invalid index specified
+
Use case ends

[none]
* 1d. V detects invalid characters for the fields
* 1d1. V outputs error informing user of invalid command
+
Use case ends

[none]
* 1e. V is unable to detect a valid command keyword
* 1e1. V outputs error informing user of invalid command
+
Use case ends

[discrete]
=== UC09 - Sorting Journal Entries
**Precondition: **User is on the Journal page and has added one or more entries already

**Guarantee: **Entry list will be sorted

*MSS*

1. User inputs sort command
2. V sorts the entry list according to user's input
3. Entry list is updated and the sorted list is displayed to the user
+
Use case ends

Extensions
[none]
* 1a. V does not detect an argument for sort type in user's input
* 1a1. V outputs error message informing user to include a sort type
+
Use case ends

[none]
* 1b. V detects invalid characters for the sort type input
* 1b1. V outputs error informing user of invalid sort type
+
Use case ends

[none]
* 1c. V is unable to detect a valid command keyword
* 1c1. V outputs error informing user of invalid command
+
Use case ends

[discrete]
=== UC10 - Finding Itinerary Activities
**Precondition: **User is on the Itinerary page and has added one or more activities already

**Guarantee: **Activity list containing matching search terms is displayed

*MSS*

1. User inputs find command
2. V checks the activity list for activities with metadata that matches the given search term(s)
3. V outputs an activity list containing all the activities matching the given search term(s)
+
Use case ends

Extensions
[none]
* 1a. V does not find any activities that match the given search term(s)
* 1a1. V outputs message informing user that no matching activities were found
+
Use case ends

[none]
* 1b. V detects invalid characters for the given search term(s)
* 1b1. V outputs error informing user of invalid command
+
Use case ends

[none]
* 1c. V is unable to detect a valid command keyword
* 1c1. V outputs error informing user of invalid command
+
Use case ends


[appendix]
== Non Functional Requirements

.  Volant should work on any <<mainstream-os,mainstream OS>> as long as it has Java `11` or above installed.
.  Volant should work without any internet connection.
.  Volant should be able to hold up to 100 trips without noticing a increase in response time from the system for typical usage.
.  A user who is able to type above 40 words per minute (wpm) for regular English text (i.e. not code, not system admin commands) should be able to accomplish most of the tasks faster using commands than using the mouse.
.  Commands should be <<one-shot-c,one-shot>> commands as opposed to <<multi-level-c, multi-level commands>>.
.  A user should have minimum 100 Megabytes (MB) free disk space on their computer to store the program.
.  Input by the user should only be in English.
.  Volant source code should be covered by tests as much as possible.
.  Volant should work for a single user only.

[appendix]
== Glossary

[[extensions]] Extensions::
""add-on""s to the MSS that describe exceptional/alternative flow of events.

[[mainstream-os]] Mainstream OS::
Windows, Linux, Unix, OS-X

[[mss]] MSS::
Main Success Scenario

[[multi-level-c]] Multi-level Commands::
Commands that require multiple lines of user input for execution.

[[root-page]] Root Page::
The first page the shows up when Volant is opened. By default, this is the `HOME` page.

[[one-shot-c]] One-shot Commands::
Commands that are executed using only a single line of user input.

[appendix]
== Product Survey

*Volant*

Author: Team Volant

Pros::

* The product is effective in assisting solo travellers to plan and execute their trips.
* GUI is very aesthetic looking, pleasing to the eyes.
* The available commands are intuitive, and are easy to use and remember.

Cons::

* The fremium model proposed can be a bit expensive.
* A dark mode can be included. Some users prefer a GUI with dark mode.
* More features can be integrated. These features can be included in version 2.0.

[appendix]
== Instructions for Manual Testing

Given below are instructions to test the app manually.

[NOTE]
These instructions only provide a starting point for testers to work on; testers are expected to do more _exploratory_ testing.

=== Launch and Shutdown

. Initial launch

.. Download the jar file and copy into an empty folder.
.. Double-click the jar file. +
   Expected: Shows the GUI with a set of sample contacts. The window size may not be optimum.

. Saving window preferences

.. Resize the window to an optimum size. Move the window to a different location. Close the window.
.. Re-launch the app by double-clicking the jar file. +
   Expected: The most recent window size and location is retained.

=== Adding

. Adding a `TRIP` to an empty or populated trip list

.. Prerequisites: NA
.. Test case: `add n/Bali 2020 l/Bali d/02-01-2020 to 02-05-2020`
.. Expected: `TRIP` with corresponding details is added to trip list.
.. Test case: `add n/Bali 2020 l/Bali d/2020-01-02 to 2020-05-02`
.. Expected: No `TRIP` added. Error details shown in status message.

=== Deleting

. Deleting a `TRIP` while all `TRIPS` are listed

.. Prerequisites: List all `TRIPS` using the `list` command. Multiple `TRIPS` are present in the list.
.. Test case: `delete 1` +
   Expected: First contact is deleted from the list. Details of the deleted `TRIP` are shown in the status message. Timestamp in the status bar is updated.
.. Test case: `delete 0` +
   Expected: No `TRIP` is deleted. Error details shown in the status message. Status bar remains the same.
.. Other incorrect delete commands to try: `delete`, `delete x` (where x is larger than the list size)  +
   Expected: Similar to previous.

. Deleting an `activity` in the `ITINERARY`

.. Prerequisites: A `TRIP` has already been created.
.. Test case: `delete 1` +
Expected: First `activity` is deleted from the `activity` list of the `ITINERARY` of the current `TRIP`. Current `activity` list is updated.
.. Test case: `delete 0` +
Expected: No `activity` is deleted. Error details shown in the status message.
.. Test case: `delete a` +
Expected: No `activity` is deleted. Error details shown in the status message.
.. Other incorrect delete commands to try: `delete`, `delete x` (where x is larger than the itinerary size) +
Expected: Similar to previous.

. Deleting an `entry` in the `JOURNAL`

.. Prerequisites: A `TRIP` has already been created.
.. Test case: `delete 1` +
Expected: First `entry` is deleted from the `JOURNAL` of the current `TRIP`. Current `entry` list is updated.
.. Test case: `delete 0` +
Expected: No `entry` is deleted. Error details shown in the status message
.. Other incorrect delete commands to try: `delete`, `delete x` (where x is larger than the journal size) +
Expected: Similar to previous.

=== Saving data

. Dealing with missing/corrupted data files

.. _{explain how to simulate a missing/corrupted file and the expected behavior}_

",12535,False,2015.1323348767855,median
"/*
 * Copyright (c) 2016, Ford Motor Company
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 *
 * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following
 * disclaimer in the documentation and/or other materials provided with the
 * distribution.
 *
 * Neither the name of the Ford Motor Company nor the names of its contributors
 * may be used to endorse or promote products derived from this software
 * without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS""
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdint.h>
#include <fstream>
#include <string>
#include <vector>

#include ""gtest/gtest.h""

#include ""policy/policy_manager_impl_test_base.h""
#include ""policy/policy_table/types.h""

#include ""json/reader.h""
#include ""utils/date_time.h""
#include ""utils/gen_hash.h""

namespace test {
namespace components {
namespace policy_test {

using ::testing::_;
using ::testing::Return;
using ::testing::ReturnRef;

TEST_F(PolicyManagerImplTest,
       DISABLED_TiggerPTUForNaviAppInCaseNoCertificateExistsInPolicyTable) {
  EXPECT_CALL(*cache_manager_, GetDeviceConsent(_))
      .WillOnce(Return(kDeviceAllowed));
  const uint32_t type = 0;
  const uint32_t id = 1;
  const EntityStatus status = kStatusOn;
  ExternalConsentStatusItem item(type, id, status);

  ExternalConsentStatus external_consent_status;
  external_consent_status.insert(item);

  GroupsByExternalConsentStatus group;
  group[item].push_back(std::make_pair<std::string, bool>(""group_name"", true));

  EXPECT_CALL(*cache_manager_, GetExternalConsentStatus())
      .WillOnce(Return(external_consent_status));

  EXPECT_CALL(*cache_manager_,
              GetGroupsWithSameEntities(external_consent_status))
      .WillOnce(Return(group));

  EXPECT_CALL(*cache_manager_, ResetCalculatedPermissions());

  EXPECT_CALL(*cache_manager_, GetPermissionsForApp(_, _, _))
      .WillOnce(Return(true))
      .WillOnce(Return(true));
  EXPECT_CALL(*cache_manager_, GetFunctionalGroupNames(_))
      .WillOnce(Return(true))
      .WillOnce(Return(true));

  EXPECT_CALL(*cache_manager_, SetUserPermissionsForApp(_, _))
      .WillOnce(Return(false));

  EXPECT_CALL(*cache_manager_, SetExternalConsentForApp(_));

  EXPECT_CALL(*cache_manager_, IsPredataPolicy(_)).WillOnce(Return(false));
  EXPECT_CALL(*cache_manager_, IsApplicationRepresented(_))
      .WillOnce(Return(true));
  EXPECT_EQ(policy_manager_->GetPolicyTableStatus(), ""UP_TO_DATE"");
  policy_manager_->AddApplication(kDefaultDeviceMacAddress,
                                  kDefaultId,
                                  HmiTypes(policy_table::AHT_DEFAULT));
  EXPECT_EQ(policy_manager_->GetPolicyTableStatus(), ""UP_TO_DATE"");
}

TEST_F(PolicyManagerImplTest2, GetNotificationsNumberAfterPTUpdate) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);

  Json::Value table = createPTforLoad();
  policy_manager_->ForcePTExchange();
  policy_manager_->OnUpdateStarted();
  policy_table::Table update(&table);
  update.SetPolicyTableType(rpc::policy_table_interface_base::PT_UPDATE);
  // Act
  std::string json = table.toStyledString();
  ::policy::BinaryMessage msg(json.begin(), json.end());
  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
  EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());

  EXPECT_CALL(listener_, OnUpdateStatusChanged(_));
  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);

  std::string priority = ""EMERGENCY"";
  uint32_t notif_number = policy_manager_->GetNotificationsNumber(priority);
  EXPECT_EQ(1u, notif_number);

  priority = ""NAVIGATION"";
  notif_number = policy_manager_->GetNotificationsNumber(priority);
  EXPECT_EQ(2u, notif_number);

  priority = ""EMERGENCY"";
  notif_number = policy_manager_->GetNotificationsNumber(priority);
  EXPECT_EQ(1u, notif_number);

  priority = ""VOICECOM"";
  notif_number = policy_manager_->GetNotificationsNumber(priority);
  EXPECT_EQ(3u, notif_number);

  priority = ""NORMAL"";
  notif_number = policy_manager_->GetNotificationsNumber(priority);
  EXPECT_EQ(5u, notif_number);

  priority = ""NONE"";
  notif_number = policy_manager_->GetNotificationsNumber(priority);
  EXPECT_EQ(6u, notif_number);
}

TEST_F(PolicyManagerImplTest2, IsAppRevoked_SetRevokedAppID_ExpectAppRevoked) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);

  EXPECT_CALL(listener_, GetDevicesIds(app_id_1_))
      .WillRepeatedly(Return(transport_manager::DeviceList()));

  policy_manager_->AddApplication(
      device_id_1_, app_id_1_, HmiTypes(policy_table::AHT_DEFAULT));

  std::ifstream ifile(kValidSdlPtUpdateJson);
  Json::Reader reader;
  std::string json;
  Json::Value root(Json::objectValue);
  if (ifile.is_open()) {
    if (reader.parse(ifile, root, true)) {
      root[""policy_table""][""app_policies""][app_id_1_] = Json::nullValue;
      json = root.toStyledString();
    }
  }
  ifile.close();

  ::policy::BinaryMessage msg(json.begin(), json.end());
  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);

  EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
  CheckRpcPermissions(
      app_id_1_, ""UnregisterAppInterface"", ::policy::kRpcDisallowed);
  EXPECT_TRUE(policy_manager_->IsApplicationRevoked(app_id_1_));
}

// Related to manual test APPLINK-18792
TEST_F(PolicyManagerImplTest2, AppRevokedOne_AppRegistered) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);
  EmulatePTAppRevoked(kPtu2Json);

  EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
  ASSERT_TRUE(
      (policy_manager_->GetCache())->AddDevice(device_id_2_, ""Bluetooth""));
  policy_manager_->AddApplication(
      device_id_2_, application_id_, HmiTypes(policy_table::AHT_DEFAULT));
  // Registration is allowed
  CheckRpcPermissions(""RegisterAppInterface"", ::policy::kRpcAllowed);
}

// Related to manual test APPLINK-18794
TEST_F(PolicyManagerImplTest2, AppRevokedOne_AppRegistered_HMIDefault) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);
  EmulatePTAppRevoked(kPtu2Json);

  EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
  policy_manager_->AddApplication(
      device_id_1_, application_id_, HmiTypes(policy_table::AHT_DEFAULT));

  std::string default_hmi;
  // Default HMI level is NONE
  EXPECT_TRUE(policy_manager_->GetDefaultHmi(
      device_id_1_, application_id_, &default_hmi));
  EXPECT_EQ(""NONE"", default_hmi);
}

TEST_F(PolicyManagerImplTest2,
       CheckPermissions_SetRevokedAppID_ExpectRPCDisallowed) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);
  policy::CacheManagerInterfaceSPtr cache = policy_manager_->GetCache();
  cache->AddDevice(device_id_1_, ""Bluetooth"");
  cache->SetDeviceData(device_id_1_,
                       ""hardware IPX"",
                       ""v.8.0.1"",
                       ""Android"",
                       ""4.4.2"",
                       ""Life"",
                       2,
                       ""Bluetooth"");

  EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(_, app_id_1_))
      .Times(0);
  EXPECT_CALL(listener_, GetDevicesIds(app_id_1_))
      .WillRepeatedly(Return(transport_manager::DeviceList(1, device_id_1_)));

  policy_manager_->SetUserConsentForDevice(device_id_1_, true);
  // Add app from consented device. App will be assigned with default policies
  policy_manager_->AddApplication(
      device_id_1_, app_id_1_, HmiTypes(policy_table::AHT_DEFAULT));
  // Check before action
  policy_table::RpcParameters rpc_parameters;
  rpc_parameters.hmi_levels.push_back(policy_table::HL_FULL);

  policy_table::Rpc rpc;
  rpc[""Alert""] = rpc_parameters;

  ::policy::RPCParams input_params;
  ::policy::CheckPermissionResult output;

  policy_manager_->CheckPermissions(
      device_id_1_, app_id_1_, kHmiLevelFull, ""Alert"", input_params, output);

  // Check RPC is allowed
  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
  ASSERT_TRUE(output.list_of_allowed_params.empty());
  // Act
  std::ifstream ifile(kValidSdlPtUpdateJson);
  Json::Reader reader;
  std::string json;
  Json::Value root(Json::objectValue);
  EXPECT_TRUE(ifile.is_open());
  EXPECT_TRUE(reader.parse(ifile, root, true));
  root[""policy_table""][""app_policies""][app_id_1_] = Json::nullValue;
  json = root.toStyledString();
  ifile.close();

  ::policy::BinaryMessage msg(json.begin(), json.end());
  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);

  EXPECT_FALSE(cache->IsPTPreloaded());

  policy_manager_->CheckPermissions(
      device_id_1_, app_id_1_, kHmiLevelFull, ""Alert"", input_params, output);
  // Check RPC is disallowed
  EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
  ASSERT_TRUE(output.list_of_allowed_params.empty());
}

TEST_F(PolicyManagerImplTest2,
       CheckPermissions_SetAppIDwithPolicies_ExpectRPCAllowed) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);
  policy_manager_->AddDevice(device_id_1_, ""Bluetooth"");
  policy::CacheManagerInterfaceSPtr cache = policy_manager_->GetCache();

  ASSERT_TRUE(cache->SetDeviceData(device_id_1_,
                                   ""hardware IPX"",
                                   ""v.8.0.1"",
                                   ""Android"",
                                   ""4.4.2"",
                                   ""Life"",
                                   2,
                                   ""Bluetooth""));
  EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(_, application_id_))
      .Times(0);
  EXPECT_CALL(listener_, GetDevicesIds(application_id_))
      .WillRepeatedly(Return(transport_manager::DeviceList(1, device_id_1_)));
  policy_manager_->SetUserConsentForDevice(device_id_1_, true);
  // Add app from consented device. App will be assigned with default policies
  policy_manager_->AddApplication(
      device_id_1_, application_id_, HmiTypes(policy_table::AHT_MEDIA));
  // Emulate PTU with new policies for app added above
  std::ifstream ifile(kValidSdlPtUpdateJson);
  Json::Reader reader;
  std::string json;
  Json::Value root(Json::objectValue);
  if (ifile.is_open() && reader.parse(ifile, root, true)) {
    // Add AppID with policies
    root[""policy_table""][""app_policies""][application_id_] =
        Json::Value(Json::objectValue);
    root[""policy_table""][""app_policies""][application_id_][""memory_kb""] =
        Json::Value(50);
    root[""policy_table""][""app_policies""][application_id_]
        [""heart_beat_timeout_ms""] = Json::Value(100);
    root[""policy_table""][""app_policies""][application_id_][""AppHMIType""] =
        Json::Value(Json::arrayValue);
    root[""policy_table""][""app_policies""][application_id_][""AppHMIType""][0] =
        Json::Value(""MEDIA"");
    root[""policy_table""][""app_policies""][application_id_][""groups""] =
        Json::Value(Json::arrayValue);
    root[""policy_table""][""app_policies""][application_id_][""groups""][0] =
        Json::Value(""Base-4"");
    root[""policy_table""][""app_policies""][application_id_][""priority""] =
        Json::Value(""EMERGENCY"");
    root[""policy_table""][""app_policies""][application_id_][""default_hmi""] =
        Json::Value(""FULL"");
    root[""policy_table""][""app_policies""][application_id_][""keep_context""] =
        Json::Value(true);
    root[""policy_table""][""app_policies""][application_id_][""steal_focus""] =
        Json::Value(true);
    root[""policy_table""][""app_policies""][application_id_][""certificate""] =
        Json::Value(""sign"");
    json = root.toStyledString();
  }
  ifile.close();

  ::policy::BinaryMessage msg(json.begin(), json.end());
  // Load Json to cache
  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);

  EXPECT_FALSE(cache->IsPTPreloaded());

  policy_table::RpcParameters rpc_parameters;
  rpc_parameters.hmi_levels.push_back(policy_table::HL_FULL);

  policy_table::Rpc rpc;
  rpc[""Alert""] = rpc_parameters;
  ::policy::RPCParams input_params;
  ::policy::CheckPermissionResult output;

  cache->AddDevice(device_id_1_, ""Bluetooth"");
  cache->SetDeviceData(device_id_1_,
                       ""hardware IPX"",
                       ""v.8.0.1"",
                       ""Android"",
                       ""4.4.2"",
                       ""Life"",
                       2,
                       ""Bluetooth"");
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelFull,
                                    ""Alert"",
                                    input_params,
                                    output);
  // Check RPC is allowed
  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
  // Check list of parameters empty
  ASSERT_TRUE(output.list_of_allowed_params.empty());
}

TEST_F(PolicyManagerImplTest2,
       CheckPermissions_NoParametersInPT_CheckRpcsInDifferentLevels) {
  EXPECT_CALL(listener_, GetDevicesIds(application_id_))
      .WillRepeatedly(Return(transport_manager::DeviceList()));
  // Arrange
  AddSetDeviceData();
  LoadPTUFromJsonFile(""json/sdl_update_pt_send_location.json"");

  // Check RPC in each level
  ::policy::RPCParams input_params;
  ::policy::CheckPermissionResult output;
  // Rpc in FULL level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelFull,
                                    ""SendLocation"",
                                    input_params,
                                    output);
  // Check RPC is allowed
  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
  ASSERT_TRUE(output.list_of_allowed_params.empty());

  // Reset output
  ResetOutputList(output);

  // Rpc in LIMITED level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelLimited,
                                    ""SendLocation"",
                                    input_params,
                                    output);
  // Check RPC is allowed
  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
  ASSERT_TRUE(output.list_of_allowed_params.empty());

  ResetOutputList(output);

  // Rpc in BACKGROUND level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelBackground,
                                    ""SendLocation"",
                                    input_params,
                                    output);
  // Check RPC is allowed
  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
  ASSERT_TRUE(output.list_of_allowed_params.empty());

  ResetOutputList(output);

  // Rpc in NONE level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelNone,
                                    ""SendLocation"",
                                    input_params,
                                    output);
  // Check RPC is disallowed
  EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
  // Check list of parameters is empty
  ASSERT_TRUE(output.list_of_allowed_params.empty());
}

TEST_F(
    PolicyManagerImplTest2,
    CheckPermissions_ParamsNotAllowedInPT_AddAppWithAllParams_CheckRpcsInDiffLvls) {
  EXPECT_CALL(listener_, GetDevicesIds(application_id_))
      .WillRepeatedly(Return(transport_manager::DeviceList()));
  // Arrange
  AddSetDeviceData();
  // File have empty parameters, so they are forbidden
  LoadPTUFromJsonFile(""json/sdl_update_pt_send_location_no_params.json"");

  // Check RPC in each level
  ::policy::RPCParams input_params;
  InsertRpcParametersInList(input_params);

  ::policy::CheckPermissionResult output;
  // Rpc in FULL level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelFull,
                                    ""SendLocation"",
                                    input_params,
                                    output);

  // Group which has RPC does not require user consent, so its auto-allowed for
  // user. Since RPC 'parameters' section is present, but empty, that means
  // 'every parameter is disallowed' in case some parameter(s) will be passed
  // it will be considered as disallowed by policy (assumption, will be
  // clarified).
  EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);

  // Check list of allowed parameters is empty
  EXPECT_TRUE(output.list_of_allowed_params.empty());
  EXPECT_EQ(10u, output.list_of_undefined_params.size());
  ResetOutputList(output);

  // Rpc in LIMITED level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelLimited,
                                    ""SendLocation"",
                                    input_params,
                                    output);

  EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);

  // Check list of allowed parameters is empty
  EXPECT_TRUE(output.list_of_allowed_params.empty());
  EXPECT_EQ(10u, output.list_of_undefined_params.size());

  ResetOutputList(output);

  // Rpc in BACKGROUND level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelBackground,
                                    ""SendLocation"",
                                    input_params,
                                    output);
  // Check RPC is allowed
  EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);

  // Check list of allowed parameters is empty
  EXPECT_TRUE(output.list_of_allowed_params.empty());
  EXPECT_EQ(10u, output.list_of_undefined_params.size());

  // Reset output
  ResetOutputList(output);

  // Rpc in NONE level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelNone,
                                    ""SendLocation"",
                                    input_params,
                                    output);

  EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);

  // Check lists of parameters are  empty
  EXPECT_TRUE(output.list_of_allowed_params.empty());
  EXPECT_TRUE(output.list_of_disallowed_params.empty());
  EXPECT_TRUE(output.list_of_undefined_params.empty());
}

TEST_F(PolicyManagerImplTest2,
       CheckPermissions_SomeParamsAllowedInPT_CheckRpcsInDiffLvls) {
  EXPECT_CALL(listener_, GetDevicesIds(application_id_))
      .WillRepeatedly(Return(transport_manager::DeviceList()));
  // Arrange
  AddSetDeviceData();

  // File have some parameters, so only ""longitudeDegrees"", ""latitudeDegrees"",
  //""locationDescription"",  ""phoneNumber"" are allowed
  LoadPTUFromJsonFile(""json/sdl_update_pt_send_location_some_params.json"");

  // Check RPC in each level
  ::policy::RPCParams input_params;
  InsertRpcParametersInList(input_params);

  ::policy::CheckPermissionResult output;
  // Rpc in FULL level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelFull,
                                    ""SendLocation"",
                                    input_params,
                                    output);
  // Check RPC is allowed
  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);

  // Check list of allowed parameters is not empty
  ASSERT_FALSE(output.list_of_allowed_params.empty());
  // Check parameters that should be allowed
  CheckIsParamInList(output.list_of_allowed_params, ""longitudeDegrees"");
  CheckIsParamInList(output.list_of_allowed_params, ""latitudeDegrees"");
  CheckIsParamInList(output.list_of_allowed_params, ""locationDescription"");
  CheckIsParamInList(output.list_of_allowed_params, ""phoneNumber"");

  // Parameters that are missing in application assigned groups are considered
  // as disallowed by policy, i.e. w/o defined user consent, so they are put to
  // undefined container.
  ASSERT_FALSE(output.list_of_undefined_params.empty());
  CheckIsParamInList(output.list_of_undefined_params, ""locationName"");
  CheckIsParamInList(output.list_of_undefined_params, ""addressLines"");
  CheckIsParamInList(output.list_of_undefined_params, ""locationImage"");
  CheckIsParamInList(output.list_of_undefined_params, ""deliveryMode"");
  CheckIsParamInList(output.list_of_undefined_params, ""timeStamp"");
  CheckIsParamInList(output.list_of_undefined_params, ""address"");

  // Reset output
  output.hmi_level_permitted = ::policy::kRpcDisallowed;
  output.list_of_allowed_params.clear();
  output.list_of_undefined_params.clear();

  // Rpc in LIMITED level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelLimited,
                                    ""SendLocation"",
                                    input_params,
                                    output);
  // Check RPC is allowed
  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);

  // Check list of allowed parameters is not empty
  ASSERT_FALSE(output.list_of_allowed_params.empty());
  // Check parameters that should be allowed
  CheckIsParamInList(output.list_of_allowed_params, ""longitudeDegrees"");
  CheckIsParamInList(output.list_of_allowed_params, ""latitudeDegrees"");
  CheckIsParamInList(output.list_of_allowed_params, ""locationDescription"");
  CheckIsParamInList(output.list_of_allowed_params, ""phoneNumber"");

  ASSERT_FALSE(output.list_of_undefined_params.empty());
  EXPECT_EQ(6u, output.list_of_undefined_params.size());
  // Reset output
  ResetOutputList(output);

  // Rpc in BACKGROUND level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelBackground,
                                    ""SendLocation"",
                                    input_params,
                                    output);
  // Check RPC is allowed
  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);

  // Check parameters that should be allowed
  ASSERT_FALSE(output.list_of_allowed_params.empty());
  CheckIsParamInList(output.list_of_allowed_params, ""longitudeDegrees"");
  CheckIsParamInList(output.list_of_allowed_params, ""latitudeDegrees"");
  CheckIsParamInList(output.list_of_allowed_params, ""locationDescription"");
  CheckIsParamInList(output.list_of_allowed_params, ""phoneNumber"");

  EXPECT_FALSE(output.list_of_undefined_params.empty());
  // Reset output
  ResetOutputList(output);

  // Rpc in NONE level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelNone,
                                    ""SendLocation"",
                                    input_params,
                                    output);
  // Check RPC is disallowed
  EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
  // Check lists of parameters are  empty
  EXPECT_TRUE(output.list_of_allowed_params.empty());
  EXPECT_TRUE(output.list_of_disallowed_params.empty());
  EXPECT_TRUE(output.list_of_undefined_params.empty());
}

TEST_F(PolicyManagerImplTest2, GetUpdateUrl) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);
  GetPTU(kValidSdlPtUpdateJson);
  // Check expectations
  const std::string update_url(""http://x.x.x.x:3000/api/1/policies"");
  EXPECT_EQ(update_url, policy_manager_->GetUpdateUrl(7));
  EXPECT_EQ("""", policy_manager_->GetUpdateUrl(4));
}

// Related to manual test APPLINK-18789
TEST_F(PolicyManagerImplTest2, GetCorrectStatus_PTUSuccessful) {
  // Precondition
  CreateLocalPT(preloaded_pt_filename_);
  // Check
  EXPECT_EQ(""UP_TO_DATE"", policy_manager_->GetPolicyTableStatus());
  EXPECT_CALL(listener_, GetDevicesIds(application_id_))
      .WillRepeatedly(Return(transport_manager::DeviceList()));

  // Adding changes PT status
  policy_manager_->AddApplication(
      device_id_1_, application_id_, HmiTypes(policy_table::AHT_DEFAULT));
  EXPECT_EQ(""UP_TO_DATE"", policy_manager_->GetPolicyTableStatus());
  // Before load PT we should send notification about start updating
  policy_manager_->OnUpdateStarted();
  // Update
  GetPTU(kPtu3Json);
  EXPECT_EQ(""UP_TO_DATE"", policy_manager_->GetPolicyTableStatus());
}

TEST_F(PolicyManagerImplTest2,
       CheckPermissions_NoParamsInPT_AddAppWithAllParams_CheckRpcsInDiffLvls) {
  // File does not have parameters, so they all are permitted
  CheckPermissions_AllParamsAllowed_CheckRpcsInDiffLvls(
      ""json/sdl_update_pt_send_location.json"");
}

TEST_F(PolicyManagerImplTest2,
       CheckPermissions_AllParamsAllowedInPT_CheckRpcsInDiffLvls) {
  // File has permissions for all params
  CheckPermissions_AllParamsAllowed_CheckRpcsInDiffLvls(
      ""json/sdl_update_pt_send_location_all_params.json"");
}

TEST_F(PolicyManagerImplTest2,
       CheckPermissions_DiffParamsAllowedInGroups_CheckRpcsInDiffLvls) {
  EXPECT_CALL(listener_, GetDevicesIds(application_id_))
      .WillRepeatedly(Return(transport_manager::DeviceList()));
  // Arrange
  AddSetDeviceData();
  // Load Json to cache
  // File have 2 functional groups: SendLocation and SendLocationOnly.
  // They have different parameters.
  // Allowed both groups of parameters
  LoadPTUFromJsonFile(""json/sdl_update_pt_2_groups_have_params.json"");

  // Check RPC in each level
  ::policy::RPCParams input_params;
  InsertRpcParametersInList(input_params);

  ::policy::CheckPermissionResult output;
  // Rpc in FULL level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelFull,
                                    ""SendLocation"",
                                    input_params,
                                    output);
  // Check RPC is allowed
  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
  // Check list of allowed parameters is not empty
  EXPECT_FALSE(output.list_of_allowed_params.empty());
  EXPECT_EQ(7u, output.list_of_allowed_params.size());
  // Check parameters that should be allowed
  CheckIsParamInList(output.list_of_allowed_params, ""longitudeDegrees"");
  CheckIsParamInList(output.list_of_allowed_params, ""latitudeDegrees"");
  CheckIsParamInList(output.list_of_allowed_params, ""locationDescription"");
  CheckIsParamInList(output.list_of_allowed_params, ""phoneNumber"");
  CheckIsParamInList(output.list_of_allowed_params, ""locationName"");
  CheckIsParamInList(output.list_of_allowed_params, ""locationImage"");
  CheckIsParamInList(output.list_of_allowed_params, ""deliveryMode"");

  EXPECT_TRUE(output.list_of_disallowed_params.empty());
  ResetOutputList(output);

  // Rpc in LIMITED level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelLimited,
                                    ""SendLocation"",
                                    input_params,
                                    output);
  // Check RPC is allowed
  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
  // Check list of allowed parameters is not empty
  EXPECT_FALSE(output.list_of_allowed_params.empty());
  EXPECT_EQ(7u, output.list_of_allowed_params.size());
  // Check parameters that should be allowed
  CheckIsParamInList(output.list_of_allowed_params, ""longitudeDegrees"");
  CheckIsParamInList(output.list_of_allowed_params, ""latitudeDegrees"");
  CheckIsParamInList(output.list_of_allowed_params, ""locationDescription"");
  CheckIsParamInList(output.list_of_allowed_params, ""phoneNumber"");
  CheckIsParamInList(output.list_of_allowed_params, ""locationName"");
  CheckIsParamInList(output.list_of_allowed_params, ""locationImage"");
  CheckIsParamInList(output.list_of_allowed_params, ""deliveryMode"");

  EXPECT_TRUE(output.list_of_disallowed_params.empty());
  ResetOutputList(output);

  // Rpc in BACKGROUND level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelBackground,
                                    ""SendLocation"",
                                    input_params,
                                    output);
  // Check RPC is allowed
  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
  // Check list of allowed parameters is not empty
  EXPECT_FALSE(output.list_of_allowed_params.empty());
  EXPECT_EQ(7u, output.list_of_allowed_params.size());
  // Check parameters that should be allowed
  CheckIsParamInList(output.list_of_allowed_params, ""longitudeDegrees"");
  CheckIsParamInList(output.list_of_allowed_params, ""latitudeDegrees"");
  CheckIsParamInList(output.list_of_allowed_params, ""locationDescription"");
  CheckIsParamInList(output.list_of_allowed_params, ""phoneNumber"");
  CheckIsParamInList(output.list_of_allowed_params, ""locationName"");
  CheckIsParamInList(output.list_of_allowed_params, ""locationImage"");
  CheckIsParamInList(output.list_of_allowed_params, ""deliveryMode"");

  EXPECT_TRUE(output.list_of_disallowed_params.empty());
  // Reset output
  ResetOutputList(output);

  // Rpc in NONE level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelNone,
                                    ""SendLocation"",
                                    input_params,
                                    output);
  // Check RPC is disallowed
  EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
  // Check lists of parameters are  empty
  EXPECT_TRUE(output.list_of_allowed_params.empty());
  EXPECT_TRUE(output.list_of_disallowed_params.empty());
  EXPECT_TRUE(output.list_of_undefined_params.empty());
}

TEST_F(PolicyManagerImplTest2,
       CheckPermissions_ParamsAllowedInOneGroup_CheckRpcsInDiffLvls) {
  // Load Json to cache
  // File have 2 functional groups: SendLocation and SendLocationOnly.
  // They have different parameters. One has dissalowed all params, other -
  // allowed.

  // Arrange
  CreateLocalPT(""json/sdl_preloaded_pt_send_location.json"");
  policy_manager_->AddDevice(device_id_1_, ""Bluetooth"");
  policy::CacheManagerInterfaceSPtr cache = policy_manager_->GetCache();
  ASSERT_TRUE(cache->SetDeviceData(device_id_1_,
                                   ""hardware IPX"",
                                   ""v.8.0.1"",
                                   ""Android"",
                                   ""4.4.2"",
                                   ""Life"",
                                   2,
                                   ""Bluetooth""));

  EXPECT_CALL(listener_, GetDevicesIds(application_id_))
      .WillRepeatedly(Return(transport_manager::DeviceList()));
  // Add app from consented device. App will be assigned with default policies
  policy_manager_->SetUserConsentForDevice(device_id_1_, true);
  policy_manager_->AddApplication(
      device_id_1_, application_id_, HmiTypes(policy_table::AHT_DEFAULT));

  std::ifstream ifile(""json/sdl_update_pt_2_groups_no_params_in1.json"");
  Json::Reader reader;
  std::string json;
  Json::Value root(Json::objectValue);
  if (ifile.is_open()) {
    reader.parse(ifile, root, true);
  }
  json = root.toStyledString();
  ifile.close();
  ::policy::BinaryMessage msg(json.begin(), json.end());
  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);

  EXPECT_FALSE(cache->IsPTPreloaded());

  // Check RPC in each level
  ::policy::RPCParams input_params;
  InsertRpcParametersInList(input_params);

  ::policy::CheckPermissionResult output;
  // Rpc in FULL level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelFull,
                                    ""SendLocation"",
                                    input_params,
                                    output);

  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
  EXPECT_TRUE(output.list_of_undefined_params.empty());
  EXPECT_EQ(10u, output.list_of_allowed_params.size());
  ResetOutputList(output);

  // Rpc in LIMITED level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelLimited,
                                    ""SendLocation"",
                                    input_params,
                                    output);

  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
  EXPECT_TRUE(output.list_of_undefined_params.empty());
  EXPECT_EQ(10u, output.list_of_allowed_params.size());
  ResetOutputList(output);

  // Rpc in BACKGROUND level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelBackground,
                                    ""SendLocation"",
                                    input_params,
                                    output);

  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
  EXPECT_TRUE(output.list_of_undefined_params.empty());
  EXPECT_EQ(10u, output.list_of_allowed_params.size());
  // Reset output
  ResetOutputList(output);

  // Rpc in NONE level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelNone,
                                    ""SendLocation"",
                                    input_params,
                                    output);

  EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
  EXPECT_TRUE(output.list_of_allowed_params.empty());
  EXPECT_TRUE(output.list_of_disallowed_params.empty());
}

TEST_F(PolicyManagerImplTest2,
       CheckPermissions_ParamOmmittedInOneGroup_CheckRpcsInDiffLvls) {
  // Load Json to cache
  // File have 2 functional groups: SendLocation and SendLocationOnly.
  // They have different parameters. One has dissalowed all params, other -
  // omitted.

  // Arrange
  CreateLocalPT(""json/sdl_preloaded_pt_send_location.json"");
  policy_manager_->AddDevice(device_id_1_, ""Bluetooth"");
  policy::CacheManagerInterfaceSPtr cache = policy_manager_->GetCache();
  ASSERT_TRUE(cache->SetDeviceData(device_id_1_,
                                   ""hardware IPX"",
                                   ""v.8.0.1"",
                                   ""Android"",
                                   ""4.4.2"",
                                   ""Life"",
                                   2,
                                   ""Bluetooth""));

  EXPECT_CALL(listener_, GetDevicesIds(application_id_))
      .WillRepeatedly(Return(transport_manager::DeviceList()));
  // Add app from consented device. App will be assigned with default policies
  policy_manager_->SetUserConsentForDevice(device_id_1_, true);
  policy_manager_->AddApplication(
      device_id_1_, application_id_, HmiTypes(policy_table::AHT_DEFAULT));

  std::ifstream ifile(
      ""json/sdl_update_pt_2_groups_no_params_in1_omitted_in2.json"");
  Json::Reader reader;
  std::string json;
  Json::Value root(Json::objectValue);
  if (ifile.is_open()) {
    reader.parse(ifile, root, true);
  }
  json = root.toStyledString();
  ifile.close();
  ::policy::BinaryMessage msg(json.begin(), json.end());
  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);

  EXPECT_FALSE(cache->IsPTPreloaded());

  // Check RPC in each level
  ::policy::RPCParams input_params;
  InsertRpcParametersInList(input_params);

  ::policy::CheckPermissionResult output;
  // Rpc in FULL level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelFull,
                                    ""SendLocation"",
                                    input_params,
                                    output);

  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
  EXPECT_TRUE(output.list_of_undefined_params.empty());
  EXPECT_EQ(10u, output.list_of_allowed_params.size());
  ResetOutputList(output);

  // Rpc in LIMITED level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelLimited,
                                    ""SendLocation"",
                                    input_params,
                                    output);
  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
  EXPECT_TRUE(output.list_of_undefined_params.empty());
  EXPECT_EQ(10u, output.list_of_allowed_params.size());
  ResetOutputList(output);

  // Rpc in BACKGROUND level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelBackground,
                                    ""SendLocation"",
                                    input_params,
                                    output);
  EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
  EXPECT_TRUE(output.list_of_undefined_params.empty());
  EXPECT_EQ(10u, output.list_of_allowed_params.size());
  // Reset output
  ResetOutputList(output);

  // Rpc in NONE level
  policy_manager_->CheckPermissions(device_id_1_,
                                    application_id_,
                                    kHmiLevelNone,
                                    ""SendLocation"",
                                    input_params,
                                    output);
  EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
  EXPECT_TRUE(output.list_of_allowed_params.empty());
  EXPECT_TRUE(output.list_of_disallowed_params.empty());
  EXPECT_TRUE(output.list_of_undefined_params.empty());
}

TEST_F(PolicyManagerImplTest, LoadPT_SetInvalidUpdatePT_PTIsNotLoaded) {
  // Arrange
  policy_manager_->ForcePTExchange();
  policy_manager_->OnUpdateStarted();
  Json::Value table(Json::objectValue);

  policy_table::Table update(&table);
  update.SetPolicyTableType(rpc::policy_table_interface_base::PT_UPDATE);

  // Assert update is invalid
  ASSERT_FALSE(IsValid(update));

  // Act
  std::string json = table.toStyledString();
  ::policy::BinaryMessage msg(json.begin(), json.end());

  auto pt = std::make_shared<policy_table::Table>();
  *pt = update;

  // Assert
  EXPECT_CALL(*cache_manager_, ApplyUpdate(_)).Times(0);
  EXPECT_CALL(listener_, GetAppName(_)).Times(0);
  EXPECT_CALL(*cache_manager_, SaveUpdateRequired(false)).Times(0);
  EXPECT_CALL(*cache_manager_, TimeoutResponse()).Times(0);
  EXPECT_CALL(*cache_manager_, SecondsBetweenRetries(_)).Times(0);
  EXPECT_CALL(*cache_manager_, GetVehicleDataItems())
      .WillOnce(Return(std::vector<policy_table::VehicleDataItem>()));
  ASSERT_EQ(PolicyManager::PtProcessingResult::kWrongPtReceived,
            policy_manager_->LoadPT(kFilePtUpdateJson, msg));

  EXPECT_CALL(*cache_manager_, IsPTPreloaded());
  EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());

  EXPECT_CALL(listener_, OnUpdateStatusChanged(_)).Times(1);
  policy_manager_->OnPTUFinished(
      PolicyManager::PtProcessingResult::kWrongPtReceived);
}

TEST_F(
    PolicyManagerImplTest2,
    AddApplication_AddExistingApplicationFromDeviceWithoutConsent_ExpectNoUpdateRequired) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);
  EXPECT_EQ(""UP_TO_DATE"", policy_manager_->GetPolicyTableStatus());
  GetPTU(kValidSdlPtUpdateJson);
  EXPECT_EQ(""UP_TO_DATE"", policy_manager_->GetPolicyTableStatus());
  // Try to add existing app
  policy_manager_->AddApplication(
      device_id_1_, app_id_2_, HmiTypes(policy_table::AHT_DEFAULT));
  // Check no update required
  EXPECT_EQ(""UP_TO_DATE"", policy_manager_->GetPolicyTableStatus());
}

uint32_t GetCurrentDaysCount() {
  date_time::TimeDuration current_time = date_time::getCurrentTime();
  const uint32_t kSecondsInDay = 60 * 60 * 24;
  return date_time::getSecs(current_time) / kSecondsInDay;
}

TEST_F(PolicyManagerImplTest2,
       PTUpdatedAt_DaysNotExceedLimit_ExpectNoUpdateRequired) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);
  const uint32_t days = GetCurrentDaysCount();
  EXPECT_EQ(""UP_TO_DATE"", policy_manager_->GetPolicyTableStatus());

  GetPTU(kValidSdlPtUpdateJson);
  EXPECT_EQ(""UP_TO_DATE"", policy_manager_->GetPolicyTableStatus());

  policy_manager_->AddApplication(
      device_id_2_, app_id_2_, HmiTypes(policy_table::AHT_DEFAULT));
  EXPECT_EQ(""UP_TO_DATE"", policy_manager_->GetPolicyTableStatus());
  ::policy::Counters counter = ::policy::Counters::DAYS_AFTER_EPOCH;
  // Set PT was updated 10 days ago (limit is 30 days for now)
  // So no limit exceeded
  policy_manager_->PTUpdatedAt(counter, days - 10);
  policy_manager_->OnAppRegisteredOnMobile(device_id_2_, app_id_2_);
  EXPECT_EQ(""UP_TO_DATE"", policy_manager_->GetPolicyTableStatus());
}

TEST_F(PolicyManagerImplTest2,
       PTUpdatedAt_DaysExceedLimit_ExpectUpdateRequired) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);
  const uint32_t days = GetCurrentDaysCount();
  EXPECT_EQ(""UP_TO_DATE"", policy_manager_->GetPolicyTableStatus());
  GetPTU(kValidSdlPtUpdateJson);
  EXPECT_EQ(""UP_TO_DATE"", policy_manager_->GetPolicyTableStatus());

  policy_manager_->AddApplication(
      device_id_2_, app_id_2_, HmiTypes(policy_table::AHT_DEFAULT));
  EXPECT_EQ(""UP_TO_DATE"", policy_manager_->GetPolicyTableStatus());
  ::policy::Counters counter = ::policy::Counters::DAYS_AFTER_EPOCH;
  // Set PT was updated 50 days ago (limit is 30 days for now)
  policy_manager_->PTUpdatedAt(counter, days - 50);
  policy_manager_->OnAppRegisteredOnMobile(device_id_2_, app_id_2_);
  EXPECT_EQ(""UPDATE_NEEDED"", policy_manager_->GetPolicyTableStatus());
}

TEST_F(
    PolicyManagerImplTest2,
    OnIgnitionCyclesExceeded_SetExceededIgnitionCycles_ExpectUpdateScheduled) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);
  const uint32_t days = GetCurrentDaysCount();
  EXPECT_EQ(""UP_TO_DATE"", policy_manager_->GetPolicyTableStatus());
  GetPTU(kValidSdlPtUpdateJson);
  EXPECT_EQ(""UP_TO_DATE"", policy_manager_->GetPolicyTableStatus());
  // Try to add existing app
  policy_manager_->AddApplication(
      device_id_2_, app_id_2_, HmiTypes(policy_table::AHT_DEFAULT));
  EXPECT_EQ(""UP_TO_DATE"", policy_manager_->GetPolicyTableStatus());
  ::policy::Counters counter = ::policy::Counters::DAYS_AFTER_EPOCH;
  // Set PT was updated 10 days ago (limit is 30 days for now)
  // So no limit exceeded
  policy_manager_->PTUpdatedAt(counter, days - 10);
  int ign_cycles =
      (policy_manager_->GetCache())->IgnitionCyclesBeforeExchange();
  // Set ignition cycles to value = 99 (limit is 100 which initiates auto
  // PTExchange)
  for (int i = 0; i < ign_cycles; ++i) {
    policy_manager_->IncrementIgnitionCycles();
  }
  policy_manager_->OnAppRegisteredOnMobile(device_id_2_, app_id_2_);
  // Check update required
  EXPECT_EQ(""UPDATE_NEEDED"", policy_manager_->GetPolicyTableStatus());
}

TEST_F(PolicyManagerImplTest2,
       GetUserConsentForApp_SetUserConsentForApp_ExpectReceivedConsentCorrect) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);
  ASSERT_TRUE(
      (policy_manager_->GetCache())->AddDevice(device_id_2_, ""Bluetooth""));
  ASSERT_TRUE((policy_manager_->GetCache())
                  ->SetDeviceData(device_id_2_,
                                  ""hardware IPX"",
                                  ""v.8.0.1"",
                                  ""Android"",
                                  ""4.4.2"",
                                  ""Life"",
                                  2,
                                  ""Bluetooth""));

  ::policy::StringArray consented_groups;
  ::policy::StringArray disallowed_groups;
  consented_groups.push_back(std::string(""Notifications""));
  consented_groups.push_back(std::string(""Notifications""));
  (policy_manager_->GetCache())
      ->SetUserPermissionsForDevice(
          device_id_2_, consented_groups, disallowed_groups);
  policy_manager_->SetUserConsentForDevice(device_id_2_, true);
  EXPECT_CALL(listener_, GetDevicesIds(app_id_2_))
      .WillRepeatedly(Return(transport_manager::DeviceList()));
  policy_manager_->AddApplication(
      device_id_2_, app_id_2_, HmiTypes(policy_table::AHT_DEFAULT));
  GetPTU(kValidSdlPtUpdateJson);

  ::policy::PermissionConsent perm_consent;
  perm_consent.device_id = device_id_2_;
  perm_consent.policy_app_id = app_id_2_;
  perm_consent.consent_source = ""VR"";

  ::policy::FunctionalGroupPermission group1_perm;
  group1_perm.group_alias = ""Notifications"";
  group1_perm.group_name = ""Notifications"";
  group1_perm.group_id = ::utils::Djb2HashFromString(""Notifications"");
  group1_perm.state = ::policy::GroupConsent::kGroupAllowed;

  std::vector< ::policy::FunctionalGroupPermission> groups_permissions;
  groups_permissions.push_back(group1_perm);
  perm_consent.group_permissions = groups_permissions;

  policy_manager_->SetUserConsentForApp(perm_consent,
                                        policy::PolicyManager::kSilentMode);
  policy_manager_->SendNotificationOnPermissionsUpdated(device_id_2_,
                                                        app_id_2_);
  std::vector< ::policy::FunctionalGroupPermission> actual_groups_permissions;
  std::vector< ::policy::FunctionalGroupPermission>::iterator it;
  policy_manager_->GetUserConsentForApp(
      device_id_2_, app_id_2_, actual_groups_permissions);
  uint32_t index = 0;
  for (; index < actual_groups_permissions.size(); ++index) {
    if (actual_groups_permissions[index].group_id == group1_perm.group_id) {
      break;
    }
  }
  // Check
  EXPECT_EQ(group1_perm.group_alias,
            actual_groups_permissions[index].group_alias);
  EXPECT_EQ(group1_perm.group_name,
            actual_groups_permissions[index].group_name);
  EXPECT_EQ(group1_perm.group_id, actual_groups_permissions[index].group_id);
  EXPECT_EQ(group1_perm.state, actual_groups_permissions[index].state);
}

TEST_F(PolicyManagerImplTest2,
       CanAppKeepContext_SetPoliciesForAppUpdated_ExpectAppCanKeepContext) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);
  EXPECT_CALL(listener_, GetDevicesIds(app_id_2_))
      .WillRepeatedly(Return(transport_manager::DeviceList()));
  policy_manager_->AddApplication(
      device_id_2_, app_id_2_, HmiTypes(policy_table::AHT_DEFAULT));
  GetPTU(kValidSdlPtUpdateJson);
  // Check keep context in updated policies for app
  EXPECT_TRUE(policy_manager_->CanAppKeepContext(app_id_2_));
}

TEST_F(PolicyManagerImplTest2,
       CanAppStealFocus_SetPoliciesForAppUpdated_ExpectAppCanStealFocus) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);
  EXPECT_CALL(listener_, GetDevicesIds(app_id_2_))
      .WillRepeatedly(Return(transport_manager::DeviceList()));
  policy_manager_->AddApplication(
      device_id_2_, app_id_2_, HmiTypes(policy_table::AHT_DEFAULT));
  GetPTU(kValidSdlPtUpdateJson);
  // Check keep context in updated policies for app
  EXPECT_TRUE(policy_manager_->CanAppKeepContext(app_id_2_));
}

TEST_F(
    PolicyManagerImplTest2,
    GetPermissionsForApp_SetUserConsentForApp_ExpectReceivedPermissionsCorrect) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);

  ASSERT_TRUE(
      (policy_manager_->GetCache())->AddDevice(device_id_2_, ""Bluetooth""));
  ASSERT_TRUE((policy_manager_->GetCache())
                  ->SetDeviceData(device_id_2_,
                                  ""hardware IPX"",
                                  ""v.8.0.1"",
                                  ""Android"",
                                  ""4.4.2"",
                                  ""Life"",
                                  2,
                                  ""Bluetooth""));

  ::policy::StringArray consented_groups;
  ::policy::StringArray disallowed_groups;
  consented_groups.push_back(std::string(""Notifications""));
  (policy_manager_->GetCache())
      ->SetUserPermissionsForDevice(
          device_id_2_, consented_groups, disallowed_groups);
  policy_manager_->SetUserConsentForDevice(device_id_2_, true);
  EXPECT_CALL(listener_, GetDevicesIds(app_id_2_))
      .WillRepeatedly(Return(transport_manager::DeviceList(1, device_id_2_)));
  policy_manager_->AddApplication(
      device_id_2_, app_id_2_, HmiTypes(policy_table::AHT_DEFAULT));

  GetPTU(kValidSdlPtUpdateJson);
  ::policy::PermissionConsent perm_consent;
  perm_consent.device_id = device_id_2_;
  perm_consent.policy_app_id = app_id_2_;
  perm_consent.consent_source = ""VR"";

  ::policy::FunctionalGroupPermission group1_perm;
  group1_perm.group_alias = ""Notifications"";
  group1_perm.group_name = ""Notifications"";
  group1_perm.group_id = ::utils::Djb2HashFromString(""Notifications"");
  group1_perm.state = ::policy::GroupConsent::kGroupAllowed;

  std::vector< ::policy::FunctionalGroupPermission> groups_permissions;
  groups_permissions.push_back(group1_perm);
  perm_consent.group_permissions = groups_permissions;

  policy_manager_->SetUserConsentForApp(perm_consent,
                                        policy::PolicyManager::kSilentMode);
  policy_manager_->SendNotificationOnPermissionsUpdated(device_id_2_,
                                                        app_id_2_);
  std::vector< ::policy::FunctionalGroupPermission> actual_groups_permissions;
  std::vector< ::policy::FunctionalGroupPermission>::iterator it;
  policy_manager_->GetPermissionsForApp(
      device_id_2_, app_id_2_, actual_groups_permissions);
  uint32_t index = 0;
  for (; index < actual_groups_permissions.size(); ++index) {
    if (actual_groups_permissions[index].group_id == group1_perm.group_id) {
      break;
    }
  }
  // Check
  EXPECT_EQ(group1_perm.group_alias,
            actual_groups_permissions[index].group_alias);
  EXPECT_EQ(group1_perm.group_name,
            actual_groups_permissions[index].group_name);
  EXPECT_EQ(group1_perm.group_id, actual_groups_permissions[index].group_id);
  EXPECT_EQ(group1_perm.state, actual_groups_permissions[index].state);
}

TEST_F(
    PolicyManagerImplTest2,
    GetAppRequestTypes_AddApp_UpdateAppPolicies_ExpectReceivedRequestTypesCorrect) {
  // Arrange
  const transport_manager::DeviceHandle handle = 1;
  CreateLocalPT(preloaded_pt_filename_);
  EXPECT_CALL(listener_, GetDevicesIds(app_id_3_))
      .WillRepeatedly(Return(transport_manager::DeviceList(1, device_id_1_)));
  EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(handle, app_id_3_))
      .WillRepeatedly(Return(device_id_1_));
  policy_manager_->AddApplication(
      device_id_1_, app_id_3_, HmiTypes(policy_table::AHT_DEFAULT));
  ::policy::StringArray app_requests =
      policy_manager_->GetAppRequestTypes(handle, app_id_3_);
  EXPECT_EQ(1u, app_requests.size());

  Json::Value root = GetPTU(kPtuRequestTypeJson);
  Json::Value request_Types = Json::Value(Json::arrayValue);
  request_Types =
      root[""policy_table""][""app_policies""][app_id_3_][""RequestType""];
  app_requests = policy_manager_->GetAppRequestTypes(handle, app_id_3_);
  EXPECT_EQ(request_Types.size(), app_requests.size());
  // Check nicknames match
  for (uint32_t i = 0; i < request_Types.size(); ++i) {
    EXPECT_EQ(request_Types[i], app_requests[i]);
  }
}

TEST_F(
    PolicyManagerImplTest2,
    HertBeatTimeout_AddApp_UpdateAppPolicies_ExpectReceivedHertBeatTimeoutCorrect) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);
  std::shared_ptr<policy_table::Table> pt =
      (policy_manager_->GetCache())->GetPT();
  ::policy_table::PolicyTableType type1 =
      ::policy_table::PolicyTableType::PT_PRELOADED;
  pt->SetPolicyTableType(type1);
  if (!pt->is_valid()) {
    std::cout << ""\\nPolicy table is not valid.""
              << ""\\n"";
    rpc::ValidationReport report(""policy_table"");
    pt->ReportErrors(&report);
  }
  EXPECT_CALL(listener_, GetDevicesIds(app_id_2_))
      .WillRepeatedly(Return(transport_manager::DeviceList()));
  // Add new app
  policy_manager_->AddApplication(
      device_id_2_, app_id_2_, HmiTypes(policy_table::AHT_DEFAULT));
  uint32_t result = policy_manager_->HeartBeatTimeout(app_id_2_);
  // By default hertbeat timeout is 0
  EXPECT_EQ(0u, result);
  Json::Value root = GetPTU(kValidSdlPtUpdateJson);

  ::policy_table::PolicyTableType type2 =
      ::policy_table::PolicyTableType::PT_UPDATE;
  pt->SetPolicyTableType(type2);
  if (!pt->is_valid()) {
    std::cout << ""\\nPolicy table is not valid.""
              << ""\\n"";
    rpc::ValidationReport report(""policy_table"");
    pt->ReportErrors(&report);
  }

  Json::Value heart_beat_timeout = Json::Value(Json::uintValue);
  heart_beat_timeout =
      root[""policy_table""][""app_policies""][app_id_2_][""heart_beat_timeout_ms""];
  result = policy_manager_->HeartBeatTimeout(app_id_2_);
  EXPECT_EQ(heart_beat_timeout.asUInt(), result);
}

TEST_F(PolicyManagerImplTest2,
       RemoveAppConsentForGroup_SetUserConsentForApp_ExpectAppConsentDeleted) {
  // Arrange
  CreateLocalPT(preloaded_pt_filename_);
  ASSERT_TRUE(
      (policy_manager_->GetCache())->AddDevice(device_id_2_, ""Bluetooth""));
  ASSERT_TRUE((policy_manager_->GetCache())
                  ->SetDeviceData(device_id_2_,
                                  ""hardware IPX"",
                                  ""v.8.0.1"",
                                  ""Android"",
                                  ""4.4.2"",
                                  ""Life"",
                                  2,
                                  ""Bluetooth""));

  ::policy::StringArray consented_groups;
  ::policy::StringArray disallowed_groups;
  consented_groups.push_back(std::string(""Notifications""));
  (policy_manager_->GetCache())
      ->SetUserPermissionsForDevice(
          device_id_2_, consented_groups, disallowed_groups);
  policy_manager_->SetUserConsentForDevice(device_id_2_, true);
  EXPECT_CALL(listener_, GetDevicesIds(app_id_2_))
      .WillRepeatedly(Return(transport_manager::DeviceList(1, device_id_2_)));
  policy_manager_->AddApplication(
      device_id_2_, app_id_2_, HmiTypes(policy_table::AHT_DEFAULT));
  GetPTU(kValidSdlPtUpdateJson);

  ::policy::PermissionConsent perm_consent;
  perm_consent.device_id = device_id_2_;
  perm_consent.policy_app_id = app_id_2_;
  perm_consent.consent_source = ""VR"";

  ::policy::FunctionalGroupPermission group1_perm;
  group1_perm.group_alias = ""Notifications"";
  group1_perm.group_name = ""Notifications"";
  group1_perm.group_id = ::utils::Djb2HashFromString(""Notifications"");
  group1_perm.state = ::policy::GroupConsent::kGroupAllowed;

  std::vector< ::policy::FunctionalGroupPermission> groups_permissions;
  groups_permissions.push_back(group1_perm);
  perm_consent.group_permissions = groups_permissions;

  policy_manager_->SetUserConsentForApp(perm_consent,
                                        policy::PolicyManager::kSilentMode);
  policy_manager_->SendNotificationOnPermissionsUpdated(device_id_2_,
                                                        app_id_2_);
  std::vector< ::policy::FunctionalGroupPermission> actual_groups_permissions;
  std::vector< ::policy::FunctionalGroupPermission>::iterator it;
  policy_manager_->GetPermissionsForApp(
      device_id_2_, app_id_2_, actual_groups_permissions);
  uint32_t index = 0;
  for (; index < actual_groups_permissions.size(); ++index) {
    if (actual_groups_permissions[index].group_id == group1_perm.group_id) {
      break;
    }
  }
  // Check
  EXPECT_EQ(group1_perm.group_alias,
            actual_groups_permissions[index].group_alias);
  EXPECT_EQ(group1_perm.group_name,
            actual_groups_permissions[index].group_name);
  EXPECT_EQ(group1_perm.group_id, actual_groups_permissions[index].group_id);
  EXPECT_EQ(group1_perm.state, actual_groups_permissions[index].state);
  std::shared_ptr<policy_table::Table> pt =
      (policy_manager_->GetCache())->GetPT();
  uint32_t ucr_size = 0;
  ::policy_table::DeviceData& device_data = *pt->policy_table.device_data;
  ::policy_table::DeviceData::const_iterator dev_data_iter =
      device_data.find(device_id_2_);
  if (dev_data_iter != device_data.end()) {
    const ::policy_table::DeviceParams& dev_params = dev_data_iter->second;
    const ::policy_table::UserConsentRecords& ucr =
        *(dev_params.user_consent_records);
    ucr_size = ucr.size();
    ASSERT_GT(ucr_size, 0u);
    ::policy_table::UserConsentRecords::const_iterator ucr_iter =
        ucr.find(app_id_2_);
    if (ucr_iter != ucr.end()) {
      EXPECT_TRUE((*(ucr_iter->second.consent_groups)).find(""Notifications"") !=
                  (*(ucr_iter->second.consent_groups)).end());
      policy_manager_->RemoveAppConsentForGroup(app_id_2_, ""Notifications"");
      EXPECT_TRUE((*(ucr_iter->second.consent_groups)).find(""Notifications"") ==
                  (*(ucr_iter->second.consent_groups)).end());
    }
  }
}

TEST_F(PolicyManagerImplTest2,
       SingleInvalidRequestTypeInPTU_ExpectReplaceWithDefaultValues) {
  // Arrange
  const std::string section_name = app_id_2_;
  const transport_manager::DeviceHandle handle = 1;

  // Arrange
  CreateLocalPT(preloaded_pt_filename_);

  // Setting device consent to 'true' in order to have defult application
  // permissions, request type etc.
  EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(handle, app_id_2_))
      .WillRepeatedly(Return(device_id_1_));
  policy_manager_->SetUserConsentForDevice(device_id_1_, true);
  EXPECT_CALL(listener_, GetDevicesIds(section_name))
      .WillRepeatedly(Return(transport_manager::DeviceList(1, device_id_1_)));
  // Add app
  policy_manager_->AddApplication(
      device_id_1_, section_name, HmiTypes(policy_table::AHT_DEFAULT));
  EXPECT_CALL(listener_, OnPendingPermissionChange(device_id_1_, section_name));

  // PTU has single invalid RequestTypes, which must be dropped and replaced
  // with default RT
  GetPTU(""json/PTU_with_one_invalid_requestType.json"");

  // Get RequestTypes from <app_id> section of app policies after PT update
  ::policy::StringArray app_request_types_after =
      policy_manager_->GetAppRequestTypes(handle, section_name);

  EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(handle, kDefaultId))
      .WillOnce(Return(device_id_1_));
  ::policy::StringArray default_request_types_after =
      policy_manager_->GetAppRequestTypes(handle, kDefaultId);

  // Check sizes of Request types of PT and PTU
  EXPECT_EQ(4u, app_request_types_after.size());

  ::policy::AppPermissions permissions =
      policy_manager_->GetAppPermissionsChanges(device_id_1_, section_name);
  EXPECT_TRUE(permissions.requestTypeChanged);

  policy_table::RequestType temp_res1;
  std::vector<policy_table::RequestType> result1;
  for (uint32_t i = 0; i < app_request_types_after.size(); ++i) {
    if (::rpc::policy_table_interface_base::EnumFromJsonString(
            app_request_types_after[i], &temp_res1)) {
      result1.push_back(temp_res1);
    }
  }
  policy_table::RequestType temp_res2;
  std::vector<policy_table::RequestType> result2;
  for (size_t i = 0; i < default_request_types_after.size(); ++i) {
    if (::rpc::policy_table_interface_base::EnumFromJsonString(
            default_request_types_after[i], &temp_res2)) {
      result2.push_back(temp_res2);
    }
  }
  ASSERT_EQ(result1.size(), result2.size());
  std::sort(result1.begin(), result1.end());
  std::sort(result2.begin(), result2.end());
  // Checks
  EXPECT_TRUE(std::equal(result1.begin(), result1.end(), result2.begin()));
}

TEST_F(PolicyManagerImplTest2,
       InitPT_LoadPT_ExpectIncrementedCountOfSamePrompts) {
  // Initializing policy_table
  CreateLocalPT(preloaded_pt_filename_);

  policy_table::FunctionalGroupings functional_groupings;
  GetFunctionalGroupingsFromManager(functional_groupings);

  UserConsentPromptToRpcsConnections initial_functional_groupings_map;
  UserConsentPromptToRpcsConnections updated_functional_groupings_map;
  // Filling initial map
  FillMultimapFromFunctionalGroupings(initial_functional_groupings_map,
                                      functional_groupings);

  // Updating policy_table
  GetPTU(""json/sdl_pt_update.json"");
  policy_table::FunctionalGroupings updated_functional_groupings;
  GetFunctionalGroupingsFromManager(updated_functional_groupings);
  // Filling updated map
  FillMultimapFromFunctionalGroupings(updated_functional_groupings_map,
                                      updated_functional_groupings);

  // Comparing two multimaps
  // (EXPECT increment count of functionalgroups
  // under key : user_consent_prompt)
  uint32_t count_before_update =
      initial_functional_groupings_map.count(""Notifications"");
  uint32_t count_after_update =
      updated_functional_groupings_map.count(""Notifications"");
  EXPECT_EQ(1u, count_before_update);
  EXPECT_EQ(2u, count_after_update);
}

TEST_F(PolicyManagerImplTest2,
       LoadPT_UpdatePT_ChangingCountsOfDifferentUserConsentPrompts) {
  // Initializing policy_table
  CreateLocalPT(preloaded_pt_filename_);

  // First update of policy table
  GetPTU(""json/sdl_pt_first_update.json"");
  // Geting functional groupings first time
  policy_table::FunctionalGroupings first_functional_groupings;
  GetFunctionalGroupingsFromManager(first_functional_groupings);
  // Filling map first time
  UserConsentPromptToRpcsConnections first_update_functional_groupings_map;
  FillMultimapFromFunctionalGroupings(first_update_functional_groupings_map,
                                      first_functional_groupings);

  // Second update of policy table
  GetPTU(""json/sdl_pt_second_update.json"");
  // Geting functional groupings second time
  policy_table::FunctionalGroupings second_functional_groupings;
  GetFunctionalGroupingsFromManager(second_functional_groupings);
  // Filling map second time
  UserConsentPromptToRpcsConnections second_update_functional_groupings_map;
  FillMultimapFromFunctionalGroupings(second_update_functional_groupings_map,
                                      second_functional_groupings);

  // Getting counts before second update
  uint32_t first_count_of_old_user_consent_prompt =
      first_update_functional_groupings_map.count(""Old_Notifications"");
  uint32_t first_count_of_new_user_consent_prompt =
      first_update_functional_groupings_map.count(""New_Notifications"");

  // Getting counts after second update
  uint32_t second_count_of_old_user_consent_prompt =
      second_update_functional_groupings_map.count(""Old_Notifications"");
  uint32_t second_count_of_new_user_consent_prompt =
      second_update_functional_groupings_map.count(""New_Notifications"");

  // Expect decrement count of old user_consent_prormpt
  EXPECT_GT(first_count_of_old_user_consent_prompt,
            second_count_of_old_user_consent_prompt);
  // Expect increment count of new user_consent_prormpt
  EXPECT_LT(first_count_of_new_user_consent_prompt,
            second_count_of_new_user_consent_prompt);
}

TEST_F(PolicyManagerImplTest_RequestTypes,
       LoadPT_PTWithOneInvalidRequestTypeValue_RequestTypeValueEQToDefault) {
  // Logic in another function
  CompareAppRequestTypesWithDefault(kAppId, kJsonFiles[0]);
}

TEST_F(PolicyManagerImplTest_RequestTypes,
       LoadPT_InvalidRequestTypeBetweenCorectValuesInPTU_EraseInvalidValue) {
  // Refresh policy table with invalid RequestType in application
  RefreshPT(preloaded_pt_filename_, kJsonFiles[1]);
  // Correct of Request Types
  policy_table::RequestTypes correct_types;
  correct_types.push_back(policy_table::RequestType::RT_HTTP);
  correct_types.push_back(policy_table::RequestType::RT_LAUNCH_APP);
  correct_types.push_back(policy_table::RequestType::RT_PROPRIETARY);
  // Get <app_id> Request Types
  policy_table::RequestTypes received_types =
      GetRequestTypesForApplication(kAppId);

  CompareRequestTypesContainers(correct_types, received_types);
}

TEST_F(
    PolicyManagerImplTest_RequestTypes,
    LoadPT_AppInUpdateFileHaventRequestTypeField_RequestTypeValueEQToDefault) {
  // Logic in another function
  CompareAppRequestTypesWithDefault(kAppId, kJsonFiles[2]);
}

TEST_F(PolicyManagerImplTest_RequestTypes,
       LoadPT_RequestTypeArrayHaveNoOneValues_AvalibleAllRequestTypes) {
  // Refresh policy table with invalid RequestType in application
  RefreshPT(preloaded_pt_filename_, kJsonFiles[3]);

  // Get <app_id> Request Types
  policy_table::RequestTypes received_types =
      GetRequestTypesForApplication(kAppId);

  // Expect
  const size_t correct_size = 0;
  const size_t received_size = received_types.size();
  EXPECT_EQ(correct_size, received_size);
}

TEST_F(PolicyManagerImplTest_RequestTypes,
       InitPT_DefaultRequestTypeHaveOneInvalidValue_False) {
  // PT have only invalid value in app_policies::default::RequestType
  ON_CALL(policy_settings_, app_storage_folder())
      .WillByDefault(ReturnRef(app_storage_folder_));
  ASSERT_FALSE(
      policy_manager_impl_sptr_->InitPT(kJsonFiles[4], &policy_settings_));
  // Invalid table data with pt_preloaded=true
  EXPECT_TRUE(policy_manager_impl_sptr_->GetCache()->IsPTPreloaded());
}

TEST_F(PolicyManagerImplTest_RequestTypes,
       InitPT_DefaultRequestTypeHaveSeveralInvalidValues_False) {
  // PT have several only invalid values in app_policies::default::RequestType
  ON_CALL(policy_settings_, app_storage_folder())
      .WillByDefault(ReturnRef(app_storage_folder_));
  ASSERT_FALSE(
      policy_manager_impl_sptr_->InitPT(kJsonFiles[5], &policy_settings_));
  // Invalid table data with pt_preloaded=true
  EXPECT_TRUE(policy_manager_impl_sptr_->GetCache()->IsPTPreloaded());
}

TEST_F(PolicyManagerImplTest_RequestTypes,
       InitPT_DefaultRequestTypeHaveInvalidValueBetweenCorrect_True) {
  // PT have [""QUERY_APPS"", ""IVSU"", ""PROPRIETARY""]
  // In app_policies::default::RequestType
  ON_CALL(policy_settings_, app_storage_folder())
      .WillByDefault(ReturnRef(app_storage_folder_));
  ASSERT_TRUE(
      policy_manager_impl_sptr_->InitPT(kJsonFiles[6], &policy_settings_));
  EXPECT_TRUE(policy_manager_impl_sptr_->GetCache()->IsPTPreloaded());

  // Correct of Request Types
  policy_table::RequestTypes correct_types;
  correct_types.push_back(policy_table::RequestType::RT_QUERY_APPS);
  correct_types.push_back(policy_table::RequestType::RT_PROPRIETARY);

  // Get default Request Types
  policy_table::RequestTypes received_types =
      GetRequestTypesForApplication(kDefaultAppId);

  CompareRequestTypesContainers(correct_types, received_types);
}

TEST_F(PolicyManagerImplTest_RequestTypes,
       LoadPT_PTDefaultApp_RequestTypeValueEQToUpdate) {
  // Base values of Request Types
  policy_table::RequestTypes correct_types = CreateDefaultAppPTURequestValues();

  // Load valid values for RequestType
  RefreshPT(preloaded_pt_filename_, kJsonFiles[7]);

  // Get Request Types for ""<default>""
  policy_table::RequestTypes received_types =
      GetRequestTypesForApplication(policy::kDefaultId);

  CompareRequestTypesContainers(correct_types, received_types);
}

TEST_F(
    PolicyManagerImplTest_RequestTypes,
    LoadPT_PTDefaultAppInvalidRequestTypeValues_RequestTypeValueEQToDatabase) {
  // Base values of Request Types
  policy_table::RequestTypes correct_types =
      CreateDefaultAppDatabaseRequestValues();

  // Load RequestType with invalid values
  RefreshPT(preloaded_pt_filename_, kJsonFiles[8]);

  // Get Request Types for ""<default>""
  policy_table::RequestTypes received_types =
      GetRequestTypesForApplication(policy::kDefaultId);

  CompareRequestTypesContainers(correct_types, received_types);
}

TEST_F(PolicyManagerImplTest_RequestTypes,
       LoadPT_PTDefaultAppEmptyRequestTypeValues_RequestTypeValueEmpty) {
  // Load RequestType with empty values
  RefreshPT(preloaded_pt_filename_, kJsonFiles[9]);

  // Get Request Types for ""<default>""
  policy_table::RequestTypes received_types =
      GetRequestTypesForApplication(policy::kDefaultId);

  // Expect
  const size_t received_size = received_types.size();
  EXPECT_EQ(0u, received_size);
}

TEST_F(PolicyManagerImplTest_RequestTypes,
       LoadPT_PTDefaultAppOmittedRequestType_RequestTypeValueEQToDatabase) {
  // Base values of Request Types
  policy_table::RequestTypes correct_types =
      CreateDefaultAppDatabaseRequestValues();

  // Load omitted RequestType values
  RefreshPT(preloaded_pt_filename_, kJsonFiles[10]);

  // Get Request Types for ""<default>""
  policy_table::RequestTypes received_types =
      GetRequestTypesForApplication(policy::kDefaultId);

  CompareRequestTypesContainers(correct_types, received_types);
}

TEST_F(
    PolicyManagerImplTest_RequestTypes,
    LoadPT_PTDefaultAppOneInvalidRequestTypeValue_RequestTypeValueEQValidPT) {
  // Update values of Request Types
  policy_table::RequestTypes correct_types = CreateDefaultAppPTURequestValues();

  // Load RequestType with one invalid value
  RefreshPT(preloaded_pt_filename_, kJsonFiles[11]);

  // Get Request Types for ""<default>""
  policy_table::RequestTypes received_types =
      GetRequestTypesForApplication(policy::kDefaultId);

  CompareRequestTypesContainers(correct_types, received_types);
}

TEST_F(PolicyManagerImplTest_RequestTypes,
       LoadPT_PTPreDataConsentApp_RequestTypeValueEQToUpdate) {
  // Update values of Request Types
  policy_table::RequestTypes correct_types =
      CreatePreDataConsentAppPTURequestValues();

  // Load valid values for RequestType
  RefreshPT(preloaded_pt_filename_, kJsonFiles[12]);

  // Get Request Types for ""<pre_DataConsent>""
  policy_table::RequestTypes received_types =
      GetRequestTypesForApplication(policy::kPreDataConsentId);

  CompareRequestTypesContainers(correct_types, received_types);
}

TEST_F(
    PolicyManagerImplTest_RequestTypes,
    LoadPT_PTPreDataConsentAppInvalidRequestTypeValues_RequestTypeValueEQToDatabase) {
  // Update values of Request Types
  policy_table::RequestTypes correct_types;
  correct_types.push_back(policy_table::RequestType::RT_HTTP);

  // Load RequestType with invalid values
  RefreshPT(preloaded_pt_filename_, kJsonFiles[13]);

  // Get Request Types for ""<pre_DataConsent>""
  policy_table::RequestTypes received_types =
      GetRequestTypesForApplication(policy::kPreDataConsentId);

  CompareRequestTypesContainers(correct_types, received_types);
}

TEST_F(PolicyManagerImplTest_RequestTypes,
       LoadPT_PTPreDataConsentAppEmptyRequestTypeValues_RequestTypeValueEmpty) {
  // Load RequestType with empty values
  RefreshPT(preloaded_pt_filename_, kJsonFiles[14]);

  // Get Request Types for ""<pre_DataConsent>""
  policy_table::RequestTypes received_types =
      GetRequestTypesForApplication(policy::kPreDataConsentId);

  // Expect
  const size_t received_size = received_types.size();
  EXPECT_EQ(0u, received_size);
}

TEST_F(
    PolicyManagerImplTest_RequestTypes,
    LoadPT_PTPreDataConsentAppOmittedRequestType_RequestTypeValueEQToDatabase) {
  // Base values of Request Types
  policy_table::RequestTypes correct_types;
  correct_types.push_back(policy_table::RequestType::RT_HTTP);

  // Load omitted RequestType values
  RefreshPT(preloaded_pt_filename_, kJsonFiles[15]);

  // Get Request Types for ""<pre_DataConsent>""
  policy_table::RequestTypes received_types =
      GetRequestTypesForApplication(policy::kPreDataConsentId);

  CompareRequestTypesContainers(correct_types, received_types);
}

TEST_F(
    PolicyManagerImplTest_RequestTypes,
    LoadPT_PTPreDataConsentAppOneInvalidRequestTypeValue_RequestTypeValueEQValidPT) {
  // Update values of Request Types
  policy_table::RequestTypes correct_types =
      CreatePreDataConsentAppPTURequestValues();

  // Load RequestType with one invalid value
  RefreshPT(preloaded_pt_filename_, kJsonFiles[16]);

  // Get Request Types for ""<pre_DataConsent>""
  policy_table::RequestTypes received_types =
      GetRequestTypesForApplication(policy::kPreDataConsentId);

  CompareRequestTypesContainers(correct_types, received_types);
}

}  // namespace policy_test
}  // namespace components
}  // namespace test
",16369,True,3164.2802581624524,median
"/*
 * si5351.cpp - Si5351 library for Arduino
 *
 * Copyright (C) 2015 - 2019 Jason Milldrum <milldrum@gmail.com>
 *                           Dana H. Myers <k6jq@comcast.net>
 *
 * Some tuning algorithms derived from clk-si5351.c in the Linux kernel.
 * Sebastian Hesselbarth <sebastian.hesselbarth@gmail.com>
 * Rabeeh Khoury <rabeeh@solid-run.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 

#include <stdint.h>

#include ""Arduino.h""
#include ""Wire.h""

#include ""si5351.h""

#ifdef RASPBERRY_PI_I2C
int si5351fd;
#endif

#ifdef SI5351A_B04486_GT
	i2c_addr = 0x62;		//	needed for certain preprogrammed parts
#endif

/********************/
/* Public functions */
/********************/

Si5351::Si5351(uint8_t i2c_addr):
	i2c_bus_addr(i2c_addr)
{
	xtal_freq[0] = SI5351_XTAL_FREQ;

	// Start by using XO ref osc as default for each PLL
	plla_ref_osc = SI5351_PLL_INPUT_XO;
	pllb_ref_osc = SI5351_PLL_INPUT_XO;
	clkin_div = SI5351_CLKIN_DIV_1;
}

/*
 * init(uint8_t xtal_load_c, uint32_t ref_osc_freq, int32_t corr)
 *
 * Setup communications to the Si5351 and set the crystal
 * load capacitance.
 *
 * xtal_load_c - Crystal load capacitance. Use the SI5351_CRYSTAL_LOAD_*PF
 * defines in the header file
 * xo_freq - Crystal/reference oscillator frequency in 1 Hz increments.
 * Defaults to 25000000 if a 0 is used here.
 * corr - Frequency correction constant in parts-per-billion
 *
 * Returns a boolean that indicates whether a device was found on the desired
 * I2C address.
 *
 */
bool Si5351::init(uint8_t xtal_load_c, uint32_t xo_freq, int32_t corr)
{
#ifdef RASPBERRY_PI_I2C
	// Start I2C comms
   	uint8_t reg_val = 0;
   if (		((si5351fd = open(""/dev/i2c-1"", O_RDWR)) >= 0)
   		&&	(ioctl(si5351fd, I2C_SLAVE, i2c_bus_addr & 0xff) >= 0) )
   		reg_val = 0;
	else reg_val = -1;
#endif

#ifndef RASPBERRY_PI_I2C
	// Start I2C comms
	Wire.begin();

	// Check for a device on the bus, bail out if it is not there
	Wire.beginTransmission(i2c_bus_addr);
	uint8_t reg_val;
  reg_val = Wire.endTransmission();

#endif

	if(reg_val == 0)
	{
		// Wait for SYS_INIT flag to be clear, indicating that device is ready
		uint8_t status_reg = 0;
		do
		{
			status_reg = si5351_read(SI5351_DEVICE_STATUS);
		} while (status_reg >> 7 == 1);

		// Set crystal load capacitance
		si5351_write(SI5351_CRYSTAL_LOAD, (xtal_load_c & SI5351_CRYSTAL_LOAD_MASK) | 0b00010010);

		// Set up the XO reference frequency
		if (xo_freq != 0)
		{
			set_ref_freq(xo_freq, SI5351_PLL_INPUT_XO);
		}
		else
		{
			set_ref_freq(SI5351_XTAL_FREQ, SI5351_PLL_INPUT_XO);
		}

		// Set the frequency calibration for the XO
		set_correction(corr, SI5351_PLL_INPUT_XO);

		reset();

		return true;
	}
	else
	{
		return false;
	}
}

/*
 * reset(void)
 *
 * Call to reset the Si5351 to the state initialized by the library.
 *
 */
void Si5351::reset(void)
{
	// Initialize the CLK outputs according to flowchart in datasheet
	// First, turn them off
	si5351_write(16, 0x80);
	si5351_write(17, 0x80);
	si5351_write(18, 0x80);
	si5351_write(19, 0x80);
	si5351_write(20, 0x80);
	si5351_write(21, 0x80);
	si5351_write(22, 0x80);
	si5351_write(23, 0x80);

	// Turn the clocks back on...
	si5351_write(16, 0x0c);
	si5351_write(17, 0x0c);
	si5351_write(18, 0x0c);
	si5351_write(19, 0x0c);
	si5351_write(20, 0x0c);
	si5351_write(21, 0x0c);
	si5351_write(22, 0x0c);
	si5351_write(23, 0x0c);

	// Set PLLA and PLLB to 800 MHz for automatic tuning
	set_pll(SI5351_PLL_FIXED, SI5351_PLLA);
	set_pll(SI5351_PLL_FIXED, SI5351_PLLB);

	// Make PLL to CLK assignments for automatic tuning
	pll_assignment[0] = SI5351_PLLA;
	pll_assignment[1] = SI5351_PLLA;
	pll_assignment[2] = SI5351_PLLA;
	pll_assignment[3] = SI5351_PLLA;
	pll_assignment[4] = SI5351_PLLA;
	pll_assignment[5] = SI5351_PLLA;
	pll_assignment[6] = SI5351_PLLB;
	pll_assignment[7] = SI5351_PLLB;

	set_ms_source(SI5351_CLK0, SI5351_PLLA);
	set_ms_source(SI5351_CLK1, SI5351_PLLA);
	set_ms_source(SI5351_CLK2, SI5351_PLLA);
	set_ms_source(SI5351_CLK3, SI5351_PLLA);
	set_ms_source(SI5351_CLK4, SI5351_PLLA);
	set_ms_source(SI5351_CLK5, SI5351_PLLA);
	set_ms_source(SI5351_CLK6, SI5351_PLLB);
	set_ms_source(SI5351_CLK7, SI5351_PLLB);

	// Reset the VCXO param
	si5351_write(SI5351_VXCO_PARAMETERS_LOW, 0);
	si5351_write(SI5351_VXCO_PARAMETERS_MID, 0);
	si5351_write(SI5351_VXCO_PARAMETERS_HIGH, 0);

	// Then reset the PLLs
	pll_reset(SI5351_PLLA);
	pll_reset(SI5351_PLLB);

	// Set initial frequencies
	uint8_t i;
	for(i = 0; i < 8; i++)
	{
		clk_freq[i] = 0;
		output_enable((enum si5351_clock)i, 0);
		clk_first_set[i] = false;
	}
}

/*
 * set_freq(uint64_t freq, enum si5351_clock clk)
 *
 * Sets the clock frequency of the specified CLK output.
 * Frequency range of 8 kHz to 150 MHz
 *
 * freq - Output frequency in Hz
 * clk - Clock output
 *   (use the si5351_clock enum)
 */
uint8_t Si5351::set_freq(uint64_t freq, enum si5351_clock clk)
{
	struct Si5351RegSet ms_reg;
	uint64_t pll_freq;
	uint8_t int_mode = 0;
	uint8_t div_by_4 = 0;
	uint8_t r_div = 0;

	// Check which Multisynth is being set
	if((uint8_t)clk <= (uint8_t)SI5351_CLK5)
	{
		// MS0 through MS5 logic
		// ---------------------

		// Lower bounds check
		if(freq > 0 && freq < SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT)
		{
			freq = SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT;
		}

		// Upper bounds check
		if(freq > SI5351_MULTISYNTH_MAX_FREQ * SI5351_FREQ_MULT)
		{
			freq = SI5351_MULTISYNTH_MAX_FREQ * SI5351_FREQ_MULT;
		}

		// If requested freq >100 MHz and no other outputs are already >100 MHz,
		// we need to recalculate PLLA and then recalculate all other CLK outputs
		// on same PLL
		if(freq > (SI5351_MULTISYNTH_SHARE_MAX * SI5351_FREQ_MULT))
		{
			// Check other clocks on same PLL
			uint8_t i;
			for(i = 0; i < 6; i++)
			{
				if(clk_freq[i] > (SI5351_MULTISYNTH_SHARE_MAX * SI5351_FREQ_MULT))
				{
					if(i != (uint8_t)clk && pll_assignment[i] == pll_assignment[clk])
					{
						return 1; // won't set if any other clks already >100 MHz
					}
				}
			}

			// Enable the output on first set_freq only
			if(clk_first_set[(uint8_t)clk] == false)
			{
				output_enable(clk, 1);
				clk_first_set[(uint8_t)clk] = true;
			}

			// Set the freq in memory
			clk_freq[(uint8_t)clk] = freq;

			// Calculate the proper PLL frequency
			pll_freq = multisynth_calc(freq, 0, &ms_reg);

			// Set PLL
			set_pll(pll_freq, pll_assignment[clk]);

			// Recalculate params for other synths on same PLL
			for(i = 0; i < 6; i++)
			{
				if(clk_freq[i] != 0)
				{
					if(pll_assignment[i] == pll_assignment[clk])
					{
						struct Si5351RegSet temp_reg;
						uint64_t temp_freq;

						// Select the proper R div value
						temp_freq = clk_freq[i];
						r_div = select_r_div(&temp_freq);

						multisynth_calc(temp_freq, pll_freq, &temp_reg);

						// If freq > 150 MHz, we need to use DIVBY4 and integer mode
						if(temp_freq >= SI5351_MULTISYNTH_DIVBY4_FREQ * SI5351_FREQ_MULT)
						{
							div_by_4 = 1;
							int_mode = 1;
						}
						else
						{
							div_by_4 = 0;
							int_mode = 0;
						}

						// Set multisynth registers
						set_ms((enum si5351_clock)i, temp_reg, int_mode, r_div, div_by_4);
					}
				}
			}

			// Reset the PLL
			pll_reset(pll_assignment[clk]);
		}
		else
		{
			clk_freq[(uint8_t)clk] = freq;

			// Enable the output on first set_freq only
			if(clk_first_set[(uint8_t)clk] == false)
			{
				output_enable(clk, 1);
				clk_first_set[(uint8_t)clk] = true;
			}

			// Select the proper R div value
			r_div = select_r_div(&freq);

			// Calculate the synth parameters
			if(pll_assignment[clk] == SI5351_PLLA)
			{
				multisynth_calc(freq, plla_freq, &ms_reg);
			}
			else
			{
				multisynth_calc(freq, pllb_freq, &ms_reg);
			}

			// Set multisynth registers
			set_ms(clk, ms_reg, int_mode, r_div, div_by_4);

			// Reset the PLL
			//pll_reset(pll_assignment[clk]);
		}

		return 0;
	}
	else
	{
		// MS6 and MS7 logic
		// -----------------

		// Lower bounds check
		if(freq > 0 && freq < SI5351_CLKOUT67_MIN_FREQ * SI5351_FREQ_MULT)
		{
			freq = SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT;
		}

		// Upper bounds check
		if(freq >= SI5351_MULTISYNTH_DIVBY4_FREQ * SI5351_FREQ_MULT)
		{
			freq = SI5351_MULTISYNTH_DIVBY4_FREQ * SI5351_FREQ_MULT - 1;
		}

		// If one of CLK6 or CLK7 is already set when trying to set the other,
		// we have to ensure that it will also have an integer division ratio
		// with the same PLL, otherwise do not set it.
		if(clk == SI5351_CLK6)
		{
			if(clk_freq[7] != 0)
			{
				if(pllb_freq % freq == 0)
				{
					if((pllb_freq / freq) % 2 != 0)
					{
						// Not an even divide ratio, no bueno
						return 1;
					}
					else
					{
						// Set the freq in memory
						clk_freq[(uint8_t)clk] = freq;

						// Select the proper R div value
						r_div = select_r_div_ms67(&freq);

						multisynth67_calc(freq, pllb_freq, &ms_reg);
					}
				}
				else
				{
					// Not an integer divide ratio, no good
					return 1;
				}
			}
			else
			{
				// No previous assignment, so set PLLB based on CLK6

				// Set the freq in memory
				clk_freq[(uint8_t)clk] = freq;

				// Select the proper R div value
				r_div = select_r_div_ms67(&freq);

				pll_freq = multisynth67_calc(freq, 0, &ms_reg);
				//pllb_freq = pll_freq;
				set_pll(pll_freq, SI5351_PLLB);
			}
		}
		else
		{
			if(clk_freq[6] != 0)
			{
				if(pllb_freq % freq == 0)
				{
					if((pllb_freq / freq) % 2 != 0)
					{
						// Not an even divide ratio, no bueno
						return 1;
					}
					else
					{
						// Set the freq in memory
						clk_freq[(uint8_t)clk] = freq;

						// Select the proper R div value
						r_div = select_r_div_ms67(&freq);

						multisynth67_calc(freq, pllb_freq, &ms_reg);
					}
				}
				else
				{
					// Not an integer divide ratio, no good
					return 1;
				}
			}
			else
			{
				// No previous assignment, so set PLLB based on CLK7

				// Set the freq in memory
				clk_freq[(uint8_t)clk] = freq;

				// Select the proper R div value
				r_div = select_r_div_ms67(&freq);

				pll_freq = multisynth67_calc(freq, 0, &ms_reg);
				//pllb_freq = pll_freq;
				set_pll(pll_freq, pll_assignment[clk]);
			}
		}

		div_by_4 = 0;
		int_mode = 0;

		// Set multisynth registers (MS must be set before PLL)
		set_ms(clk, ms_reg, int_mode, r_div, div_by_4);

		return 0;
	}
}

/*
 * set_freq_manual(uint64_t freq, uint64_t pll_freq, enum si5351_clock clk)
 *
 * Sets the clock frequency of the specified CLK output using the given PLL
 * frequency. You must ensure that the MS is assigned to the correct PLL and
 * that the PLL is set to the correct frequency before using this method.
 *
 * It is important to note that if you use this method, you will have to
 * track that all settings are sane yourself.
 *
 * freq - Output frequency in Hz
 * pll_freq - Frequency of the PLL driving the Multisynth in Hz * 100
 * clk - Clock output
 *   (use the si5351_clock enum)
 */
uint8_t Si5351::set_freq_manual(uint64_t freq, uint64_t pll_freq, enum si5351_clock clk)
{
	struct Si5351RegSet ms_reg;
	uint8_t int_mode = 0;
	uint8_t div_by_4 = 0;

	// Lower bounds check
	if(freq > 0 && freq < SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT)
	{
		freq = SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT;
	}

	// Upper bounds check
	if(freq > SI5351_CLKOUT_MAX_FREQ * SI5351_FREQ_MULT)
	{
		freq = SI5351_CLKOUT_MAX_FREQ * SI5351_FREQ_MULT;
	}

	uint8_t r_div;

	clk_freq[(uint8_t)clk] = freq;

	set_pll(pll_freq, pll_assignment[clk]);

	// Enable the output
	output_enable(clk, 1);

	// Select the proper R div value
	r_div = select_r_div(&freq);

	// Calculate the synth parameters
	multisynth_calc(freq, pll_freq, &ms_reg);

	// If freq > 150 MHz, we need to use DIVBY4 and integer mode
	if(freq >= SI5351_MULTISYNTH_DIVBY4_FREQ * SI5351_FREQ_MULT)
	{
		div_by_4 = 1;
		int_mode = 1;
	}

	// Set multisynth registers (MS must be set before PLL)
	set_ms(clk, ms_reg, int_mode, r_div, div_by_4);

    return 0;
}

/*
 * set_pll(uint64_t pll_freq, enum si5351_pll target_pll)
 *
 * Set the specified PLL to a specific oscillation frequency
 *
 * pll_freq - Desired PLL frequency in Hz * 100
 * target_pll - Which PLL to set
 *     (use the si5351_pll enum)
 */
void Si5351::set_pll(uint64_t pll_freq, enum si5351_pll target_pll)
{
  struct Si5351RegSet pll_reg;

	if(target_pll == SI5351_PLLA)
	{
		pll_calc(SI5351_PLLA, pll_freq, &pll_reg, ref_correction[plla_ref_osc], 0);
	}
	else
	{
		pll_calc(SI5351_PLLB, pll_freq, &pll_reg, ref_correction[pllb_ref_osc], 0);
	}

  // Derive the register values to write

  // Prepare an array for parameters to be written to
  uint8_t *params = new uint8_t[20];
  uint8_t i = 0;
  uint8_t temp;

  // Registers 26-27
  temp = ((pll_reg.p3 >> 8) & 0xFF);
  params[i++] = temp;

  temp = (uint8_t)(pll_reg.p3  & 0xFF);
  params[i++] = temp;

  // Register 28
  temp = (uint8_t)((pll_reg.p1 >> 16) & 0x03);
  params[i++] = temp;

  // Registers 29-30
  temp = (uint8_t)((pll_reg.p1 >> 8) & 0xFF);
  params[i++] = temp;

  temp = (uint8_t)(pll_reg.p1  & 0xFF);
  params[i++] = temp;

  // Register 31
  temp = (uint8_t)((pll_reg.p3 >> 12) & 0xF0);
  temp += (uint8_t)((pll_reg.p2 >> 16) & 0x0F);
  params[i++] = temp;

  // Registers 32-33
  temp = (uint8_t)((pll_reg.p2 >> 8) & 0xFF);
  params[i++] = temp;

  temp = (uint8_t)(pll_reg.p2  & 0xFF);
  params[i++] = temp;

  // Write the parameters
  if(target_pll == SI5351_PLLA)
  {
    si5351_write_bulk(SI5351_PLLA_PARAMETERS, i, params);
		plla_freq = pll_freq;
  }
  else if(target_pll == SI5351_PLLB)
  {
    si5351_write_bulk(SI5351_PLLB_PARAMETERS, i, params);
		pllb_freq = pll_freq;
  }

  delete params;
}

/*
 * set_ms(enum si5351_clock clk, struct Si5351RegSet ms_reg, uint8_t int_mode, uint8_t r_div, uint8_t div_by_4)
 *
 * Set the specified multisynth parameters. Not normally needed, but public for advanced users.
 *
 * clk - Clock output
 *   (use the si5351_clock enum)
 * int_mode - Set integer mode
 *  Set to 1 to enable, 0 to disable
 * r_div - Desired r_div ratio
 * div_by_4 - Set Divide By 4 mode
 *   Set to 1 to enable, 0 to disable
 */
void Si5351::set_ms(enum si5351_clock clk, struct Si5351RegSet ms_reg, uint8_t int_mode, uint8_t r_div, uint8_t div_by_4)
{
	uint8_t *params = new uint8_t[20];
	uint8_t i = 0;
 	uint8_t temp;
 	uint8_t reg_val;


	if((uint8_t)clk <= (uint8_t)SI5351_CLK5)
	{
		// Registers 42-43 for CLK0
		temp = (uint8_t)((ms_reg.p3 >> 8) & 0xFF);
		params[i++] = temp;

		temp = (uint8_t)(ms_reg.p3  & 0xFF);
		params[i++] = temp;

		// Register 44 for CLK0
		reg_val = si5351_read((SI5351_CLK0_PARAMETERS + 2) + (clk * 8));
		reg_val &= ~(0x03);
		temp = reg_val | ((uint8_t)((ms_reg.p1 >> 16) & 0x03));
		params[i++] = temp;

		// Registers 45-46 for CLK0
		temp = (uint8_t)((ms_reg.p1 >> 8) & 0xFF);
		params[i++] = temp;

		temp = (uint8_t)(ms_reg.p1  & 0xFF);
		params[i++] = temp;

		// Register 47 for CLK0
		temp = (uint8_t)((ms_reg.p3 >> 12) & 0xF0);
		temp += (uint8_t)((ms_reg.p2 >> 16) & 0x0F);
		params[i++] = temp;

		// Registers 48-49 for CLK0
		temp = (uint8_t)((ms_reg.p2 >> 8) & 0xFF);
		params[i++] = temp;

		temp = (uint8_t)(ms_reg.p2  & 0xFF);
		params[i++] = temp;
	}
	else
	{
		// MS6 and MS7 only use one register
		temp = ms_reg.p1;
	}

	// Write the parameters
	switch(clk)
	{
		case SI5351_CLK0:
			si5351_write_bulk(SI5351_CLK0_PARAMETERS, i, params);
			set_int(clk, int_mode);
			ms_div(clk, r_div, div_by_4);
			break;
		case SI5351_CLK1:
			si5351_write_bulk(SI5351_CLK1_PARAMETERS, i, params);
			set_int(clk, int_mode);
			ms_div(clk, r_div, div_by_4);
			break;
		case SI5351_CLK2:
			si5351_write_bulk(SI5351_CLK2_PARAMETERS, i, params);
			set_int(clk, int_mode);
			ms_div(clk, r_div, div_by_4);
			break;
		case SI5351_CLK3:
			si5351_write_bulk(SI5351_CLK3_PARAMETERS, i, params);
			set_int(clk, int_mode);
			ms_div(clk, r_div, div_by_4);
			break;
		case SI5351_CLK4:
			si5351_write_bulk(SI5351_CLK4_PARAMETERS, i, params);
			set_int(clk, int_mode);
			ms_div(clk, r_div, div_by_4);
			break;
		case SI5351_CLK5:
			si5351_write_bulk(SI5351_CLK5_PARAMETERS, i, params);
			set_int(clk, int_mode);
			ms_div(clk, r_div, div_by_4);
			break;
		case SI5351_CLK6:
			si5351_write(SI5351_CLK6_PARAMETERS, temp);
			ms_div(clk, r_div, div_by_4);
			break;
		case SI5351_CLK7:
			si5351_write(SI5351_CLK7_PARAMETERS, temp);
			ms_div(clk, r_div, div_by_4);
			break;
	}

	delete params;
}

/*
 * output_enable(enum si5351_clock clk, uint8_t enable)
 *
 * Enable or disable a chosen output
 * clk - Clock output
 *   (use the si5351_clock enum)
 * enable - Set to 1 to enable, 0 to disable
 */
void Si5351::output_enable(enum si5351_clock clk, uint8_t enable)
{
  uint8_t reg_val;

  reg_val = si5351_read(SI5351_OUTPUT_ENABLE_CTRL);

  if(enable == 1)
  {
    reg_val &= ~(1<<(uint8_t)clk);
  }
  else
  {
    reg_val |= (1<<(uint8_t)clk);
  }

  si5351_write(SI5351_OUTPUT_ENABLE_CTRL, reg_val);
}

/*
 * drive_strength(enum si5351_clock clk, enum si5351_drive drive)
 *
 * Sets the drive strength of the specified clock output
 *
 * clk - Clock output
 *   (use the si5351_clock enum)
 * drive - Desired drive level
 *   (use the si5351_drive enum)
 */
void Si5351::drive_strength(enum si5351_clock clk, enum si5351_drive drive)
{
  uint8_t reg_val;
  const uint8_t mask = 0x03;

  reg_val = si5351_read(SI5351_CLK0_CTRL + (uint8_t)clk);
  reg_val &= ~(mask);

  switch(drive)
  {
  case SI5351_DRIVE_2MA:
    reg_val |= 0x00;
    break;
  case SI5351_DRIVE_4MA:
   reg_val |= 0x01;
    break;
  case SI5351_DRIVE_6MA:
    reg_val |= 0x02;
    break;
  case SI5351_DRIVE_8MA:
    reg_val |= 0x03;
    break;
  default:
    break;
  }

  si5351_write(SI5351_CLK0_CTRL + (uint8_t)clk, reg_val);
}

/*
 * update_status(void)
 *
 * Call this to update the status structs, then access them
 * via the dev_status and dev_int_status global members.
 *
 * See the header file for the struct definitions. These
 * correspond to the flag names for registers 0 and 1 in
 * the Si5351 datasheet.
 */
void Si5351::update_status(void)
{
	update_sys_status(&dev_status);
	update_int_status(&dev_int_status);
}

/*
 * set_correction(int32_t corr, enum si5351_pll_input ref_osc)
 *
 * corr - Correction factor in ppb
 * ref_osc - Desired reference oscillator
 *     (use the si5351_pll_input enum)
 *
 * Use this to set the oscillator correction factor.
 * This value is a signed 32-bit integer of the
 * parts-per-billion value that the actual oscillation
 * frequency deviates from the specified frequency.
 *
 * The frequency calibration is done as a one-time procedure.
 * Any desired test frequency within the normal range of the
 * Si5351 should be set, then the actual output frequency
 * should be measured as accurately as possible. The
 * difference between the measured and specified frequencies
 * should be calculated in Hertz, then multiplied by 10 in
 * order to get the parts-per-billion value.
 *
 * Since the Si5351 itself has an intrinsic 0 PPM error, this
 * correction factor is good across the entire tuning range of
 * the Si5351. Once this calibration is done accurately, it
 * should not have to be done again for the same Si5351 and
 * crystal.
 */
void Si5351::set_correction(int32_t corr, enum si5351_pll_input ref_osc)
{
	ref_correction[(uint8_t)ref_osc] = corr;

	// Recalculate and set PLL freqs based on correction value
	set_pll(plla_freq, SI5351_PLLA);
	set_pll(pllb_freq, SI5351_PLLB);
}

/*
 * set_phase(enum si5351_clock clk, uint8_t phase)
 *
 * clk - Clock output
 *   (use the si5351_clock enum)
 * phase - 7-bit phase word
 *   (in units of VCO/4 period)
 *
 * Write the 7-bit phase register. This must be used
 * with a user-set PLL frequency so that the user can
 * calculate the proper tuning word based on the PLL period.
 */
void Si5351::set_phase(enum si5351_clock clk, uint8_t phase)
{
	// Mask off the upper bit since it is reserved
	phase = phase & 0b01111111;

	si5351_write(SI5351_CLK0_PHASE_OFFSET + (uint8_t)clk, phase);
}

/*
 * get_correction(enum si5351_pll_input ref_osc)
 *
 * ref_osc - Desired reference oscillator
 *     0: crystal oscillator (XO)
 *     1: external clock input (CLKIN)
 *
 * Returns the oscillator correction factor stored
 * in RAM.
 */
int32_t Si5351::get_correction(enum si5351_pll_input ref_osc)
{
	return ref_correction[(uint8_t)ref_osc];
}

/*
 * pll_reset(enum si5351_pll target_pll)
 *
 * target_pll - Which PLL to reset
 *     (use the si5351_pll enum)
 *
 * Apply a reset to the indicated PLL.
 */
void Si5351::pll_reset(enum si5351_pll target_pll)
{
	if(target_pll == SI5351_PLLA)
 	{
    	si5351_write(SI5351_PLL_RESET, SI5351_PLL_RESET_A);
	}
	else if(target_pll == SI5351_PLLB)
	{
	    si5351_write(SI5351_PLL_RESET, SI5351_PLL_RESET_B);
	}
}

/*
 * set_ms_source(enum si5351_clock clk, enum si5351_pll pll)
 *
 * clk - Clock output
 *   (use the si5351_clock enum)
 * pll - Which PLL to use as the source
 *     (use the si5351_pll enum)
 *
 * Set the desired PLL source for a multisynth.
 */
void Si5351::set_ms_source(enum si5351_clock clk, enum si5351_pll pll)
{
	uint8_t reg_val;

	reg_val = si5351_read(SI5351_CLK0_CTRL + (uint8_t)clk);

	if(pll == SI5351_PLLA)
	{
		reg_val &= ~(SI5351_CLK_PLL_SELECT);
	}
	else if(pll == SI5351_PLLB)
	{
		reg_val |= SI5351_CLK_PLL_SELECT;
	}

	si5351_write(SI5351_CLK0_CTRL + (uint8_t)clk, reg_val);

	pll_assignment[(uint8_t)clk] = pll;
}

/*
 * set_int(enum si5351_clock clk, uint8_t int_mode)
 *
 * clk - Clock output
 *   (use the si5351_clock enum)
 * enable - Set to 1 to enable, 0 to disable
 *
 * Set the indicated multisynth into integer mode.
 */
void Si5351::set_int(enum si5351_clock clk, uint8_t enable)
{
	uint8_t reg_val;
	reg_val = si5351_read(SI5351_CLK0_CTRL + (uint8_t)clk);

	if(enable == 1)
	{
		reg_val |= (SI5351_CLK_INTEGER_MODE);
	}
	else
	{
		reg_val &= ~(SI5351_CLK_INTEGER_MODE);
	}

	si5351_write(SI5351_CLK0_CTRL + (uint8_t)clk, reg_val);

	// Integer mode indication
	/*
	switch(clk)
	{
	case SI5351_CLK0:
		clk0_int_mode = enable;
		break;
	case SI5351_CLK1:
		clk1_int_mode = enable;
		break;
	case SI5351_CLK2:
		clk2_int_mode = enable;
		break;
	default:
		break;
	}
	*/
}

/*
 * set_clock_pwr(enum si5351_clock clk, uint8_t pwr)
 *
 * clk - Clock output
 *   (use the si5351_clock enum)
 * pwr - Set to 1 to enable, 0 to disable
 *
 * Enable or disable power to a clock output (a power
 * saving feature).
 */
void Si5351::set_clock_pwr(enum si5351_clock clk, uint8_t pwr)
{
	uint8_t reg_val; //, reg;
	reg_val = si5351_read(SI5351_CLK0_CTRL + (uint8_t)clk);

	if(pwr == 1)
	{
		reg_val &= 0b01111111;
	}
	else
	{
		reg_val |= 0b10000000;
	}

	si5351_write(SI5351_CLK0_CTRL + (uint8_t)clk, reg_val);
}

/*
 * set_clock_invert(enum si5351_clock clk, uint8_t inv)
 *
 * clk - Clock output
 *   (use the si5351_clock enum)
 * inv - Set to 1 to enable, 0 to disable
 *
 * Enable to invert the clock output waveform.
 */
void Si5351::set_clock_invert(enum si5351_clock clk, uint8_t inv)
{
	uint8_t reg_val;
	reg_val = si5351_read(SI5351_CLK0_CTRL + (uint8_t)clk);

	if(inv == 1)
	{
		reg_val |= (SI5351_CLK_INVERT);
	}
	else
	{
		reg_val &= ~(SI5351_CLK_INVERT);
	}

	si5351_write(SI5351_CLK0_CTRL + (uint8_t)clk, reg_val);
}

/*
 * set_clock_source(enum si5351_clock clk, enum si5351_clock_source src)
 *
 * clk - Clock output
 *   (use the si5351_clock enum)
 * src - Which clock source to use for the multisynth
 *   (use the si5351_clock_source enum)
 *
 * Set the clock source for a multisynth (based on the options
 * presented for Registers 16-23 in the Silicon Labs AN619 document).
 * Choices are XTAL, CLKIN, MS0, or the multisynth associated with
 * the clock output.
 */
void Si5351::set_clock_source(enum si5351_clock clk, enum si5351_clock_source src)
{
	uint8_t reg_val;
	reg_val = si5351_read(SI5351_CLK0_CTRL + (uint8_t)clk);

	// Clear the bits first
	reg_val &= ~(SI5351_CLK_INPUT_MASK);

	switch(src)
	{
	case SI5351_CLK_SRC_XTAL:
		reg_val |= (SI5351_CLK_INPUT_XTAL);
		break;
	case SI5351_CLK_SRC_CLKIN:
		reg_val |= (SI5351_CLK_INPUT_CLKIN);
		break;
	case SI5351_CLK_SRC_MS0:
		if(clk == SI5351_CLK0)
		{
			return;
		}

		reg_val |= (SI5351_CLK_INPUT_MULTISYNTH_0_4);
		break;
	case SI5351_CLK_SRC_MS:
		reg_val |= (SI5351_CLK_INPUT_MULTISYNTH_N);
		break;
	default:
		return;
	}

	si5351_write(SI5351_CLK0_CTRL + (uint8_t)clk, reg_val);
}

/*
 * set_clock_disable(enum si5351_clock clk, enum si5351_clock_disable dis_state)
 *
 * clk - Clock output
 *   (use the si5351_clock enum)
 * dis_state - Desired state of the output upon disable
 *   (use the si5351_clock_disable enum)
 *
 * Set the state of the clock output when it is disabled. Per page 27
 * of AN619 (Registers 24 and 25), there are four possible values: low,
 * high, high impedance, and never disabled.
 */
void Si5351::set_clock_disable(enum si5351_clock clk, enum si5351_clock_disable dis_state)
{
	uint8_t reg_val, reg;

	if (clk >= SI5351_CLK0 && clk <= SI5351_CLK3)
	{
		reg = SI5351_CLK3_0_DISABLE_STATE;
	}
	else if(clk >= SI5351_CLK4 && clk <= SI5351_CLK7)
	{
		reg = SI5351_CLK7_4_DISABLE_STATE;
	}
	else return;

	reg_val = si5351_read(reg);

	if (clk >= SI5351_CLK0 && clk <= SI5351_CLK3)
	{
		reg_val &= ~(0b11 << (clk * 2));
		reg_val |= dis_state << (clk * 2);
	}
	else if(clk >= SI5351_CLK4 && clk <= SI5351_CLK7)
	{
		reg_val &= ~(0b11 << ((clk - 4) * 2));
		reg_val |= dis_state << ((clk - 4) * 2);
	}

	si5351_write(reg, reg_val);
}

/*
 * set_clock_fanout(enum si5351_clock_fanout fanout, uint8_t enable)
 *
 * fanout - Desired clock fanout
 *   (use the si5351_clock_fanout enum)
 * enable - Set to 1 to enable, 0 to disable
 *
 * Use this function to enable or disable the clock fanout options
 * for individual clock outputs. If you intend to output the XO or
 * CLKIN on the clock outputs, enable this first.
 *
 * By default, only the Multisynth fanout is enabled at startup.
 */
void Si5351::set_clock_fanout(enum si5351_clock_fanout fanout, uint8_t enable)
{
	uint8_t reg_val;
	reg_val = si5351_read(SI5351_FANOUT_ENABLE);

	switch(fanout)
	{
	case SI5351_FANOUT_CLKIN:
		if(enable)
		{
			reg_val |= SI5351_CLKIN_ENABLE;
		}
		else
		{
			reg_val &= ~(SI5351_CLKIN_ENABLE);
		}
		break;
	case SI5351_FANOUT_XO:
		if(enable)
		{
			reg_val |= SI5351_XTAL_ENABLE;
		}
		else
		{
			reg_val &= ~(SI5351_XTAL_ENABLE);
		}
		break;
	case SI5351_FANOUT_MS:
		if(enable)
		{
			reg_val |= SI5351_MULTISYNTH_ENABLE;
		}
		else
		{
			reg_val &= ~(SI5351_MULTISYNTH_ENABLE);
		}
		break;
	}

	si5351_write(SI5351_FANOUT_ENABLE, reg_val);
}

/*
 * set_pll_input(enum si5351_pll pll, enum si5351_pll_input input)
 *
 * pll - Which PLL to use as the source
 *     (use the si5351_pll enum)
 * input - Which reference oscillator to use as PLL input
 *     (use the si5351_pll_input enum)
 *
 * Set the desired reference oscillator source for the given PLL.
 */
void Si5351::set_pll_input(enum si5351_pll pll, enum si5351_pll_input input)
{
	uint8_t reg_val;
	reg_val = si5351_read(SI5351_PLL_INPUT_SOURCE);

	// Clear the bits first
	//reg_val &= ~(SI5351_CLKIN_DIV_MASK);

	switch(pll)
	{
	case SI5351_PLLA:
		if(input == SI5351_PLL_INPUT_CLKIN)
		{
			reg_val |= SI5351_PLLA_SOURCE;
			reg_val |= clkin_div;
			plla_ref_osc = SI5351_PLL_INPUT_CLKIN;
		}
		else
		{
			reg_val &= ~(SI5351_PLLA_SOURCE);
			plla_ref_osc = SI5351_PLL_INPUT_XO;
		}
		break;
	case SI5351_PLLB:
		if(input == SI5351_PLL_INPUT_CLKIN)
		{
			reg_val |= SI5351_PLLB_SOURCE;
			reg_val |= clkin_div;
			pllb_ref_osc = SI5351_PLL_INPUT_CLKIN;
		}
		else
		{
			reg_val &= ~(SI5351_PLLB_SOURCE);
			pllb_ref_osc = SI5351_PLL_INPUT_XO;
		}
		break;
	default:
		return;
	}

	si5351_write(SI5351_PLL_INPUT_SOURCE, reg_val);

	set_pll(plla_freq, SI5351_PLLA);
	set_pll(pllb_freq, SI5351_PLLB);
}

/*
 * set_vcxo(uint64_t pll_freq, uint8_t ppm)
 *
 * pll_freq - Desired PLL base frequency in Hz * 100
 * ppm - VCXO pull limit in ppm
 *
 * Set the parameters for the VCXO on the Si5351B.
 */
void Si5351::set_vcxo(uint64_t pll_freq, uint8_t ppm)
{
	struct Si5351RegSet pll_reg;
	uint64_t vcxo_param;

	// Bounds check
	if(ppm < SI5351_VCXO_PULL_MIN)
	{
		ppm = SI5351_VCXO_PULL_MIN;
	}

	if(ppm > SI5351_VCXO_PULL_MAX)
	{
		ppm = SI5351_VCXO_PULL_MAX;
	}

	// Set PLLB params
	vcxo_param = pll_calc(SI5351_PLLB, pll_freq, &pll_reg, ref_correction[pllb_ref_osc], 1);

	// Derive the register values to write

	// Prepare an array for parameters to be written to
	uint8_t *params = new uint8_t[20];
	uint8_t i = 0;
	uint8_t temp;

	// Registers 26-27
	temp = ((pll_reg.p3 >> 8) & 0xFF);
	params[i++] = temp;

	temp = (uint8_t)(pll_reg.p3  & 0xFF);
	params[i++] = temp;

	// Register 28
	temp = (uint8_t)((pll_reg.p1 >> 16) & 0x03);
	params[i++] = temp;

	// Registers 29-30
	temp = (uint8_t)((pll_reg.p1 >> 8) & 0xFF);
	params[i++] = temp;

	temp = (uint8_t)(pll_reg.p1  & 0xFF);
	params[i++] = temp;

	// Register 31
	temp = (uint8_t)((pll_reg.p3 >> 12) & 0xF0);
	temp += (uint8_t)((pll_reg.p2 >> 16) & 0x0F);
	params[i++] = temp;

	// Registers 32-33
	temp = (uint8_t)((pll_reg.p2 >> 8) & 0xFF);
	params[i++] = temp;

	temp = (uint8_t)(pll_reg.p2  & 0xFF);
	params[i++] = temp;

	// Write the parameters
	si5351_write_bulk(SI5351_PLLB_PARAMETERS, i, params);

	delete params;

	// Write the VCXO parameters
	vcxo_param = ((vcxo_param * ppm * SI5351_VCXO_MARGIN) / 100ULL) / 1000000ULL;

	temp = (uint8_t)(vcxo_param & 0xFF);
	si5351_write(SI5351_VXCO_PARAMETERS_LOW, temp);

	temp = (uint8_t)((vcxo_param >> 8) & 0xFF);
	si5351_write(SI5351_VXCO_PARAMETERS_MID, temp);

	temp = (uint8_t)((vcxo_param >> 16) & 0x3F);
	si5351_write(SI5351_VXCO_PARAMETERS_HIGH, temp);
}

/*
 * set_ref_freq(uint32_t ref_freq, enum si5351_pll_input ref_osc)
 *
 * ref_freq - Reference oscillator frequency in Hz
 * ref_osc - Which reference oscillator frequency to set
 *    (use the si5351_pll_input enum)
 *
 * Set the reference frequency value for the desired reference oscillator
 */
void Si5351::set_ref_freq(uint32_t ref_freq, enum si5351_pll_input ref_osc)
{
	// uint8_t reg_val;
	//reg_val = si5351_read(SI5351_PLL_INPUT_SOURCE);

	// Clear the bits first
	//reg_val &= ~(SI5351_CLKIN_DIV_MASK);

	if(ref_freq <= 30000000UL)
	{
		xtal_freq[(uint8_t)ref_osc] = ref_freq;
		//reg_val |= SI5351_CLKIN_DIV_1;
		if(ref_osc == SI5351_PLL_INPUT_CLKIN)
		{
			clkin_div = SI5351_CLKIN_DIV_1;
		}
	}
	else if(ref_freq > 30000000UL && ref_freq <= 60000000UL)
	{
		xtal_freq[(uint8_t)ref_osc] = ref_freq / 2;
		//reg_val |= SI5351_CLKIN_DIV_2;
		if(ref_osc == SI5351_PLL_INPUT_CLKIN)
		{
			clkin_div = SI5351_CLKIN_DIV_2;
		}
	}
	else if(ref_freq > 60000000UL && ref_freq <= 100000000UL)
	{
		xtal_freq[(uint8_t)ref_osc] = ref_freq / 4;
		//reg_val |= SI5351_CLKIN_DIV_4;
		if(ref_osc == SI5351_PLL_INPUT_CLKIN)
		{
			clkin_div = SI5351_CLKIN_DIV_4;
		}
	}
	else
	{
		//reg_val |= SI5351_CLKIN_DIV_1;
	}

	//si5351_write(SI5351_PLL_INPUT_SOURCE, reg_val);
}

uint8_t Si5351::si5351_write_bulk(uint8_t addr, uint8_t bytes, uint8_t *data)
{
#ifndef RASPBERRY_PI_I2C
	Wire.beginTransmission(i2c_bus_addr);
	Wire.write(addr);
	for(int i = 0; i < bytes; i++)
	{
		Wire.write(data[i]);
	}
	return Wire.endTransmission();
#endif

#ifdef RASPBERRY_PI_I2C
int result = -1;
uint8_t buf[33];

	if (bytes <= 31)
		{
		buf[0] = addr;
		memcpy(&buf[1], data, bytes);
		result = write(si5351fd, buf, bytes+1);
		if (result > 0)
			result--;
		}
	return result = 0x0ff;	
#endif
}

uint8_t Si5351::si5351_write(uint8_t addr, uint8_t data)
{
#ifndef RASPBERRY_PI_I2C
	Wire.beginTransmission(i2c_bus_addr);
	Wire.write(addr);
	Wire.write(data);
	return Wire.endTransmission();
#endif

#ifdef RASPBERRY_PI_I2C
uint8_t buf[2];

	buf[0]=addr; buf[1]=data;
	int result = write(si5351fd, buf, 2);
	return (result < 0) ? 0 : 1;
#endif
}

uint8_t Si5351::si5351_read(uint8_t addr)
{
#ifndef RASPBERRY_PI_I2C
	uint8_t reg_val = 0;

	Wire.beginTransmission(i2c_bus_addr);
	Wire.write(addr);
	Wire.endTransmission();

	Wire.requestFrom(i2c_bus_addr, (uint8_t)1, (uint8_t)false);

	while(Wire.available())
	{
		reg_val = Wire.read();
	}

	return reg_val;
#endif

#ifdef RASPBERRY_PI_I2C
	uint8_t reg_val = 0;
	uint8_t buf[33];
	
	buf[0] = addr;
	int readcount = 0;

	//	caller seems to expect only last byte if more than one received (!)
	if ((write(si5351fd, buf, 1) == 1) && ((readcount = read(si5351fd, buf, 1)) > 0))
//		reg_val = buf[readcount-1];
		reg_val = buf[0];
	return reg_val;

#endif
}

/*********************/
/* Private functions */
/*********************/

uint64_t Si5351::pll_calc(enum si5351_pll pll, uint64_t freq, struct Si5351RegSet *reg, int32_t correction, uint8_t vcxo)
{
	uint64_t ref_freq;
	if(pll == SI5351_PLLA)
	{
		ref_freq = xtal_freq[(uint8_t)plla_ref_osc] * SI5351_FREQ_MULT;
	}
	else
	{
		ref_freq = xtal_freq[(uint8_t)pllb_ref_osc] * SI5351_FREQ_MULT;
	}
	//ref_freq = 15974400ULL * SI5351_FREQ_MULT;
	uint32_t a, b, c, p1, p2, p3;
	uint64_t lltmp; //, denom;

	// Factor calibration value into nominal crystal frequency
	// Measured in parts-per-billion

	ref_freq = ref_freq + (int32_t)((((((int64_t)correction) << 31) / 1000000000LL) * ref_freq) >> 31);

	// PLL bounds checking
	if (freq < SI5351_PLL_VCO_MIN * SI5351_FREQ_MULT)
	{
		freq = SI5351_PLL_VCO_MIN * SI5351_FREQ_MULT;
	}
	if (freq > SI5351_PLL_VCO_MAX * SI5351_FREQ_MULT)
	{
		freq = SI5351_PLL_VCO_MAX * SI5351_FREQ_MULT;
	}

	// Determine integer part of feedback equation
	a = freq / ref_freq;

	if (a < SI5351_PLL_A_MIN)
	{
		freq = ref_freq * SI5351_PLL_A_MIN;
	}
	if (a > SI5351_PLL_A_MAX)
	{
		freq = ref_freq * SI5351_PLL_A_MAX;
	}

	// Find best approximation for b/c = fVCO mod fIN
	// denom = 1000ULL * 1000ULL;
	// lltmp = freq % ref_freq;
	// lltmp *= denom;
	// do_div(lltmp, ref_freq);

	//b = (((uint64_t)(freq % ref_freq)) * RFRAC_DENOM) / ref_freq;
	if(vcxo)
	{
		b = (((uint64_t)(freq % ref_freq)) * 1000000ULL) / ref_freq;
		c = 1000000ULL;
	}
	else
	{
		b = (((uint64_t)(freq % ref_freq)) * RFRAC_DENOM) / ref_freq;
		c = b ? RFRAC_DENOM : 1;
	}

	// Calculate parameters
  p1 = 128 * a + ((128 * b) / c) - 512;
  p2 = 128 * b - c * ((128 * b) / c);
  p3 = c;

	// Recalculate frequency as fIN * (a + b/c)
	lltmp = ref_freq;
	lltmp *= b;
	do_div(lltmp, c);
	freq = lltmp;
	freq += ref_freq * a;

	reg->p1 = p1;
	reg->p2 = p2;
	reg->p3 = p3;

	if(vcxo)
	{
		return (uint64_t)(128 * a * 1000000ULL + b);
	}
	else
	{
		return freq;
	}
}

uint64_t Si5351::multisynth_calc(uint64_t freq, uint64_t pll_freq, struct Si5351RegSet *reg)
{
	uint64_t lltmp;
	uint32_t a, b, c, p1, p2, p3;
	uint8_t divby4 = 0;
	uint8_t ret_val = 0;

	// Multisynth bounds checking
	if (freq > SI5351_MULTISYNTH_MAX_FREQ * SI5351_FREQ_MULT)
	{
		freq = SI5351_MULTISYNTH_MAX_FREQ * SI5351_FREQ_MULT;
	}
	if (freq < SI5351_MULTISYNTH_MIN_FREQ * SI5351_FREQ_MULT)
	{
		freq = SI5351_MULTISYNTH_MIN_FREQ * SI5351_FREQ_MULT;
	}

	if (freq >= SI5351_MULTISYNTH_DIVBY4_FREQ * SI5351_FREQ_MULT)
	{
		divby4 = 1;
	}

	if(pll_freq == 0)
	{
		// Find largest integer divider for max
		// VCO frequency and given target frequency
		if(divby4 == 0)
		{
			lltmp = SI5351_PLL_VCO_MAX * SI5351_FREQ_MULT; // margin needed?
			do_div(lltmp, freq);
			if(lltmp == 5)
			{
				lltmp = 4;
			}
			else if(lltmp == 7)
			{
				lltmp = 6;
			}
			a = (uint32_t)lltmp;
		}
		else
		{
			a = 4;
		}

		b = 0;
		c = 1;
		pll_freq = a * freq;
	}
	else
	{
		// Preset PLL, so return the actual freq for these params instead of PLL freq
		ret_val = 1;

		// Determine integer part of feedback equation
		a = pll_freq / freq;

		if (a < SI5351_MULTISYNTH_A_MIN)
		{
			freq = pll_freq / SI5351_MULTISYNTH_A_MIN;
		}
		if (a > SI5351_MULTISYNTH_A_MAX)
		{
			freq = pll_freq / SI5351_MULTISYNTH_A_MAX;
		}

		b = (pll_freq % freq * RFRAC_DENOM) / freq;
		c = b ? RFRAC_DENOM : 1;
	}

	// Calculate parameters
	if (divby4 == 1)
	{
		p3 = 1;
		p2 = 0;
		p1 = 0;
	}
	else
	{
    p1 = 128 * a + ((128 * b) / c) - 512;
    p2 = 128 * b - c * ((128 * b) / c);
    p3 = c;
	}

	reg->p1 = p1;
	reg->p2 = p2;
	reg->p3 = p3;

	if(ret_val == 0)
	{
		return pll_freq;
	}
	else
	{
		return freq;
	}
}

uint64_t Si5351::multisynth67_calc(uint64_t freq, uint64_t pll_freq, struct Si5351RegSet *reg)
{
	//uint8_t p1;
	// uint8_t ret_val = 0;
	uint32_t a;
	uint64_t lltmp;

	// Multisynth bounds checking
	if(freq > SI5351_MULTISYNTH67_MAX_FREQ * SI5351_FREQ_MULT)
	{
		freq = SI5351_MULTISYNTH67_MAX_FREQ * SI5351_FREQ_MULT;
	}
	if(freq < SI5351_MULTISYNTH_MIN_FREQ * SI5351_FREQ_MULT)
	{
		freq = SI5351_MULTISYNTH_MIN_FREQ * SI5351_FREQ_MULT;
	}

	if(pll_freq == 0)
	{
		// Find largest integer divider for max
		// VCO frequency and given target frequency
		lltmp = (SI5351_PLL_VCO_MAX * SI5351_FREQ_MULT) - 100000000UL; // margin needed?
		do_div(lltmp, freq);
		a = (uint32_t)lltmp;

		// Divisor has to be even
		if(a % 2 != 0)
		{
			a++;
		}

		// Divisor bounds check
		if(a < SI5351_MULTISYNTH_A_MIN)
		{
			a = SI5351_MULTISYNTH_A_MIN;
		}
		if(a > SI5351_MULTISYNTH67_A_MAX)
		{
			a = SI5351_MULTISYNTH67_A_MAX;
		}

		pll_freq = a * freq;

		// PLL bounds checking
		if(pll_freq > (SI5351_PLL_VCO_MAX * SI5351_FREQ_MULT))
		{
			a -= 2;
			pll_freq = a * freq;
		}
		else if(pll_freq < (SI5351_PLL_VCO_MIN * SI5351_FREQ_MULT))
		{
			a += 2;
			pll_freq = a * freq;
		}

		reg->p1 = (uint8_t)a;
		reg->p2 = 0;
		reg->p3 = 0;
		return pll_freq;
	}
	else
	{
		// Multisynth frequency must be integer division of PLL
		if(pll_freq % freq)
		{
			// No good
			return 0;
		}
		else
		{
			a = pll_freq / freq;

			// Division ratio bounds check
			if(a < SI5351_MULTISYNTH_A_MIN || a > SI5351_MULTISYNTH67_A_MAX)
			{
				// No bueno
				return 0;
			}
			else
			{
				reg->p1 = (uint8_t)a;
				reg->p2 = 0;
				reg->p3 = 0;
				return 1;
			}
		}
	}
}

void Si5351::update_sys_status(struct Si5351Status *status)
{
  uint8_t reg_val = 0;

  reg_val = si5351_read(SI5351_DEVICE_STATUS);

  // Parse the register
  status->SYS_INIT = (reg_val >> 7) & 0x01;
  status->LOL_B = (reg_val >> 6) & 0x01;
  status->LOL_A = (reg_val >> 5) & 0x01;
  status->LOS = (reg_val >> 4) & 0x01;
  status->REVID = reg_val & 0x03;
}

void Si5351::update_int_status(struct Si5351IntStatus *int_status)
{
  uint8_t reg_val = 0;

  reg_val = si5351_read(SI5351_INTERRUPT_STATUS);

  // Parse the register
  int_status->SYS_INIT_STKY = (reg_val >> 7) & 0x01;
  int_status->LOL_B_STKY = (reg_val >> 6) & 0x01;
  int_status->LOL_A_STKY = (reg_val >> 5) & 0x01;
  int_status->LOS_STKY = (reg_val >> 4) & 0x01;
}

void Si5351::ms_div(enum si5351_clock clk, uint8_t r_div, uint8_t div_by_4)
{
	uint8_t reg_val = 0;
    uint8_t reg_addr = 0;

	switch(clk)
	{
		case SI5351_CLK0:
			reg_addr = SI5351_CLK0_PARAMETERS + 2;
			break;
		case SI5351_CLK1:
			reg_addr = SI5351_CLK1_PARAMETERS + 2;
			break;
		case SI5351_CLK2:
			reg_addr = SI5351_CLK2_PARAMETERS + 2;
			break;
		case SI5351_CLK3:
			reg_addr = SI5351_CLK3_PARAMETERS + 2;
			break;
		case SI5351_CLK4:
			reg_addr = SI5351_CLK4_PARAMETERS + 2;
			break;
		case SI5351_CLK5:
			reg_addr = SI5351_CLK5_PARAMETERS + 2;
			break;
		case SI5351_CLK6:
			reg_addr = SI5351_CLK6_7_OUTPUT_DIVIDER;
			break;
		case SI5351_CLK7:
			reg_addr = SI5351_CLK6_7_OUTPUT_DIVIDER;
			break;
	}

	reg_val = si5351_read(reg_addr);

	if(clk <= (uint8_t)SI5351_CLK5)
	{
		// Clear the relevant bits
		reg_val &= ~(0x7c);

		if(div_by_4 == 0)
		{
			reg_val &= ~(SI5351_OUTPUT_CLK_DIVBY4);
		}
		else
		{
			reg_val |= (SI5351_OUTPUT_CLK_DIVBY4);
		}

		reg_val |= (r_div << SI5351_OUTPUT_CLK_DIV_SHIFT);
	}
	else if(clk == SI5351_CLK6)
	{
		// Clear the relevant bits
		reg_val &= ~(0x07);

		reg_val |= r_div;
	}
	else if(clk == SI5351_CLK7)
	{
		// Clear the relevant bits
		reg_val &= ~(0x70);

		reg_val |= (r_div << SI5351_OUTPUT_CLK_DIV_SHIFT);
	}

	si5351_write(reg_addr, reg_val);
}

uint8_t Si5351::select_r_div(uint64_t *freq)
{
	uint8_t r_div = SI5351_OUTPUT_CLK_DIV_1;

	// Choose the correct R divider
	if((*freq >= SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT) && (*freq < SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT * 2))
	{
		r_div = SI5351_OUTPUT_CLK_DIV_128;
		*freq *= 128ULL;
	}
	else if((*freq >= SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT * 2) && (*freq < SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT * 4))
	{
		r_div = SI5351_OUTPUT_CLK_DIV_64;
		*freq *= 64ULL;
	}
	else if((*freq >= SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT * 4) && (*freq < SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT * 8))
	{
		r_div = SI5351_OUTPUT_CLK_DIV_32;
		*freq *= 32ULL;
	}
	else if((*freq >= SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT * 8) && (*freq < SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT * 16))
	{
		r_div = SI5351_OUTPUT_CLK_DIV_16;
		*freq *= 16ULL;
	}
	else if((*freq >= SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT * 16) && (*freq < SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT * 32))
	{
		r_div = SI5351_OUTPUT_CLK_DIV_8;
		*freq *= 8ULL;
	}
	else if((*freq >= SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT * 32) && (*freq < SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT * 64))
	{
		r_div = SI5351_OUTPUT_CLK_DIV_4;
		*freq *= 4ULL;
	}
	else if((*freq >= SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT * 64) && (*freq < SI5351_CLKOUT_MIN_FREQ * SI5351_FREQ_MULT * 128))
	{
		r_div = SI5351_OUTPUT_CLK_DIV_2;
		*freq *= 2ULL;
	}

	return r_div;
}

uint8_t Si5351::select_r_div_ms67(uint64_t *freq)
{
	uint8_t r_div = SI5351_OUTPUT_CLK_DIV_1;

	// Choose the correct R divider
	if((*freq >= SI5351_CLKOUT67_MIN_FREQ * SI5351_FREQ_MULT) && (*freq < SI5351_CLKOUT67_MIN_FREQ * SI5351_FREQ_MULT * 2))
	{
		r_div = SI5351_OUTPUT_CLK_DIV_128;
		*freq *= 128ULL;
	}
	else if((*freq >= SI5351_CLKOUT67_MIN_FREQ * SI5351_FREQ_MULT * 2) && (*freq < SI5351_CLKOUT67_MIN_FREQ * SI5351_FREQ_MULT * 4))
	{
		r_div = SI5351_OUTPUT_CLK_DIV_64;
		*freq *= 64ULL;
	}
	else if((*freq >= SI5351_CLKOUT67_MIN_FREQ * SI5351_FREQ_MULT * 4) && (*freq < SI5351_CLKOUT67_MIN_FREQ * SI5351_FREQ_MULT * 8))
	{
		r_div = SI5351_OUTPUT_CLK_DIV_32;
		*freq *= 32ULL;
	}
	else if((*freq >= SI5351_CLKOUT67_MIN_FREQ * SI5351_FREQ_MULT * 8) && (*freq < SI5351_CLKOUT67_MIN_FREQ * SI5351_FREQ_MULT * 16))
	{
		r_div = SI5351_OUTPUT_CLK_DIV_16;
		*freq *= 16ULL;
	}
	else if((*freq >= SI5351_CLKOUT67_MIN_FREQ * SI5351_FREQ_MULT * 16) && (*freq < SI5351_CLKOUT67_MIN_FREQ * SI5351_FREQ_MULT * 32))
	{
		r_div = SI5351_OUTPUT_CLK_DIV_8;
		*freq *= 8ULL;
	}
	else if((*freq >= SI5351_CLKOUT67_MIN_FREQ * SI5351_FREQ_MULT * 32) && (*freq < SI5351_CLKOUT67_MIN_FREQ * SI5351_FREQ_MULT * 64))
	{
		r_div = SI5351_OUTPUT_CLK_DIV_4;
		*freq *= 4ULL;
	}
	else if((*freq >= SI5351_CLKOUT67_MIN_FREQ * SI5351_FREQ_MULT * 64) && (*freq < SI5351_CLKOUT67_MIN_FREQ * SI5351_FREQ_MULT * 128))
	{
		r_div = SI5351_OUTPUT_CLK_DIV_2;
		*freq *= 2ULL;
	}

	return r_div;
}
",16289,True,3206.54394962736,median
"/***********************************************************************************
** MIT License                                                                    **
**                                                                                **
** Copyright (c) 2018 Victor DENIS (victordenis01@gmail.com)                      **
**                                                                                **
** Permission is hereby granted, free of charge, to any person obtaining a copy   **
** of this software and associated documentation files (the ""Software""), to deal  **
** in the Software without restriction, including without limitation the rights   **
** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      **
** copies of the Software, and to permit persons to whom the Software is          **
** furnished to do so, subject to the following conditions:                       **
**                                                                                **
** The above copyright notice and this permission notice shall be included in all **
** copies or substantial portions of the Software.                                **
**                                                                                **
** THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     **
** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       **
** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    **
** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         **
** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  **
** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  **
** SOFTWARE.                                                                      **
***********************************************************************************/

#include <plog/Initializers/RollingFileInitializer.h>

#include ""BrowserWindow.hpp""

#include <QToolTip>
#include <QStatusBar>

#include <QList>

#include <QAction>

#include <QClipboard>
#include <QDesktopWidget>

#include <QTimer>
#include <QMessageBox>

#include ""Bookmarks/BookmarksUtils.hpp""
#include ""Bookmarks/BookmarksToolbar.hpp""

#include ""MaquetteGrid/MaquetteGridItem.hpp""

#include ""Plugins/PluginProxy.hpp""

#include ""Utils/DataPaths.hpp""
#include ""Utils/RestoreManager.hpp""
#include ""Utils/Settings.hpp""

#include ""Web/LoadRequest.hpp""
#include ""Web/WebPage.hpp""
#include ""Web/Tab/WebTab.hpp""
#include ""Web/Tab/TabbedWebView.hpp""

#include ""Widgets/TitleBar.hpp""
#include ""Widgets/CheckBoxDialog.hpp""
#include ""Widgets/AddressBar/AddressBar.hpp""
#include ""Widgets/Tab/TabWidget.hpp""
#include ""Widgets/Tab/MainTabBar.hpp""


#ifdef Q_OS_WIN
#include <windowsx.h>
#include <dwmapi.h>
#include <uxtheme.h>
#include <windows.h>

#if QT_VERSION == QT_VERSION_CHECK(5, 11, 0) || QT_VERSION == QT_VERSION_CHECK(5, 11, 1)
#error ""The custom window don't work with Qt 5.11.0 or Qt 5.11.1""
#endif

#endif
QT_BEGIN_NAMESPACE
extern Q_WIDGETS_EXPORT void qt_blurImage(QPainter *p, QImage &blurImage, qreal radius, bool quality, bool alphaOnly, int transposed = 0);
QT_END_NAMESPACE

#ifdef Q_OS_WIN
bool DWMEnabled(void)
{
	if (QSysInfo::windowsVersion() < QSysInfo::WV_VISTA) return false;
	BOOL useDWM;

	if (DwmIsCompositionEnabled(&useDWM) < 0) return false;
	return useDWM == TRUE;
}

void adjust_maximized_client_rect(HWND window, RECT& rect)
{
	WINDOWPLACEMENT placement;
	if (!GetWindowPlacement(window, &placement) || placement.showCmd != SW_MAXIMIZE)
		return;

	auto monitor = ::MonitorFromWindow(window, MONITOR_DEFAULTTONULL);
	if (!monitor)
		return;

	MONITORINFO monitor_info{};
	monitor_info.cbSize = sizeof(monitor_info);
	if (!::GetMonitorInfoW(monitor, &monitor_info))
		return;

	// when maximized, make the client area fill just the monitor (without task bar) rect,
	// not the whole window rect which extends beyond the monitor.
	rect = monitor_info.rcWork;
}
#endif

namespace Sn
{
BrowserWindow::SavedWindow::SavedWindow()
{
	// Empty
}

BrowserWindow::SavedWindow::SavedWindow(BrowserWindow* window)
{
	windowState = window->isFullScreen() ? QByteArray() : window->saveState();
	windowGeometry = window->saveGeometry();

	const int tabsSpaceCount{window->tabsSpaceSplitter()->count()};
	tabsSpaces.reserve(tabsSpaceCount);

	for (int i{0}; i < tabsSpaceCount; ++i) {
		TabsSpaceSplitter::SavedTabsSpace tabsSpace{window->tabsSpaceSplitter(), window->tabsSpaceSplitter()->tabWidget(i)};
		if (!tabsSpace.isValid())
			continue;

		tabsSpaces.append(tabsSpace);
	}
}

BrowserWindow::SavedWindow::SavedWindow(MaquetteGridItem* maquetteGridItem)
{
	windowState = QByteArray();
	windowGeometry = QByteArray();

	const int tabsSpaceCount{maquetteGridItem->tabsSpaces().count()};
	tabsSpaces.reserve(tabsSpaceCount);

	for (int i{0}; i < tabsSpaceCount; ++i) {
		TabsSpaceSplitter::SavedTabsSpace tabsSpace = maquetteGridItem->tabsSpaces()[i];
		if (!tabsSpace.isValid())
			continue;

		tabsSpaces.append(tabsSpace);
	}
}

bool BrowserWindow::SavedWindow::isValid() const
{
	for (const TabsSpaceSplitter::SavedTabsSpace& tabsSpace : tabsSpaces) {
		if (!tabsSpace.isValid())
			return false;
	}

	return true;
}

void BrowserWindow::SavedWindow::clear()
{
	windowState.clear();
	windowGeometry.clear();
	tabsSpaces.clear();
}

QDataStream &operator<<(QDataStream &stream, const BrowserWindow::SavedWindow &window)
{
	stream << 1;
	stream << window.windowState;
	stream << window.windowGeometry;
	stream << window.tabsSpaces.count();

	for (int i{0}; i < window.tabsSpaces.count(); ++i)
		stream << window.tabsSpaces[i];

	return stream;
}

QDataStream &operator>>(QDataStream &stream, BrowserWindow::SavedWindow &window)
{
	int version{0};
	stream >> version;

	if (version < 1)
		return stream;

	stream >> window.windowState;
	stream >> window.windowGeometry;

	int tabsSpacesCount{-1};
	stream >> tabsSpacesCount;
	window.tabsSpaces.reserve(tabsSpacesCount);

	for (int i{0}; i < tabsSpacesCount; ++i) {
		TabsSpaceSplitter::SavedTabsSpace tabsSpace{};
		stream >> tabsSpace;
		window.tabsSpaces.append(tabsSpace);
	}

	return stream;
}
BrowserWindow::BrowserWindow(Application::WindowType type, const QUrl& url) :
	QMainWindow(nullptr),
	m_startUrl(url),
	m_windowType(type),
	m_backgroundTimer(new QTimer())
{
    plog::init(plog::debug, ""Sielo.log"");
    PLOGD << ""start run\\n\\n""; 

//#define DrawWidgetOnly 1

#ifdef DrawWidgetOnly
    hide();
#else 
    setAttribute(Qt::WA_AcceptTouchEvents); ///add
    setAttribute(Qt::WA_DeleteOnClose);
    setAttribute(Qt::WA_DontCreateNativeAncestors);
    setAcceptDrops(true);
    setMouseTracking(true);

#ifdef Q_OS_WIN
    setWindowFlags(Qt::FramelessWindowHint);
    SetWindowLongPtrW(reinterpret_cast<HWND>(winId()), GWL_STYLE, WS_POPUP | WS_THICKFRAME | WS_CAPTION | WS_SYSMENU | WS_MAXIMIZEBOX | WS_MINIMIZEBOX);
    const MARGINS margins = { 1,1,1,1 };
    DwmExtendFrameIntoClientArea(reinterpret_cast<HWND>(winId()), &margins);
#endif


    setObjectName(QLatin1String(""mainwindow""));
    setWindowTitle(tr(""Sielo""));
    setProperty(""private"", Application::instance()->privateBrowsing());

    statusBar()->hide(); // Since we have a custom status bar, we hide the default one.

    setupUi();

    loadSettings();

    connect(m_backgroundTimer, &QTimer::timeout, this, &BrowserWindow::loadWallpaperSettings);
    m_backgroundTimer->start(1000);

    // Just wait some milli seconds before doing some post launch action
    QTimer::singleShot(10, this, &BrowserWindow::postLaunch);

    connect(this, SIGNAL(signalzoom(int)), this, SLOT(doZoom(int)));
    connect(this, SIGNAL(signalgoNewUrl(QString)), this, SLOT(goNewUrl(QString)));
#endif

 
    connect(this, SIGNAL(signalopenPanit(bool)), this, SLOT(openPanit(bool)));
    connect(this, SIGNAL(signalsetcolor(QString)), this, SLOT(setColor(QString)));
    connect(this, SIGNAL(signalclearPanit()), this, SLOT(clearPanit()));

    HttpServer::instance(0, this)->start();
}

BrowserWindow::~BrowserWindow()
{	
	if (DrawWidget::self) {
		DrawWidget::self->close();
		DrawWidget::self = nullptr;
	}
	Application::instance()->plugins()->emitMainWindowDeleted(this);
}

void BrowserWindow::loadSettings()
{
	Settings settings{};

	m_homePage = settings.value(QLatin1String(""Web-Settings/homePage""), QUrl(""https://item.jd.com/100010079898.html"")).toUrl();

	m_blur_radius = settings.value(QLatin1String(""Settings/backdropBlur""), 100).toInt();

	bool toolbarAtBottom{settings.value(QLatin1String(""Settings/bottomToolBar""), false).toBool()};

	if (toolbarAtBottom) {
		m_layout->removeWidget(m_titleBar);
		m_layout->addWidget(m_titleBar);
	}
	else {
		m_layout->removeWidget(m_titleBar);
		m_layout->insertWidget(0, m_titleBar);
	}

	// There is two possibility: the user use the floating button or not. 
	// Despite the floating button belongs to the window, the navigation bar belongs to the tab widget
	if (m_tabsSpaceSplitter->count() > 0) {
		if (Application::instance()->showFloatingButton() && !m_fButton)
			setupFloatingButton();
		else if (!Application::instance()->showFloatingButton() && m_fButton) {
			delete m_fButton;
			m_fButton = nullptr;
		}
	}

	m_titleBar->loadSettings();
	m_bookmarksToolbar->loadSettings();
	m_tabsSpaceSplitter->loadSettings();

	loadWallpaperSettings();

	bool showBookmarksToolBar = settings.value(QLatin1String(""ShowBookmarksToolBar""), false).toBool();
	m_bookmarksToolbar->setVisible(showBookmarksToolBar);
}

void BrowserWindow::loadWallpaperSettings()
{
	if (!m_backgroundTimer->isActive()) 
		m_backgroundTimer->start(100);

	Settings settings{};

	QString backgroundPath = settings.value(QLatin1String(""Settings/backgroundPath""), QString()).toString();

#ifdef Q_OS_WIN 
	QSettings wallpaperSettings{""HKEY_CURRENT_USER\\\\Control Panel\\\\Desktop"", QSettings::NativeFormat};
	QString wallpaper{wallpaperSettings.value(""WallPaper"", QString()).toString()};
	wallpaper.replace(""\\\\"", ""/"");

		if (backgroundPath.isEmpty())
			backgroundPath = wallpaper;
#endif


	QImage newBackground{backgroundPath};
	
	// Themes can have default backgound. If the user don't have custom background, we apply it.
	// However, if the user have a custom background we override the default one
	if (!backgroundPath.isEmpty() && newBackground != m_currentBackground) {
		QString sss{};
		sss += ""QMainWindow {"";
		sss += ""border-image: url("" + backgroundPath + "") 0 0 0 0 stretch stretch;"";
		sss += ""border-width: 0px;"";

		//if (settings.value(QLatin1String(""Settings/repeatBackground""), false).toBool())
		//	sss += ""background-repeat: repeat;"";
		//else
		//	sss += ""background-repeat: no-repeat;"";

		sss += ""}"";

		setStyleSheet(sss);

		m_currentBackground = newBackground;
		m_upd_ss = true; // Citorva will explain this.
	}
}

void BrowserWindow::setStartTab(WebTab* tab)
{
	m_startTab = tab;
}

void BrowserWindow::setStartPage(WebPage* page)
{
	m_startPage = page;
}

void BrowserWindow::restoreWindowState(const SavedWindow& window)
{
	// Restore basics informations
	restoreState(window.windowState);
	restoreGeometry(window.windowGeometry);

	for (int i{0}; i < window.tabsSpaces.count(); ++i)
		m_tabsSpaceSplitter->restoreTabsSpace(window.tabsSpaces[i]);

	m_tabsSpaceSplitter->autoResize();

	loadSettings();
}

void BrowserWindow::currentTabChanged(WebTab* tab)
{
	if (!tab || !tab->webView())
		return;

	setWindowTitle(tr(""%1 - Sielo"").arg(tab->title()));

	tab->webView()->setFocus();
}

void BrowserWindow::postMouseEvent(ButtonType t, ButtonAction ac,int x,int y){

    auto wid = tabWidget()->webTab()->webView()->inputWidget();
    auto target = wid->childAt(wid->pos() += m_curPos);//?
    QMouseEvent * mEvent = NULL;

    if (ac == ButtonAction::BUTTON_ACTION_MOVE) 
    {
        m_curPos.setX(x);
        m_curPos.setY(y);
        QCursor::setPos(wid->pos() += m_curPos);//wid->pos() += m_curPos
        mEvent = new QMouseEvent(QEvent::MouseMove, QCursor::pos(), Qt::NoButton, Qt::NoButton, Qt::NoModifier);
        QApplication::postEvent(target, (QEvent *)mEvent);
    }
    else 
    {
        switch (t)
        {
        case Sn::EBUTTON_LEFT: {
            mEvent = new QMouseEvent(
                ac == ButtonAction::BUTTON_ACTION_PRESS ? QEvent::MouseButtonPress : QEvent::MouseButtonRelease,
                QCursor::pos(), Qt::LeftButton, Qt::MouseButton::NoButton, Qt::NoModifier);
        }break;
       /* case Sn::EBUTTON_MIDDLE: {
            mEvent = new QMouseEvent(
                ac == ButtonAction::BUTTON_ACTION_PRESS ? QEvent::MouseButtonPress : QEvent::MouseButtonRelease,
                QCursor::pos(), Qt::MidButton, Qt::MidButton, Qt::NoModifier);
        }break;
        case Sn::EBUTTON_RIGHT: {
            mEvent = new QMouseEvent(
                ac == ButtonAction::BUTTON_ACTION_PRESS ? QEvent::MouseButtonPress : QEvent::MouseButtonRelease,
                QCursor::pos(), Qt::RightButton, Qt::RightButton, Qt::NoModifier);
        }break;
        case Sn::EBUTTON_X1: {
            mEvent = new QMouseEvent(
                ac == ButtonAction::BUTTON_ACTION_PRESS ? QEvent::MouseButtonPress : QEvent::MouseButtonRelease,
                QCursor::pos(), Qt::XButton1, Qt::XButton1, Qt::NoModifier);
        }break;
        case Sn::EBUTTON_X2: {
            mEvent = new QMouseEvent(
                ac == ButtonAction::BUTTON_ACTION_PRESS ? QEvent::MouseButtonPress : QEvent::MouseButtonRelease,
                QCursor::pos(), Qt::XButton2, Qt::XButton2, Qt::NoModifier);
        }break;*/
        default:
            break;
        }
        if (mEvent) {
            //QCursor::setPos(wid->pos()+m_curPos);
            //QCursor::setPos(mapToGlobal(wid->pos() += m_curPos));//wid->pos() += m_curPos
            QApplication::postEvent(target, (QEvent *)mEvent);
        }
    }
}

void BrowserWindow::loadUrl(const QUrl& url)
{
	// We can't load url directly in pinned tabs
	if (tabWidget()->webTab()->isPinned()) {
		int index{tabWidget()->addView(url, Application::NTT_CleanSelectedTab)};
		tabWidget()->webTab(index)->webView()->setFocus();
	}
	else {
		tabWidget()->webTab()->webView()->setFocus();
		tabWidget()->webTab()->webView()->load(url);
	}
}

void BrowserWindow::loadUrlInNewTab(const QUrl& url)
{
	tabWidget()->addView(url);
}

TabWidget *BrowserWindow::tabWidget() const
{
	return m_tabsSpaceSplitter->tabWidget();
}

TabWidget *BrowserWindow::tabWidget(int index) const
{
	return m_tabsSpaceSplitter->tabWidget(index);
}

const QImage *BrowserWindow::background()
{
	return m_bg;
}

const QImage *BrowserWindow::processedBackground()
{
	return m_blur_bg;
}

void BrowserWindow::setWindowTitle(const QString& title)
{
	QString t{title};

	QMainWindow::setWindowTitle(t);
}

void BrowserWindow::enterHtmlFullScreen()
{
//	toggleFullScreen();
	/// Empty
}

void BrowserWindow::toggleFullScreen()
{
	if (isFullScreen())
		showNormal();
	else
		showFullScreen();
}

void BrowserWindow::bookmarkPage()
{
	TabbedWebView* view{tabWidget()->webTab()->webView()};

	BookmarksUtils::addBookmarkDialog(this, view->url(), view->title());
}

void BrowserWindow::bookmarkAllTabs()
{
	BookmarksUtils::bookmarkAllTabsDialog(this, tabWidget());
}

void BrowserWindow::addBookmark(const QUrl& url, const QString& title)
{
	BookmarksUtils::addBookmarkDialog(this, url, title);
}

void BrowserWindow::tabWidgetIndexChanged(TabWidget* tbWidget)
{
	if (tabWidget()->count() < 1 || tabWidget() == tbWidget)
		return;

	// Change the tabs space for the restore action
	if (m_restoreAction && m_tabsSpaceSplitter->tabWidget())
		disconnect(m_restoreAction, SIGNAL(triggered()), m_tabsSpaceSplitter->tabWidget(), SLOT(restoreClosedTab()));

	// Update the current tab widget
	m_tabsSpaceSplitter->currentTabWidgetChanged(tbWidget);

	emit tabWidgetChanged(tbWidget);

	connect(m_restoreAction, SIGNAL(triggered()), m_tabsSpaceSplitter->tabWidget(), SLOT(restoreClosedTab()));

// 	AddressBar* addressBar = tabWidget()->webTab()->addressBar();
// 	if (addressBar && m_titleBar->addressBars()->indexOf(addressBar) != -1)
// 		m_titleBar->addressBars()->setCurrentWidget(addressBar);

	// Move the floating button to the new focused tabs space if the user wants
	if (m_fButton) {
		QRect tabWidgetRect = tbWidget->geometry();

		if (!tabWidgetRect.contains(tbWidget->mapFromGlobal(mapToGlobal(m_fButton->pos())))
			&& Application::instance()->floatingButtonFoloweMouse()) {
			m_fButton->tabWidgetChanged(tbWidget);
		}
	}
}

void BrowserWindow::shotBackground()
{
	// Citorva will explain this
	m_tabsSpaceSplitter->hide();
	if (m_fButton) m_fButton->hide();
	m_titleBar->hide();

	QPixmap *bg = new QPixmap(size());
	render(bg, QPoint(), QRect(0, 0, width(), height()));
	m_bg = new QImage(bg->toImage());
	m_tabsSpaceSplitter->show();
	//m_titleBar->show(); 地址栏/关闭,最大,最小化窗口栏!

	if (m_fButton) {
//		auto pos = m_tabsSpaceSplitter->pos();
//		m_fButton->move(pos);
		m_fButton->hide();
	}
	m_blur_bg = new QImage(applyBlur(m_bg, m_blur_radius));
}

QImage BrowserWindow::applyBlur(const QImage *src, qreal radius, bool quality, bool alphaOnly, int transposed)
{
	QPixmap ret(src->size());
	QPainter painter(&ret);
	{
		QPixmap big(QSize(src->width() + 2 * radius, src->height() + 2 * radius));
		QPainter big_painter(&big);

		big_painter.drawImage(QPoint(radius, radius), src->copy());

		{
			QPixmap	left(QSize(1, big.height())),
				right(QSize(1, big.height()));

			QPainter painter_left(&left),
				painter_right(&right);

			painter_left.drawImage(QPoint(0, radius), src->copy());
			painter_right.drawImage(QPoint(1 - src->width(), radius), src->copy());

			for (int i = 0; i < radius; i++) {
				big_painter.drawImage(QPoint(i, 0), left.toImage());
				big_painter.drawImage(QPoint(radius + src->width() + i, 0), right.toImage());
			}
		}

		{
			QPixmap top(QSize(big.width(), 1)),
				bottom(QSize(big.width(), 1));

			QPainter painter_top(&top),
				painter_bottom(&bottom);

			painter_top.drawImage(QPoint(0, -radius), big.toImage());
			painter_bottom.drawImage(QPoint(0, 1 + radius - big.height()), big.toImage());

			for (int i = 0; i < radius; i++) {
				big_painter.drawImage(QPoint(0, i), top.toImage());
				big_painter.drawImage(QPoint(0, radius + src->height() + i), bottom.toImage());
			}
		}

		QImage bgImage{big.toImage()};
		qt_blurImage(&big_painter, bgImage, radius, quality, alphaOnly, transposed);
		painter.drawImage(QPoint(-radius, -radius), big.toImage());
	}
	return ret.toImage();
}

void BrowserWindow::paintEvent(QPaintEvent* event)
{
	// Citorva will explain this
	QMainWindow::paintEvent(event);
	if (m_upd_ss) {
		m_upd_ss = false;
		shotBackground();
	}
}

void BrowserWindow::resizeEvent(QResizeEvent* event)
{
	// Move the floating button if need
	QRect screeRect{QApplication::desktop()->availableGeometry(this)};

	if (event->oldSize() == screeRect.size() && event->size() != screeRect.size())
		emit maximizeChanged(false, event->oldSize());
	else if (event->oldSize() != screeRect.size() && event->size() == screeRect.size())
		emit maximizeChanged(true, event->oldSize());

	QMainWindow::resizeEvent(event);

	shotBackground();
}

void BrowserWindow::keyPressEvent(QKeyEvent* event)
{
	if (Application::instance()->plugins()->processKeyPress(Application::ON_BrowserWindow, this, event))
		return;

	QMainWindow::keyPressEvent(event);
}

void BrowserWindow::keyReleaseEvent(QKeyEvent* event)
{
	if (Application::instance()->plugins()->processKeyRelease(Application::ON_BrowserWindow, this, event))
		return;

	QMainWindow::keyReleaseEvent(event);
}

void BrowserWindow::mouseMoveEvent(QMouseEvent *e)
{
	if ((e->pos().x() >= pos().x() && e->pos().x() <= (pos().x() + width())) ||
		(e->pos().y() >= pos().y() && e->pos().y() <= (pos().y() + height())))
		emit mouseOver(true);
	else
		emit mouseOver(false);
	QMainWindow::mouseMoveEvent(e);
}

void BrowserWindow::addTab()
{
	tabWidget()->addView(QUrl(), Application::NTT_SelectedNewEmptyTab, true);
	tabWidget()->setCurrentTabFresh(true);
}

void BrowserWindow::postLaunch()
{
	bool addTab{true};
	QUrl startUrl{};

	Application::AfterLaunch launchAction = Application::instance()->afterLaunch();

// 	if (Application::instance()->isStartingAfterCrash()) {
// 		launchAction = Application::instance()->afterCrashLaunch();
// 	}

	switch (launchAction) {
	case Application::OpenBlankPage:
		startUrl = QUrl();
		break;
	case Application::OpenHomePage:
	case Application::OpenSavedSession:
	case Application::RestoreSession:
		startUrl = m_homePage;
		break;

	default:
		break;
	}

	switch (m_windowType) {
	case Application::WT_FirstAppWindow:
		// Check if we start after a crash or if we want to restore session
		if (Application::instance()->isStartingAfterCrash()) {
			if (Application::instance()->afterCrashLaunch() == Application::AfterLaunch::RestoreSession)
				addTab = m_tabsSpaceSplitter->count() <= 0;
		}
		else if (Application::instance()->afterLaunch() == Application::AfterLaunch::RestoreSession ||
				 Application::instance()->afterLaunch() == Application::AfterLaunch::OpenSavedSession) {
			addTab = m_tabsSpaceSplitter->count() <= 0;
		}
		break;
	case Application::WT_NewWindow:
		addTab = true;
		break;
	case Application::WT_OtherRestoredWindow:
		addTab = false;
		break;

	}

	showFullScreen();
	
	qDebug() << ""pos ""<<pos().rx() << "","" << pos().ry();
	qDebug() << ""size "" << size().width() << "","" << size().height();
	auto pos = this->pos();
	pos.setX(pos.rx()-7);
	pos.setY(pos.ry()-7);
	move(pos);

	auto x = size();
	x.setWidth(size().width() + 14);
	x.setHeight(size().height() + 14);
	resize(x);

	if (!m_startUrl.isEmpty()) {
		startUrl = m_startUrl;
		addTab = true;
	}
	if (m_startTab) {
		addTab = false;
		m_tabsSpaceSplitter->createNewTabsSpace();
		tabWidget()->addView(m_startTab, Application::NTT_SelectedTabAtEnd);
	}

	if (m_startPage) {
		addTab = false;
		tabWidget()->addView(QUrl());
		tabWidget()->webTab()->webView()->setPage(m_startPage);
	}

	if (addTab) {
		m_tabsSpaceSplitter->createNewTabsSpace();
		tabWidget()->addView(startUrl, Application::NTT_CleanSelectedTabAtEnd);
	}

	if (tabWidget()->tabBar()->normalTabsCount() <= 0)
		tabWidget()->addView(m_homePage, Application::NTT_SelectedTabAtEnd);

	//TODO: emit main window created to plugins
	m_restoreAction = new QAction(tr(""Restore Closed Tab""), this);
	m_restoreAction->setShortcut(QKeySequence(""Ctrl+Shift+T""));
	this->addAction(m_restoreAction);
	connect(m_restoreAction, SIGNAL(triggered()), tabWidget(), SLOT(restoreClosedTab()));

	//tabWidget()->tabBar()->ensureVisible();
	if (Application::instance()->showFloatingButton() && !m_fButton)
		setupFloatingButton();
	else if (!Application::instance()->showFloatingButton() && m_fButton) {
		delete m_fButton;
		m_fButton = nullptr;
	}

// 	if (m_fButton)
// 		m_fButton->tabWidgetChanged(tabWidget());

    if (m_fButton)
        m_fButton->hide();

// 	m_fButton->expandAroundA(m_fButton->pos());
// 	m_fButton->closeButton();

	Application::instance()->plugins()->emitMainWindowCreated(this);

	Settings settings{};

	// Show the ""getting started"" page if it's the first time Sielo is launch
	if (!settings.value(""installed"", false).toBool()) {
#ifndef QT_DEBUG
		Application::instance()->piwikTraker()->sendEvent(""installation"", ""installation"", ""installation"", ""new installation"");
#endif
// 		CheckBoxDialog dialog(QMessageBox::Ok, this);
// 		dialog.setWindowTitle(tr(""Floating Button""));
// 		dialog.setText(tr(""Do you want to enable floating button? This button can always be enable/disable later in settings.""));
// 		dialog.setCheckBoxText(tr(""Enable""));
// 		dialog.setIcon(QMessageBox::Information);
// 		dialog.exec();
// 
 		settings.setValue(""Settings/showFloatingButton"", true);
 		settings.setValue(""installed"", true);

		Application::instance()->loadSettings();
	}
}


void BrowserWindow::floatingButtonPatternChange(RootFloatingButton::Pattern pattern)
{
	if (pattern != RootFloatingButton::Pattern::Floating) {
		m_fButton->tabWidgetChanged(tabWidget());
	}
}


void BrowserWindow::clearPanit() {
    PLOGD << ""DO clearPanit"";
    DrawWidget::Instance()->doClener();
}

//缩放动作
void BrowserWindow::doZoom(int n) {
    //m_zoom;
    auto view = m_tabsSpaceSplitter->tabWidget(m_fButton->pos())->webTab()->webView();
    if(view)
        view->applyZoom(n);
}

void BrowserWindow::openPanit(bool r)
{
    if (r) {
        DrawWidget::Instance()->show();
    }
    else {
        DrawWidget::Instance()->doClener();
        DrawWidget::Instance()->doClener();
        DrawWidget::Instance()->hide();
        delete DrawWidget::self;
        DrawWidget::self = nullptr;
    }
}

void BrowserWindow::closePanit()
{
     DrawWidget::Instance()->close();
}

///蒙层+标记
void  BrowserWindow::on_mark_window()
{
	qDebug() << ""on_mark_window"";
	if (DrawWidget::self){
		DrawWidget::self->close();
		DrawWidget::self = nullptr;
	}
	else {
		auto tab = m_tabsSpaceSplitter->tabWidget(m_fButton->pos())->webTab();
		auto tabsize = tab->size();
		tabsize.setWidth(tabsize.width());
		auto pos = this->pos();
		pos.setY(pos.y() );
		pos.setX(pos.x() );
		DrawWidget::Instance()->move(pos);
		DrawWidget::Instance()->show();
	}
}

void BrowserWindow::newWindow()
{
	m_tabsSpaceSplitter->tabWidget(m_fButton->pos())->webTab()->sNewWindow();
}

void BrowserWindow::goNewUrl(QString r)
{
    m_tabsSpaceSplitter->tabWidget(m_fButton->pos())->webTab()->webView()->load(QUrl(r));
	//m_tabsSpaceSplitter->tabWidget(m_fButton->pos())->webTab()->loadNewUrl(QUrl(r));

    QList<QTouchEvent::TouchPoint> touchPoints;
    touchPoints.append(QTouchEvent::TouchPoint(0));

    /*state
        TouchPointPressed    = 0x01,
        TouchPointMoved      = 0x02,
        TouchPointStationary = 0x04,
        TouchPointReleased   = 0x08
    */
    touchPoints[0].setState(Qt::TouchPointPressed); 
    touchPoints[0].setRect(QRect(11, 11, 0, 0));
    /*event
        TouchBegin = 194,
        TouchUpdate = 195,
        TouchEnd = 196,
    */
    QTouchEvent touchEvent(QEvent::TouchBegin,
        0 /* device */,
        Qt::NoModifier,
        Qt::TouchPointPressed,
        touchPoints);

}

void BrowserWindow::setColor(QString r)
{
    PLOGD << ""do setColor :"" << r.toStdString();
    DrawWidget::Instance()->setColor(r);
}


///转到主页
void BrowserWindow::goHome()
{
	m_tabsSpaceSplitter->tabWidget(m_fButton->pos())->webTab()->sGoHome();
}

void BrowserWindow::forward()
{
	m_tabsSpaceSplitter->tabWidget(m_fButton->pos())->webTab()->webView()->forward();
}

void BrowserWindow::back()
{
	m_tabsSpaceSplitter->tabWidget(m_fButton->pos())->webTab()->webView()->back();
}

void BrowserWindow::newTab()
{
	LoadRequest request{};
	request.setUrl(m_tabsSpaceSplitter->tabWidget(m_fButton->pos())->urlOnNewTab());
	m_tabsSpaceSplitter->tabWidget(m_fButton->pos())->webTab()->webView()->loadInNewTab(request, Application::NTT_CleanSelectedTabAtEnd);
}

void BrowserWindow::setupUi()
{
	QWidget* centralWidget{new QWidget(this)};
	m_layout = new QVBoxLayout(centralWidget);

	m_layout->setSpacing(0);
	m_layout->setContentsMargins(0, 0, 0, 0);

	m_titleBar = new TitleBar(this);
	m_bookmarksToolbar = new BookmarksToolbar(this, this);
	m_tabsSpaceSplitter = new TabsSpaceSplitter(this);

	m_titleBar->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
	m_bookmarksToolbar->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
	m_tabsSpaceSplitter->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

	QPalette palette{QToolTip::palette()};
	QColor color{palette.window().color()};

	color.setAlpha(0);
	palette.setColor(QPalette::Window, color);
	QToolTip::setPalette(palette);

	setMinimumWidth(300);
	///TODO: delete this line when settings will be implements

    //设置全屏
	QApplication::desktop()->screenGeometry().size();
	resize(QApplication::desktop()->size());
	//resize(1200, 1200);

// 	m_layout->addWidget(m_titleBar);
// 	m_layout->addWidget(m_bookmarksToolbar);
	m_layout->addWidget(m_tabsSpaceSplitter);

// 	m_layout->setStretchFactor(m_titleBar, 1);
// 	m_layout->setStretchFactor(m_bookmarksToolbar, 1);
	m_layout->setStretchFactor(m_tabsSpaceSplitter, 100);

	setCentralWidget(centralWidget);
	move(0, 0);
}

void BrowserWindow::setupFloatingButton()
{
	m_fButton = new RootFloatingButton(this, this);

	// Get floating button state
	QFile fButtonDataFile{DataPaths::currentProfilePath() + QLatin1String(""/fbutton.dat"")};

	if (fButtonDataFile.exists()) {
		fButtonDataFile.open(QIODevice::ReadOnly);

		QDataStream fButtonData{&fButtonDataFile};
		int version{0};
		int pattern;
		QPoint lastPosition{};

		fButtonData >> version;

		if (version <= 0x0003) {
			int buttonCount{0};

			fButtonData >> buttonCount;
			buttonCount = 1;
			QString button = ""fbutton-new-window"";
			QString toolTip{ ""Open New Window"" };

			for (int i{0}; i < buttonCount; ++i) {

				//fButtonData >> button;

				if (version >= 0x0003) {
					fButtonData >> toolTip;
				}
				else {
					if (button == ""fbutton-next"")
						toolTip = tr(""Go Forward"");
					else if (button == ""fbutton-back"")
						toolTip = tr(""Go Back"");
					else if (button == ""fbutton-home"")
						toolTip = tr(""Go Home"");
					else if (button == ""fbutton-add-bookmark"")
						toolTip = tr(""Add Bookmark"");
					else if (button == ""fbutton-view-bookmarks"")
						toolTip = tr(""Show all Bookmarks"");
					else if (button == ""fbutton-view-history"")
						toolTip = tr(""Show History"");
					else if (button == ""fbutton-new-window"") {
						toolTip = tr(""Open New Window"");
					}
					else if (button == ""fbutton-new-tab"")
						toolTip = tr(""Open New Tab"");
				}

				m_fButton->addButton(button, toolTip);
			}

			if (version >= 0x0002) {
				fButtonData >> pattern;
				fButtonData >> lastPosition;
				m_fButton->setPattern(static_cast<RootFloatingButton::Pattern>(pattern));
			}
		}
	}
	else { // Load default floating button
		m_fButton->addButton(""fbutton-next"", tr(""Go Forward""));
		m_fButton->addButton(""fbutton-back"", tr(""Go Back""));
		m_fButton->addButton(""fbutton-home"", tr(""Go Home""));
		m_fButton->addButton(""fbutton-add-bookmark"", tr(""Add Bookmark""));
		m_fButton->addButton(""fbutton-view-bookmarks"", tr(""Show all Bookmarks""));
		m_fButton->addButton(""fbutton-view-history"", tr(""Show History""));
		m_fButton->addButton(""fbutton-new-window"", tr(""Open New Window""));
		m_fButton->addButton(""fbutton-new-tab"", tr(""Open New Tab""));
	}

	connect(m_fButton, &RootFloatingButton::statusChanged, this, &BrowserWindow::saveButtonState);
	connect(m_fButton, &RootFloatingButton::patternChanged, this, &BrowserWindow::floatingButtonPatternChange);

	connect(m_fButton->button(""fbutton-view-bookmarks""), &FloatingButton::isClicked, tabWidget(),
			&TabWidget::openBookmarksDialog);
	connect(m_fButton->button(""fbutton-view-history""), &FloatingButton::isClicked, tabWidget(),
			&TabWidget::openHistoryDialog);
	connect(m_fButton->button(""fbutton-add-bookmark""), &FloatingButton::isClicked, this,
			&BrowserWindow::bookmarkPage);
	connect(m_fButton->button(""fbutton-new-window""), &FloatingButton::isClicked, this, &BrowserWindow::newTab);
	/// 这个按钮改成,标记按钮
	connect(m_fButton->button(""fbutton-new-tab""), &FloatingButton::isClicked, this, &BrowserWindow::newTab);
	connect(m_fButton->button(""fbutton-home""), &FloatingButton::isClicked, this, &BrowserWindow::goHome);
	connect(m_fButton->button(""fbutton-next""), &FloatingButton::isClicked, this, &BrowserWindow::forward);
	connect(m_fButton->button(""fbutton-back""), &FloatingButton::isClicked, this, &BrowserWindow::back);

// 	m_fButton->button(""fbutton-view-bookmarks"")->hide();
// 	m_fButton->button(""fbutton-view-history"")->hide();
// 	m_fButton->button(""fbutton-view-bookmark"")->hide();
}

void BrowserWindow::saveButtonState()
{
	QByteArray data{};
	QDataStream stream{&data, QIODevice::WriteOnly};

	stream << 0x0003;
	stream << m_fButton->buttons().size();

	for (int i{0}; i < m_fButton->buttons().size(); ++i) {
		foreach(FloatingButton* button, m_fButton->buttons())
		{
			if (button->index() == i) {
				stream << button->objectName();
				stream << button->toolTip();
				break;
			}
		}
	}

	stream << m_fButton->pattern();

	QFile fButtonFile{DataPaths::currentProfilePath() + QLatin1String(""/fbutton.dat"")};

	fButtonFile.open(QIODevice::WriteOnly);
	fButtonFile.write(data);
	fButtonFile.close();
}

void BrowserWindow::addCaption(const QWidget* widget)
{
	if (!isCaption(widget)) {
		m_captionWidgets.push_back(widget);
	}
}

void BrowserWindow::removeCaption(const QWidget* widget)
{
	for (int i = 0; i < m_captionWidgets.length(); i++) {
		if (m_captionWidgets[i] == widget) {
			m_captionWidgets.removeAt(i);
			return;
		}
	}
}

void BrowserWindow::dosignalopenPanit(bool r){
    Q_EMIT signalopenPanit(r);
}

void BrowserWindow::dosignalclearPanit() {
    Q_EMIT signalclearPanit();
}

void BrowserWindow::dosignalzoom(int n) {
    Q_EMIT signalzoom(n);
}

void BrowserWindow::dosignalsetcolor(QString r) {
    Q_EMIT signalsetcolor(r);
}
void BrowserWindow::dosignalgoNewUrl(QString r) {
    Q_EMIT signalgoNewUrl(r);
}

bool BrowserWindow::isCaption(const QWidget* widget)
{
	for (int i = 0; i < m_captionWidgets.length(); i++) {
		if (m_captionWidgets[i] == widget)
			return true;
	}
	return false;
}

#ifdef Q_OS_WIN
bool BrowserWindow::nativeEvent(const QByteArray &eventType, void *message, long *result)
{
	Q_UNUSED(eventType);
	const MSG* wMsg = reinterpret_cast<MSG*>(message);
	const UINT wMessage = wMsg->message;
	bool hasHandled = false;
	long res = 0;

	if (DWMEnabled())
		hasHandled = DwmDefWindowProc(wMsg->hwnd, wMessage, wMsg->wParam,
									  wMsg->lParam, reinterpret_cast<LRESULT*>(&res));

	if (wMessage == WM_NCCALCSIZE && wMsg->wParam == TRUE) {
		NCCALCSIZE_PARAMS& params = *reinterpret_cast<NCCALCSIZE_PARAMS*>(wMsg->lParam);
		adjust_maximized_client_rect(wMsg->hwnd, params.rgrc[0]);
		res = 0;
		hasHandled = true;
	}
	else if (wMessage == WM_NCHITTEST && res == 0) {
		res = ncHitTest(wMsg);

		if (res != HTNOWHERE)
			hasHandled = true;
	}
	//else if (wMessage == WM_NCPAINT)
	//	hasHandled = true;

	if (hasHandled)
		*result = res;
	return hasHandled;
}

long BrowserWindow::ncHitTest(const MSG* wMsg) const
{
	const long ncHitZone[3][4] = {
		{HTTOPLEFT, HTLEFT, HTLEFT, HTBOTTOMLEFT},
		{HTTOP, HTCAPTION, HTNOWHERE, HTBOTTOM},
		{HTTOPRIGHT, HTRIGHT, HTRIGHT, HTBOTTOMRIGHT}
	};

	const QPoint cursor(GET_X_LPARAM(wMsg->lParam), GET_Y_LPARAM(wMsg->lParam));
	const UINT8 borderSize = 2;
	UINT8 xPos = 1;
	UINT8 yPos = 2;

	RECT rcWin;
	GetWindowRect(wMsg->hwnd, &rcWin);

	for (const auto &e : m_captionWidgets)
		if (e == QApplication::widgetAt(QCursor::pos()))
			return HTCAPTION;

	RECT rcFrame = {0};
	AdjustWindowRectEx(&rcFrame, WS_OVERLAPPEDWINDOW & ~WS_CAPTION, FALSE, NULL);

	if (cursor.y() >= rcWin.top && cursor.y() <= rcWin.top + borderSize)
		yPos = 0;
	else if (cursor.y() >= rcWin.top + borderSize && cursor.y() <= rcWin.top + borderSize)
		yPos = 1;
	else if (cursor.y() >= rcWin.bottom - borderSize && cursor.y() < rcWin.bottom)
		yPos = 3;

	if (cursor.x() >= rcWin.left && cursor.x() < rcWin.left + borderSize)
		xPos = 0;
	else if (cursor.x() >= rcWin.right - borderSize && cursor.x() < rcWin.right)
		xPos = 2;

	return ncHitZone[xPos][yPos];
}

#endif
}


#include ""qfiledialog.h""
#if (QT_VERSION > QT_VERSION_CHECK(5,0,0))
#include ""qscreen.h""
#endif

#if _MSC_VER >= 1600
#pragma execution_character_set(""utf-8"")
#endif

#define AppPath qApp->applicationDirPath()
#define STRDATETIME qPrintable (QDateTime::currentDateTime().toString(""yyyy-MM-dd-HH-mm-ss""))

Screen::Screen(QSize size)
{
	maxWidth = size.width();
	maxHeight = size.height();

	startPos = QPoint(-1, -1);
	endPos = startPos;
	leftUpPos = startPos;
	rightDownPos = startPos;
	status = SELECT;
}

int Screen::width()
{
	return maxWidth;
}

int Screen::height()
{
	return maxHeight;
}

Screen::STATUS Screen::getStatus()
{
	return status;
}

void Screen::setStatus(STATUS status)
{
	this->status = status;
}

void Screen::setEnd(QPoint pos)
{
	endPos = pos;
	leftUpPos = startPos;
	rightDownPos = endPos;
	cmpPoint(leftUpPos, rightDownPos);
}

void Screen::setStart(QPoint pos)
{
	startPos = pos;
}

QPoint Screen::getEnd()
{
	return endPos;
}

QPoint Screen::getStart()
{
	return startPos;
}

QPoint Screen::getLeftUp()
{
	return leftUpPos;
}

QPoint Screen::getRightDown()
{
	return rightDownPos;
}

bool Screen::isInArea(QPoint pos)
{
	if (pos.x() > leftUpPos.x() && pos.x() < rightDownPos.x() && pos.y() > leftUpPos.y() && pos.y() < rightDownPos.y()) {
		return true;
	}

	return false;
}

void Screen::move(QPoint p)
{
	int lx = leftUpPos.x() + p.x();
	int ly = leftUpPos.y() + p.y();
	int rx = rightDownPos.x() + p.x();
	int ry = rightDownPos.y() + p.y();

	if (lx < 0) {
		lx = 0;
		rx -= p.x();
	}

	if (ly < 0) {
		ly = 0;
		ry -= p.y();
	}

	if (rx > maxWidth) {
		rx = maxWidth;
		lx -= p.x();
	}

	if (ry > maxHeight) {
		ry = maxHeight;
		ly -= p.y();
	}

	leftUpPos = QPoint(lx, ly);
	rightDownPos = QPoint(rx, ry);
	startPos = leftUpPos;
	endPos = rightDownPos;
}

void Screen::cmpPoint(QPoint &leftTop, QPoint &rightDown)
{
	QPoint l = leftTop;
	QPoint r = rightDown;

	if (l.x() <= r.x()) {
		if (l.y() <= r.y()) {
			;
		}
		else {
			leftTop.setY(r.y());
			rightDown.setY(l.y());
		}
	}
	else {
		if (l.y() < r.y()) {
			leftTop.setX(r.x());
			rightDown.setX(l.x());
		}
		else {
			QPoint tmp;
			tmp = leftTop;
			leftTop = rightDown;
			rightDown = tmp;
		}
	}
}

ScreenWidget *ScreenWidget::self = 0;
ScreenWidget::ScreenWidget(QWidget *parent) : QWidget(parent)
{
	this->initForm();
	showFullScreen();
}

void ScreenWidget::initForm()
{
	this->setWindowFlags(Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint);

	menu = new QMenu(this);
	menu->addAction(""保存截图"", this, SLOT(saveScreen()));
	menu->addAction(""截图另存为"", this, SLOT(saveScreenOther()));
	menu->addAction(""全屏截图"", this, SLOT(saveFullScreen()));
	menu->addAction(""退出截图"", this, SLOT(hide()));

	//取得屏幕大小
	screen = new Screen(QApplication::desktop()->size());
	//保存全屏图像
	fullScreen = new QPixmap();
}

void ScreenWidget::paintEvent(QPaintEvent *)
{
	int x = screen->getLeftUp().x();
	int y = screen->getLeftUp().y();
	int w = screen->getRightDown().x() - x;
	int h = screen->getRightDown().y() - y;

	QPainter painter(this);

	QPen pen;
	pen.setColor(Qt::green);
	pen.setWidth(2);
	pen.setStyle(Qt::DotLine);
	painter.setPen(pen);

	QFont font;
	font.setFamily(""Microsoft YaHei"");
	font.setPointSize(10);
	painter.setFont(font);

	painter.drawPixmap(0, 0, *bgScreen);

	if (w != 0 && h != 0) {
		painter.drawPixmap(x, y, fullScreen->copy(x, y, w, h));
	}

	painter.drawRect(x, y, w, h);

	pen.setColor(Qt::yellow);
	painter.setPen(pen);
	painter.drawText(x + 2, y - 8, tr(""截图范围：( %1 x %2 ) - ( %3 x %4 )  图片大小：( %5 x %6 )"")
		.arg(x).arg(y).arg(x + w).arg(y + h).arg(w).arg(h));
}

void ScreenWidget::showEvent(QShowEvent *)
{
	QPoint point(-1, -1);
	screen->setStart(point);
	screen->setEnd(point);

#if (QT_VERSION <= QT_VERSION_CHECK(5,0,0))
	*fullScreen = fullScreen->grabWindow(QApplication::desktop()->winId(), 0, 0, screen->width(), screen->height());
#else
	::QScreen *pscreen = QApplication::primaryScreen();
	*fullScreen = pscreen->grabWindow(QApplication::desktop()->winId(), 0, 0, screen->width(), screen->height());
#endif

	//设置透明度实现模糊背景
	::QPixmap pix(screen->width(), screen->height());
	pix.fill((QColor(160, 160, 160, 200)));
	bgScreen = new ::QPixmap(*fullScreen);
	QPainter p(bgScreen);
	p.drawPixmap(0, 0, pix);
}

void ScreenWidget::saveScreenOther()
{
	QString fileName = QFileDialog::getSaveFileName(this, ""保存图片"", STRDATETIME, ""JPEG Files (*.jpg)"");

	if (fileName.length() > 0) {
		int x = screen->getLeftUp().x();
		int y = screen->getLeftUp().y();
		int w = screen->getRightDown().x() - x;
		int h = screen->getRightDown().y() - y;

		fullScreen->copy(x, y, w, h).save(fileName, ""jpg"");

		close();
	}
}

void ScreenWidget::saveScreen()
{
	int x = screen->getLeftUp().x();
	int y = screen->getLeftUp().y();
	int w = screen->getRightDown().x() - x;
	int h = screen->getRightDown().y() - y;

	QString fileName = QString(""%1/screen_%2.jpg"").arg(AppPath).arg(STRDATETIME);
	fullScreen->copy(x, y, w, h).save(fileName, ""jpg"");

	close();
}

void ScreenWidget::saveFullScreen()
{
	QString fileName = QString(""%1/full_%2.jpg"").arg(AppPath).arg(STRDATETIME);
	fullScreen->save(fileName, ""jpg"");
	close();
}

void ScreenWidget::mouseMoveEvent(QMouseEvent *e)
{
	if (screen->getStatus() == Screen::SELECT) {
		screen->setEnd(e->pos());
	}
	else if (screen->getStatus() == Screen::MOV) {
		QPoint p(e->x() - movPos.x(), e->y() - movPos.y());
		screen->move(p);
		movPos = e->pos();
	}

	update();
}

void ScreenWidget::mousePressEvent(QMouseEvent *e)
{
	int status = screen->getStatus();

	if (status == Screen::SELECT) {
		screen->setStart(e->pos());
	}
	else if (status == Screen::MOV) {
		if (screen->isInArea(e->pos()) == false) {
			screen->setStart(e->pos());
			screen->setStatus(Screen::SELECT);
		}
		else {
			movPos = e->pos();
			this->setCursor(Qt::SizeAllCursor);
		}
	}

	update();
}

void ScreenWidget::mouseReleaseEvent(QMouseEvent *)
{
	if (screen->getStatus() == Screen::SELECT) {
		screen->setStatus(Screen::MOV);
	}
	else if (screen->getStatus() == Screen::MOV) {
		this->setCursor(Qt::ArrowCursor);
	}
}

void ScreenWidget::contextMenuEvent(QContextMenuEvent *)
{
	this->setCursor(Qt::ArrowCursor);
	menu->exec(cursor().pos());
}

#include <QColorDialog>
DrawWidget *DrawWidget::self = 0;
DrawWidget::DrawWidget(QWidget *parent) :
	QWidget(parent)
{
	setupUi();

	this->setWindowFlags(Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint);
    this->resize(QApplication::desktop()->size());
    this->resize(QSize(720,1280));

    setAttribute(Qt::WA_NoSystemBackground);
    setAttribute(Qt::WA_TranslucentBackground);
    setAttribute(Qt::WA_PaintOnScreen);

    hide();
    frame->hide();

    QPixmap pix(this->size().width(), this->size().height());
    pix.fill((QColor(0, 0, 0, 1)));
    image = pix.toImage();

	tempImage = image;  //将临时画布设置成与主画布相同的状态
	drawing = false;    //默认未绘图
	nshape = 0;			//默认涂鸦,画笔,形状

	//绘画数据初始化
	shape->setChecked(true);
	width = 0;
	heigh = 0;
	for (int i = 0; i < 3; i++) {
		pointPolygon[i].setX(0);
		pointPolygon[i].setY(0);
	}
	lineEdit.setParent(this);
	lineEdit.resize(70, 20);
	lineEdit.setText("" "");
	lineEdit.setVisible(false);

	penWidth->setValue(3);
	penColor.setNamedColor(""red"");
}

DrawWidget::~DrawWidget()
{
}

void DrawWidget::paintEvent(QPaintEvent *event) //重写窗口重绘事件
{
	/*
	 *采用双缓冲绘图，以矩形为例，当绘制矩形时，
	 * 鼠标左键未松开（移动），将图形绘制在临时画布（即预览）
	 * 在鼠标松开后，将临时画布上的图形copy到主画布上，
	 * 显示主画布
	 * */
	QPainter painter(this);
	if (drawing == true){
		painter.drawImage(0, 0, tempImage);		//鼠标按住但在拖动时在临时画布上画
	}
	else {
		painter.drawImage(0, 0, image);			//在image上绘画
	}
}

void drawArrow(QPoint startPoint, QPoint endPoint, QPainter &p, QColor penColor)
{
	double par = 27.0;//箭头部分三角形的腰长
	double slopy = atan2((endPoint.y() - startPoint.y()), (endPoint.x() - startPoint.x()));
	double cosy = cos(slopy);
	double siny = sin(slopy);
	QPoint point1 = QPoint(endPoint.x() + int(-par * cosy - (par / 2.0*siny)), endPoint.y() + int(-par * siny + (par / 2.0*cosy)));
	QPoint point2 = QPoint(endPoint.x() + int(-par * cosy + (par / 2.0*siny)), endPoint.y() - int(par / 2.0*cosy + par * siny));
	QPoint points[3] = { endPoint, point1, point2 };
    p.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
	QPen drawTrianglePen;//创建画笔
	drawTrianglePen.setColor(penColor);
	drawTrianglePen.setWidth(1);
	p.setPen(drawTrianglePen);
	p.drawPolygon(points, 3);// 绘制箭头部分 还需要填充颜色

	QPolygonF pts;
	QPainterPath path;
	pts.push_back(endPoint);
	pts.push_back(point1);
	pts.push_back(point2);
	path.addPolygon(pts);
	p.fillPath(path, QBrush(penColor));

	int offsetX = int(par*siny / 4);
	int offsetY = int(par*cosy / 4);
	QPoint point3, point4;
	point3 = QPoint(endPoint.x() + int(-par * cosy - (par / 2.0*siny)) + offsetX, endPoint.y() + int(-par * siny + (par / 2.0*cosy)) - offsetY);
	point4 = QPoint(endPoint.x() + int(-par * cosy + (par / 2.0*siny) - offsetX), endPoint.y() - int(par / 2.0*cosy + par * siny) + offsetY);
	QPoint arrowBodyPoints[3] = { startPoint, point3, point4 };
	p.drawPolygon(arrowBodyPoints, 3);	//绘制箭身部分
	pts.clear();
	pts.push_back(startPoint);
	pts.push_back(point3);
	pts.push_back(point4);
	path.addPolygon(pts);
	p.fillPath(path, QBrush(penColor));
}

void DrawWidget::paint(QImage &theImage)        //绘图
{
    QPen pen(penColor, penWidth->value(), Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin);

    QPainter thePainter(&theImage);
    thePainter.setPen(pen);
    thePainter.setRenderHint(QPainter::HighQualityAntialiasing, true);
    thePainter.setCompositionMode(QPainter::CompositionMode_Source);

	//绘图
	switch (nshape) {
	case 0:thePainter.drawLine(change, point);
		change = point;
		break;
	case 1: 
		drawArrow(from, point, thePainter, penColor);
		break;   
	case 2:thePainter.drawRect(from.x(), from.y(), width, heigh);
		break;
// 	case 3:thePainter.eraseRect(point.x(), point.y(), penWidth->value() + 5, penWidth->value() + 5);
// 		break;
	case 4:thePainter.drawEllipse(from.x(), from.y(), width, heigh);
		break;
	case 5:
		lineEdit.move(point.x(), point.y());
		lineEdit.setVisible(true);
		thePainter.drawText(change, lineEdit.text());
		lineEdit.clear();
		if (lineEdit.text() != """"){
			lineEdit.setVisible(false);
		}
		break;
	default:break;
	}
	thePainter.end(); //结束绘图
	update();   //窗口重绘
}

void DrawWidget::setupUi()
{
	this->setObjectName(QString::fromUtf8(""DrawWidget""));
	frame = new QFrame(this);
	frame->setObjectName(QString::fromUtf8(""frame""));
	frame->setFrameShape(QFrame::StyledPanel);
	frame->setFrameShadow(QFrame::Raised);
	verticalLayout = new QVBoxLayout(frame);
	verticalLayout->setSpacing(6);
	verticalLayout->setContentsMargins(11, 11, 11, 11);
	verticalLayout->setObjectName(QString::fromUtf8(""verticalLayout""));
	widget_2 = new QWidget(frame);
	widget_2->setObjectName(QString::fromUtf8(""widget_2""));
	gridLayout_3 = new QGridLayout(widget_2);
	gridLayout_3->setSpacing(6);
	gridLayout_3->setContentsMargins(11, 11, 11, 11);
	gridLayout_3->setObjectName(QString::fromUtf8(""gridLayout_3""));
	label = new QLabel(widget_2);
	label->setObjectName(QString::fromUtf8(""label""));

	gridLayout_3->addWidget(label, 0, 0, 1, 1);

	penWidth = new QSlider(widget_2);
	penWidth->setObjectName(QString::fromUtf8(""penWidth""));
	penWidth->setMinimum(1);
	penWidth->setMaximum(100);
	penWidth->setOrientation(Qt::Horizontal);

	gridLayout_3->addWidget(penWidth, 0, 1, 1, 1);

	label_6 = new QLabel(widget_2);
	label_6->setObjectName(QString::fromUtf8(""label_6""));

	gridLayout_3->addWidget(label_6, 1, 0, 1, 1);

	pushButton = new QPushButton(widget_2);
	pushButton->setObjectName(QString::fromUtf8(""pushButton""));
	QIcon icon;
	icon.addFile(QString::fromUtf8("":/Core/image/rgb.png""), QSize(), QIcon::Normal, QIcon::Off);
	pushButton->setIcon(icon);
	pushButton->setIconSize(QSize(200, 200));

	gridLayout_3->addWidget(pushButton, 1, 1, 1, 1);
	verticalLayout->addWidget(widget_2);

	widget_5 = new QWidget(frame);
	widget_5->setObjectName(QString::fromUtf8(""widget_5""));
	verticalLayout_2 = new QVBoxLayout(widget_5);
	verticalLayout_2->setSpacing(6);
	verticalLayout_2->setContentsMargins(11, 11, 11, 11);
	verticalLayout_2->setObjectName(QString::fromUtf8(""verticalLayout_2""));
	label_2 = new QLabel(widget_5);
	label_2->setObjectName(QString::fromUtf8(""label_2""));

	verticalLayout_2->addWidget(label_2);

	widget_3 = new QWidget(widget_5);
	widget_3->setObjectName(QString::fromUtf8(""widget_3""));
	gridLayout_2 = new QGridLayout(widget_3);
	gridLayout_2->setSpacing(6);
	gridLayout_2->setContentsMargins(11, 11, 11, 11);
	gridLayout_2->setObjectName(QString::fromUtf8(""gridLayout_2""));
	label_3 = new QLabel(widget_3);
	label_3->setObjectName(QString::fromUtf8(""label_3""));
	label_3->setPixmap(QPixmap(QString::fromUtf8("":/Core/image/line.png"")));

	gridLayout_2->addWidget(label_3, 1, 0, 1, 1);

	label_9 = new QLabel(widget_3);
	label_9->setObjectName(QString::fromUtf8(""label_9""));
	label_9->setPixmap(QPixmap(QString::fromUtf8("":/Core/image/edit.png"")));

	gridLayout_2->addWidget(label_9, 5, 2, 1, 1);

	label_5 = new QLabel(widget_3);
	label_5->setObjectName(QString::fromUtf8(""label_5""));
	label_5->setPixmap(QPixmap(QString::fromUtf8("":/Core/image/quxian.png"")));

	gridLayout_2->addWidget(label_5, 4, 0, 1, 1);

	radioButton_4 = new QRadioButton(widget_3);
	radioButton_4->setObjectName(QString::fromUtf8(""radioButton_4""));

	gridLayout_2->addWidget(radioButton_4, 5, 1, 1, 1);

	radioButton_5 = new QRadioButton(widget_3);
	radioButton_5->setObjectName(QString::fromUtf8(""radioButton_5""));

	gridLayout_2->addWidget(radioButton_5, 5, 3, 1, 1);

	shape = new QRadioButton(widget_3);
	shape->setObjectName(QString::fromUtf8(""shape""));

	gridLayout_2->addWidget(shape, 4, 1, 1, 1);

	radioButton_3 = new QRadioButton(widget_3);
	radioButton_3->setObjectName(QString::fromUtf8(""radioButton_3""));

	gridLayout_2->addWidget(radioButton_3, 4, 3, 1, 1);

	label_4 = new QLabel(widget_3);
	label_4->setObjectName(QString::fromUtf8(""label_4""));
	label_4->setPixmap(QPixmap(QString::fromUtf8("":/Core/image/rect.png"")));

	gridLayout_2->addWidget(label_4, 1, 2, 1, 1);

	label_8 = new QLabel(widget_3);
	label_8->setObjectName(QString::fromUtf8(""label_8""));
	label_8->setPixmap(QPixmap(QString::fromUtf8("":/Core/image/3jiaoxing.png"")));

	gridLayout_2->addWidget(label_8, 5, 0, 1, 1);

	radioButton = new QRadioButton(widget_3);
	radioButton->setObjectName(QString::fromUtf8(""radioButton""));

	gridLayout_2->addWidget(radioButton, 1, 1, 1, 1);

	radioButton_2 = new QRadioButton(widget_3);
	radioButton_2->setObjectName(QString::fromUtf8(""radioButton_2""));

	gridLayout_2->addWidget(radioButton_2, 1, 3, 1, 1);

	label_7 = new QLabel(widget_3);
	label_7->setObjectName(QString::fromUtf8(""label_7""));
	label_7->setPixmap(QPixmap(QString::fromUtf8("":/Core/image/eraser.png"")));

	gridLayout_2->addWidget(label_7, 4, 2, 1, 1);
	verticalLayout_2->addWidget(widget_3);
	verticalLayout->addWidget(widget_5);

	widget_4 = new QWidget(frame);
	widget_4->setObjectName(QString::fromUtf8(""widget_4""));
	horizontalLayout = new QHBoxLayout(widget_4);
	horizontalLayout->setSpacing(6);
	horizontalLayout->setContentsMargins(11, 11, 11, 11);
	horizontalLayout->setObjectName(QString::fromUtf8(""horizontalLayout""));
	pushButton_2 = new QPushButton(widget_4);
	pushButton_2->setObjectName(QString::fromUtf8(""pushButton_2""));

	horizontalLayout->addWidget(pushButton_2);

	pushButton_3 = new QPushButton(widget_4);
	pushButton_3->setObjectName(QString::fromUtf8(""pushButton_3""));

	horizontalLayout->addWidget(pushButton_3);
	verticalLayout->addWidget(widget_4);

	pushButton->setDefault(false);

	label->setText(QApplication::translate(""DrawWidget"", ""\\347\\224\\273\\347\\254\\224\\347\\262\\227\\347\\273\\206"", nullptr));
	label_6->setText(QApplication::translate(""DrawWidget"", ""\\347\\224\\273\\347\\254\\224\\351\\242\\234\\350\\211\\262"", nullptr));
	pushButton->setText(QString());
	label_2->setText(QApplication::translate(""DrawWidget"", ""<html><head/><body><p align=\\""center\\""><span style=\\"" font-size:16pt;\\"">\\345\\275\\242\\347\\212\\266\\351\\200\\211\\346\\213\\251</span></p></body></html>"", nullptr));
	label_3->setText(QString());
	label_9->setText(QString());
	label_5->setText(QString());
	radioButton_4->setText(QString());
	radioButton_5->setText(QString());
	shape->setText(QString());
	radioButton_3->setText(QString());
	label_4->setText(QString());
	label_8->setText(QString());
	radioButton->setText(QString());
	radioButton_2->setText(QString());
	label_7->setText(QString());
	pushButton_2->setText(QApplication::translate(""DrawWidget"", ""\\344\\277\\235\\345\\255\\230"", nullptr));
	pushButton_3->setText(QApplication::translate(""DrawWidget"", ""\\346\\270\\205\\347\\251\\272"", nullptr));


	connect(radioButton, SIGNAL(clicked()), this, SLOT(on_radioButton_clicked()));
	connect(radioButton_2, SIGNAL(clicked()), this, SLOT(on_radioButton_2_clicked()));
	connect(pushButton, SIGNAL(clicked()), this, SLOT(on_pushButton_clicked()));
	connect(shape, SIGNAL(clicked()), this, SLOT(on_shape_clicked()));
	connect(radioButton_3, SIGNAL(clicked()), this, SLOT(on_radioButton_3_clicked()));
	connect(pushButton_2, SIGNAL(clicked()), this, SLOT(on_pushButton_2_clicked()));
	connect(radioButton_4, SIGNAL(clicked()), this, SLOT(on_radioButton_4_clicked()));
	connect(pushButton_3, SIGNAL(clicked()), this, SLOT(on_pushButton_3_clicked()));
	connect(radioButton_5, SIGNAL(clicked()), this, SLOT(on_radioButton_5_clicked()));
	
	QString style = ""QRadioButton::indicator{\\
width:15px;\\
height:15px;\\
}\\
QRadioButton::indicator::unchecked{\\
image:url(:/icons/lightblue/radiobutton_unchecked.png);\\
}\\
QRadioButton::indicator::unchecked:disabled{\\
image:url(:/icons/lightblue/radiobutton_unchecked_disable.png);\\
}\\
QRadioButton::indicator::checked{\\
image:url(:/icons/lightblue/radiobutton_checked.png);\\
}\\
QRadioButton::indicator::checked:disabled{\\
image:url(:/icons/lightblue/radiobutton_checked_disable.png);\\
}"";
	radioButton->setStyleSheet(style);
	radioButton_2->setStyleSheet(style);
	radioButton_3->setStyleSheet(style);
	radioButton_4->setStyleSheet(style);
	radioButton_5->setStyleSheet(style);
}

void DrawWidget::setShape(int n)
{
	if (DrawWidget::self) {
		nshape = n;
        PLOGD << ""do cmd set nshape  "" << n;
    }
    else {
        PLOGD << ""do cmd set nshape err !   no self!"";
    }
}

void DrawWidget::doClener()
{
	if (DrawWidget::self) {
		on_pushButton_3_clicked();
	}
}
void DrawWidget::setWidth(int n)
{
	if (DrawWidget::self) {
		penWidth->setValue(n);
	}
}
void DrawWidget::setColor(QString n)
{
    if (DrawWidget::self) {
        penColor = QColor(n);
    }
}

void DrawWidget::mousePressEvent(QMouseEvent *event)
{
	if (event->button() == Qt::LeftButton) {
		qDebug() << ""mouse LeftButton"" << event->pos().rx() << "":"" << event->pos().ry();
		drawing = true;
		point = event->pos();
		from = event->pos();
		change = event->pos();
		width = 0; heigh = 0;
		pointPolygon[0] = point;
		pointPolygon[1].setX(point.x());
	}
}

void DrawWidget::mouseMoveEvent(QMouseEvent *event)
{
	point = event->pos();
	width = point.x() - from.x();
	heigh = point.y() - from.y();
	pointPolygon[1].setY(point.y());
	pointPolygon[2] = point;
	tempImage = image;

	if (nshape == 0 || nshape == 3) {
		paint(image);
	}
	else {
		paint(tempImage);
	}
}

void DrawWidget::mouseReleaseEvent(QMouseEvent *event)
{
	if (event->button() == Qt::LeftButton)
	{
		qDebug() << ""mouse LeftButton ""<< event->pos().rx()<<"":""<< event->pos().ry();
		to = event->pos();
		point = event->pos();
		width = to.x() - from.x();
		heigh = to.y() - from.y();
		pointPolygon[2] = point;
		drawing = false;

		paint(image);
	}
}

void DrawWidget::on_radioButton_clicked()
{
	nshape = 1;
}

void DrawWidget::on_radioButton_2_clicked()
{
	nshape = 2;
}

void DrawWidget::on_pushButton_clicked()
{
	QColorDialog color;//调出颜色选择器对话框
	penColor = color.getRgba(); //设置画笔颜色
}

void DrawWidget::on_shape_clicked()
{
	nshape = 0;
}

void DrawWidget::on_radioButton_3_clicked()
{
	nshape = 3;
}

void DrawWidget::on_pushButton_2_clicked()  //将画布内容保存
{
	QString filename = QFileDialog::getSaveFileName(this,
		tr(""Save Image""),
		"""",
		tr(""*.bmp;; *.png;; *.jpg;; *.tif;; *.GIF"")); //选择路径
	if (filename.isEmpty()) {
		return;
	}
	else{
		if (!(image.save(filename))){
			QMessageBox::information(this,
				tr(""Failed to save the image""),
				tr(""Failed to save the image!""));
			return;
		}
	}
}

void DrawWidget::on_radioButton_4_clicked()
{
	nshape = 4;
}

void DrawWidget::on_pushButton_3_clicked()
{
    QPixmap pix(this->size().width(), this->size().height());
    pix.fill((QColor(0, 0, 0, 1)));
    image = pix.toImage();
    tempImage = pix.toImage();
	update();
    PLOGD << ""do signalclearPanit end"";
}

void DrawWidget::on_radioButton_5_clicked()
{
	nshape = 5;
}


HttpServer::HttpServer(QObject *parent, void*hand) : QThread(parent),m_hand(hand)
{
    moveToThread(this);
}

HttpServer::~HttpServer()
{
    quit();
}

void HttpServer::run() {
    QHttpServer server(this);
    quint64 iconnectionCounter = 0;
    QString portOrUnixSocket(""8010"");
    server.listen(portOrUnixSocket, [&](QHttpRequest* req, QHttpResponse* res) {
        new ClientHandler(++iconnectionCounter, req, res);
    });

    if (!server.isListening()) {
        fprintf(stderr, ""can not listen on %s!\\n"", qPrintable(portOrUnixSocket));
    }

    PLOGD << ""start listen 8010"";
    exec();
}

struct MouseData {
    int type;
    int action;
    int x;
    int y;
};

std::string typeToString(int t) {
    switch (t)
    {
    case 0:return ""close panit"";
    case 1:return ""open panit"";
    case 2:return ""set shape"";
    case 3:return ""set width"";
    case 4:return ""set url"";
    case 6:return ""set color"";
    case 7:return ""clear paint"";
    case 8:return ""zoom"";
    default:
        break;
    }
}

void HttpServer::gDealHttp(int type, QByteArray data)
{
    PLOGD << ""do cmd type :"" << typeToString(type) <<"" data :""<< data.toStdString() <<"" hand:""<< m_hand;
    if (type == 1) {	//打开画板
        if (data.toInt() == 1 && m_hand) {
            ((Sn::BrowserWindow*)m_hand)->dosignalopenPanit(true);
        }
        else if (data.toInt() == 0 && m_hand) {
            ((Sn::BrowserWindow*)m_hand)->dosignalopenPanit(false);
        }
    }
    else if (type == 2) {	//形状
        int i = 0;
        do{
            if (!DrawWidget::self) {
                Sleep(100);
            }
            else {
                DrawWidget::self->setShape(data.toInt());
            }
        } while (i++ < 3);

        if (!DrawWidget::self){
            PLOGD << ""do cmd set shape err:no widget  "" << data.toInt();
        }
    }
    else if (type == 3) {	//设置粗细
        int i = 0;
        do {
            if (!DrawWidget::self) {
                Sleep(100);
            }
            else {
                DrawWidget::self->setWidth(data.toInt());
            }
        } while (i++ < 3);

        if (!DrawWidget::self) {
            PLOGD << ""do cmd set width err:no widget  "" << data.toInt();
        }
    }
    else if (type == 4 && m_hand) {	//跳转网址
        if (data.size()) {
            ((Sn::BrowserWindow*)m_hand)->dosignalgoNewUrl(data.data());
        }
    }
   /* else if (type == 5) {
        QJsonDocument json = QJsonDocument::fromJson(data.data(), 0);
        QJsonObject obj = json.object();

        int x = (obj[""x""].toInt() & 0xFFFF) / (65535 / float(1920));
        int y = (obj[""y""].toInt() & 0xFFFF) / (65535 / float(1080));

        ((Sn::BrowserWindow*)m_hand)->postMouseEvent(
            (Sn::ButtonType)obj[""type""].toInt(),
            (Sn::ButtonAction)obj[""action""].toInt(),
            x,
            y);
        PLOGD << ""do cmd set mouse  "" << "" x:""<<x<<"" y:""<<y;
    }*/
    else if (type == 6) { //颜色
        if (data.size()) {
            ((Sn::BrowserWindow*)m_hand)->dosignalsetcolor(data.data());
        }
    }
    else if (type == 7 && m_hand) {
        ((Sn::BrowserWindow*)m_hand)->dosignalclearPanit();
    }
    else if (type == 8 && m_hand) {
        ((Sn::BrowserWindow*)m_hand)->dosignalzoom(data.toInt());
    }
    else {
        PLOGE << ""unknow cmd type  "" << type;
    }
}
",16361,False,2390.4472159959455,median
"// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
// 
// File: MarshalNative.cpp
//

//
// FCall's for the PInvoke classlibs
//


#include ""common.h""
#include ""clsload.hpp""
#include ""method.hpp""
#include ""class.h""
#include ""object.h""
#include ""field.h""
#include ""util.hpp""
#include ""excep.h""
#include ""siginfo.hpp""
#include ""threads.h""
#include ""stublink.h""
#include ""dllimport.h""
#include ""jitinterface.h""
#include ""eeconfig.h""
#include ""log.h""
#include ""fieldmarshaler.h""
#include ""cgensys.h""
#include ""gcheaputilities.h""
#include ""dbginterface.h""
#include ""marshalnative.h""
#include ""fcall.h""
#include ""dllimportcallback.h""
#include ""comdelegate.h""
#include ""typestring.h""
#include ""appdomain.inl""

#ifdef FEATURE_COMINTEROP
#include ""comcallablewrapper.h""
#include ""cominterfacemarshaler.h""
#include ""commtmemberinfomap.h""
#include ""runtimecallablewrapper.h""
#include ""olevariant.h""
#include ""interoputil.h""
#include ""stubhelpers.h""
#endif // FEATURE_COMINTEROP

#ifdef FEATURE_COMINTEROP_APARTMENT_SUPPORT
#include ""olecontexthelpers.h""
#endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT

//
// NumParamBytes
// Counts # of parameter bytes
INT32 QCALLTYPE MarshalNative::NumParamBytes(MethodDesc * pMD)
{
    QCALL_CONTRACT;

    // Arguments are check on managed side
    PRECONDITION(pMD != NULL);

    INT32 cbParamBytes = 0;

    BEGIN_QCALL;

    if (!(pMD->IsNDirect()))
        COMPlusThrow(kArgumentException, IDS_EE_NOTNDIRECT);

    // Read the unmanaged stack size from the stub MethodDesc. For vararg P/Invoke,
    // this function returns size of the fixed portion of the stack.
    // Note that the following code does not throw if the DllImport declaration is
    // incorrect (such as a vararg method not marked as CallingConvention.Cdecl).

    MethodDesc * pStubMD = NULL;

    PCODE pTempStub = NULL;
    pTempStub = GetStubForInteropMethod(pMD, NDIRECTSTUB_FL_FOR_NUMPARAMBYTES, &pStubMD);
    _ASSERTE(pTempStub == NULL);

    _ASSERTE(pStubMD != NULL && pStubMD->IsILStub());

    cbParamBytes = pStubMD->AsDynamicMethodDesc()->GetNativeStackArgSize();

#ifdef _X86_
    if (((NDirectMethodDesc *)pMD)->IsThisCall())
    {
        // The size of 'this' is not included in native stack arg size.
        cbParamBytes += sizeof(LPVOID);
    }
#endif // _X86_

    END_QCALL;

    return cbParamBytes;
}


// Prelink
// Does advance loading of an N/Direct library
VOID QCALLTYPE MarshalNative::Prelink(MethodDesc * pMD)
{
    QCALL_CONTRACT;

    // Arguments are check on managed side
    PRECONDITION(pMD != NULL);

    // If the code is already ready, we are done. Else, we need to execute the prestub
    // This is a perf thing since it's always safe to execute the prestub twice.
    if (!pMD->IsPointingToPrestub())
        return;

    // Silently ignore if not N/Direct and not runtime generated.
    if (!(pMD->IsNDirect()) && !(pMD->IsRuntimeSupplied()))
        return;

    BEGIN_QCALL;

    pMD->CheckRestore();
    pMD->DoPrestub(NULL);

    END_QCALL;
}


FCIMPL3(VOID, MarshalNative::StructureToPtr, Object* pObjUNSAFE, LPVOID ptr, CLR_BOOL fDeleteOld)
{    
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(ptr, NULL_OK));
    }
    CONTRACTL_END;

    OBJECTREF pObj = (OBJECTREF) pObjUNSAFE;

    HELPER_METHOD_FRAME_BEGIN_1(pObj);

    if (ptr == NULL)
        COMPlusThrowArgumentNull(W(""ptr""));
    if (pObj == NULL) 
        COMPlusThrowArgumentNull(W(""structure""));

    // Code path will accept both regular layout objects and boxed value classes
    // with layout.

    MethodTable *pMT = pObj->GetMethodTable();

    if (pMT->HasInstantiation())
        COMPlusThrowArgumentException(W(""structure""), W(""Argument_NeedNonGenericObject""));
    
    if (pMT->IsBlittable())
    {
        memcpyNoGCRefs(ptr, pObj->GetData(), pMT->GetNativeSize());
    }
    else if (pMT->HasLayout())
    {
        if (fDeleteOld)
            LayoutDestroyNative(ptr, pMT);

        FmtClassUpdateNative( &(pObj), (LPBYTE)(ptr), NULL );
    }
    else
    {
        COMPlusThrowArgumentException(W(""structure""), W(""Argument_MustHaveLayoutOrBeBlittable""));
    }

    HELPER_METHOD_FRAME_END();
}
FCIMPLEND

FCIMPL3(VOID, MarshalNative::PtrToStructureHelper, LPVOID ptr, Object* pObjIn, CLR_BOOL allowValueClasses)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(ptr, NULL_OK));
    }
    CONTRACTL_END;

    OBJECTREF  pObj = ObjectToOBJECTREF(pObjIn);
    
    HELPER_METHOD_FRAME_BEGIN_1(pObj);

    if (ptr == NULL)
        COMPlusThrowArgumentNull(W(""ptr""));
    if (pObj == NULL) 
        COMPlusThrowArgumentNull(W(""structure""));

    // Code path will accept regular layout objects.
    MethodTable *pMT = pObj->GetMethodTable();

    // Validate that the object passed in is not a value class.
    if (!allowValueClasses && pMT->IsValueType())
    {
        COMPlusThrowArgumentException(W(""structure""), W(""Argument_StructMustNotBeValueClass""));
    }
    else if (pMT->IsBlittable())
    {
        memcpyNoGCRefs(pObj->GetData(), ptr, pMT->GetNativeSize());
    }
    else if (pMT->HasLayout())
    {
        LayoutUpdateCLR((LPVOID*) &(pObj), Object::GetOffsetOfFirstField(), pMT, (LPBYTE)(ptr));
    }
    else
    {
        COMPlusThrowArgumentException(W(""structure""), W(""Argument_MustHaveLayoutOrBeBlittable""));
    }   
    
    HELPER_METHOD_FRAME_END();  
}
FCIMPLEND


FCIMPL2(VOID, MarshalNative::DestroyStructure, LPVOID ptr, ReflectClassBaseObject* refClassUNSAFE)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(ptr, NULL_OK));
    }
    CONTRACTL_END;

    REFLECTCLASSBASEREF refClass = (REFLECTCLASSBASEREF) refClassUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_1(refClass);

    if (ptr == NULL)
        COMPlusThrowArgumentNull(W(""ptr""));
    if (refClass == NULL)
        COMPlusThrowArgumentNull(W(""structureType""));
    if (refClass->GetMethodTable() != g_pRuntimeTypeClass)
        COMPlusThrowArgumentException(W(""structureType""), W(""Argument_MustBeRuntimeType""));

    TypeHandle th = refClass->GetType();

    if (th.HasInstantiation())
        COMPlusThrowArgumentException(W(""structureType""), W(""Argument_NeedNonGenericType""));

    if (th.IsBlittable())
    {
        // ok to call with blittable structure, but no work to do in this case.
    }
    else if (th.HasLayout())
    {
        LayoutDestroyNative(ptr, th.GetMethodTable());
    }
    else
    {
        COMPlusThrowArgumentException(W(""structureType""), W(""Argument_MustHaveLayoutOrBeBlittable""));
    }

    HELPER_METHOD_FRAME_END();
}
FCIMPLEND

FCIMPL1(FC_BOOL_RET, MarshalNative::IsPinnable, Object* obj)
{
    FCALL_CONTRACT;

    VALIDATEOBJECT(obj);

    if (obj == NULL)
        FC_RETURN_BOOL(TRUE);

    if (obj->GetMethodTable() == g_pStringClass)
        FC_RETURN_BOOL(TRUE);

    if (obj->GetMethodTable()->IsArray())
    {
        BASEARRAYREF asArray = (BASEARRAYREF)ObjectToOBJECTREF(obj);
        if (CorTypeInfo::IsPrimitiveType(asArray->GetArrayElementType()))
            FC_RETURN_BOOL(TRUE);

        TypeHandle th = asArray->GetArrayElementTypeHandle();
        if (!th.IsTypeDesc())
        {
            MethodTable *pMT = th.AsMethodTable();
            if (pMT->IsValueType() && pMT->IsBlittable())
                FC_RETURN_BOOL(TRUE);
        }

        FC_RETURN_BOOL(FALSE);
    }

    FC_RETURN_BOOL(obj->GetMethodTable()->IsBlittable());
}
FCIMPLEND

/************************************************************************
 * PInvoke.SizeOf(Class)
 */
FCIMPL2(UINT32, MarshalNative::SizeOfClass, ReflectClassBaseObject* refClassUNSAFE, CLR_BOOL throwIfNotMarshalable)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(refClassUNSAFE));
    }
    CONTRACTL_END;

    UINT32 rv = 0;
    REFLECTCLASSBASEREF refClass = (REFLECTCLASSBASEREF)refClassUNSAFE;
    
    HELPER_METHOD_FRAME_BEGIN_RET_1(refClass);
    
    // refClass is validated to be non-NULL RuntimeType by callers
    TypeHandle th = refClass->GetType();

    if (throwIfNotMarshalable)
    {
        // Determine if the type is marshalable
        if (!IsStructMarshalable(th))
        {
            // It isn't marshalable so throw an ArgumentException.
            StackSString strTypeName;
            TypeString::AppendType(strTypeName, th);                
            COMPlusThrow(kArgumentException, IDS_CANNOT_MARSHAL, strTypeName.GetUnicode(), NULL, NULL);
        }
    }

    // The type is marshalable or we don't care so return its size.
    rv = th.GetMethodTable()->GetNativeSize();
    HELPER_METHOD_FRAME_END();
    return rv;   
}
FCIMPLEND


/************************************************************************
 * PInvoke.OffsetOfHelper(Class, Field)
 */
FCIMPL1(UINT32, MarshalNative::OffsetOfHelper, ReflectFieldObject *pFieldUNSAFE)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(pFieldUNSAFE));
    }
    CONTRACTL_END;

    REFLECTFIELDREF refField = (REFLECTFIELDREF)ObjectToOBJECTREF(pFieldUNSAFE);

    FieldDesc *pField = refField->GetField();
    TypeHandle th = TypeHandle(pField->GetApproxEnclosingMethodTable());

    // Determine if the type is marshalable.
    if (!IsStructMarshalable(th))
    {
        // It isn't marshalable so throw an ArgumentException.
        HELPER_METHOD_FRAME_BEGIN_RET_1(refField);       

        StackSString strTypeName;
        TypeString::AppendType(strTypeName, th);                
        COMPlusThrow(kArgumentException, IDS_CANNOT_MARSHAL, strTypeName.GetUnicode(), NULL, NULL);       

        HELPER_METHOD_FRAME_END();
    }

    FieldMarshaler *pFM = th.GetMethodTable()->GetLayoutInfo()->GetFieldMarshalers();
    UINT  numReferenceFields = th.GetMethodTable()->GetLayoutInfo()->GetNumCTMFields();

    while (numReferenceFields--) 
    {
        if (pFM->GetFieldDesc() == pField) 
        {
            return pFM->GetExternalOffset();
        }
        ((BYTE*&)pFM) += MAXFIELDMARSHALERSIZE;
    }

    UNREACHABLE_MSG(""We should never hit this point since we already verified that the requested field was present from managed code"");   
}
FCIMPLEND

FCIMPL2(Object*, MarshalNative::GetDelegateForFunctionPointerInternal, LPVOID FPtr, ReflectClassBaseObject* refTypeUNSAFE)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(refTypeUNSAFE != NULL);
    }
    CONTRACTL_END;

    OBJECTREF refDelegate = NULL;
    
    REFLECTCLASSBASEREF refType = (REFLECTCLASSBASEREF) refTypeUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_2(refType, refDelegate);

    // Retrieve the method table from the RuntimeType. We already verified in managed
    // code that the type was a RuntimeType that represented a delegate. Because type handles
    // for delegates must have a method table, we are safe in telling prefix to assume it below.
    MethodTable* pMT = refType->GetType().GetMethodTable();   
    PREFIX_ASSUME(pMT != NULL);
    refDelegate = COMDelegate::ConvertToDelegate(FPtr, pMT);

    HELPER_METHOD_FRAME_END();

    return OBJECTREFToObject(refDelegate);
}
FCIMPLEND

FCIMPL1(LPVOID, MarshalNative::GetFunctionPointerForDelegateInternal, Object* refDelegateUNSAFE)
{
    FCALL_CONTRACT;

    LPVOID pFPtr = NULL;
    
    OBJECTREF refDelegate = (OBJECTREF) refDelegateUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_1(refDelegate);

    pFPtr = COMDelegate::ConvertToCallback(refDelegate);
    
    HELPER_METHOD_FRAME_END();

    return pFPtr;
}
FCIMPLEND

//====================================================================
// map a fiber cookie from the hosting APIs into a managed Thread object
//====================================================================
FCIMPL1(THREADBASEREF, MarshalNative::GetThreadFromFiberCookie, int cookie)
{
    FCALL_CONTRACT;

    _ASSERTE(cookie);

    THREADBASEREF ret = 0;
    
    // Set up a frame
    HELPER_METHOD_FRAME_BEGIN_RET_0();

    // Any host who is sophisticated enough to correctly schedule fibers
    // had better be sophisticated enough to give us a real fiber cookie.
    Thread  *pThread = *((Thread **) &cookie);
    
    // Minimal check that it smells like a thread:
    _ASSERTE(pThread->m_fPreemptiveGCDisabled.Load() == 0 || pThread->m_fPreemptiveGCDisabled.Load() == 1);
    
    ret = (THREADBASEREF)(pThread->GetExposedObject()); 
    HELPER_METHOD_FRAME_END();

    return ret;
}
FCIMPLEND

FCIMPL3(LPVOID, MarshalNative::GetUnmanagedThunkForManagedMethodPtr, LPVOID pfnMethodToWrap, PCCOR_SIGNATURE pbSignature, ULONG cbSignature)
{
    CONTRACTL
    {
        FCALL_CHECK;
        INJECT_FAULT(FCThrow(kOutOfMemoryException););
        PRECONDITION(CheckPointer(pfnMethodToWrap, NULL_OK));
        PRECONDITION(CheckPointer(pbSignature, NULL_OK));
    }
    CONTRACTL_END;

    LPVOID pThunk = NULL;
    return pThunk;
}
FCIMPLEND


/************************************************************************
 * PInvoke.GetManagedThunkForUnmanagedMethodPtr()
 */
FCIMPL3(LPVOID, MarshalNative::GetManagedThunkForUnmanagedMethodPtr, LPVOID pfnMethodToWrap, PCCOR_SIGNATURE pbSignature, ULONG cbSignature)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(pfnMethodToWrap, NULL_OK));
        PRECONDITION(CheckPointer(pbSignature, NULL_OK));
    }
    CONTRACTL_END;

    LPVOID pThunk = NULL;
    return pThunk;
}
FCIMPLEND

/************************************************************************
 * PInvoke.GetLastWin32Error
 */
FCIMPL0(int, MarshalNative::GetLastWin32Error)
{
    FCALL_CONTRACT;

    return (UINT32)(GetThread()->m_dwLastError);
}
FCIMPLEND


/************************************************************************
 * PInvoke.SetLastWin32Error
 */
FCIMPL1(void, MarshalNative::SetLastWin32Error, int error)
{
    FCALL_CONTRACT;

    GetThread()->m_dwLastError = (DWORD)error;
}
FCIMPLEND


/************************************************************************
 * Support for the GCHandle class.
 */

 // Check that the supplied object is valid to put in a pinned handle.
// Throw an exception if not.
void ValidatePinnedObject(OBJECTREF obj)
{
    CONTRACTL
    {
        THROWS;
        GC_TRIGGERS;
        MODE_COOPERATIVE;
    }
    CONTRACTL_END;

    // NULL is fine.
    if (obj == NULL)
        return;

    if (obj->GetMethodTable() == g_pStringClass)
        return;

    if (obj->GetMethodTable()->IsArray())
    {
        BASEARRAYREF asArray = (BASEARRAYREF) obj;
        if (CorTypeInfo::IsPrimitiveType(asArray->GetArrayElementType())) 
            return;

        TypeHandle th = asArray->GetArrayElementTypeHandle();
        if (!th.IsTypeDesc())
        {
            MethodTable *pMT = th.AsMethodTable();
            if (pMT->IsValueType() && pMT->IsBlittable())
                return;
        }        
    } 
    else if (obj->GetMethodTable()->IsBlittable())
    {
        return;
    }

    COMPlusThrow(kArgumentException, IDS_EE_NOTISOMORPHIC);
}

NOINLINE static OBJECTHANDLE FCDiagCreateHandle(OBJECTREF objRef, int type)
{
    OBJECTHANDLE hnd = NULL;

    FC_INNER_PROLOG(MarshalNative::GCHandleInternalAlloc);

    // Make the stack walkable for the profiler
    HELPER_METHOD_FRAME_BEGIN_RET_ATTRIB_NOPOLL(Frame::FRAME_ATTR_EXACT_DEPTH | Frame::FRAME_ATTR_CAPTURE_DEPTH_2);
    hnd = GetAppDomain()->CreateTypedHandle(objRef, static_cast<HandleType>(type));
    HELPER_METHOD_FRAME_END_POLL();

    FC_INNER_EPILOG();

    return hnd;
}

FCIMPL2(LPVOID, MarshalNative::GCHandleInternalAlloc, Object *obj, int type)
{
    FCALL_CONTRACT;

    OBJECTREF objRef(obj);

    assert(type >= HNDTYPE_WEAK_SHORT && type <= HNDTYPE_WEAK_WINRT);

    if (CORProfilerTrackGC())
    {
        FC_INNER_RETURN(LPVOID, (LPVOID) FCDiagCreateHandle(objRef, type));
    }

    OBJECTHANDLE hnd = GetAppDomain()->GetHandleStore()->CreateHandleOfType(OBJECTREFToObject(objRef), static_cast<HandleType>(type));
    if (!hnd)
    {
        FCThrow(kOutOfMemoryException);
    }
    return (LPVOID) hnd;
}
FCIMPLEND

NOINLINE static void FCDiagDestroyHandle(OBJECTHANDLE handle)
{
    FC_INNER_PROLOG(MarshalNative::GCHandleInternalFree);

    // Make the stack walkable for the profiler
    HELPER_METHOD_FRAME_BEGIN_ATTRIB(Frame::FRAME_ATTR_EXACT_DEPTH | Frame::FRAME_ATTR_CAPTURE_DEPTH_2);
    DestroyTypedHandle(handle);
    HELPER_METHOD_FRAME_END();

    FC_INNER_EPILOG();
}

// Free a GC handle.
FCIMPL1(VOID, MarshalNative::GCHandleInternalFree, OBJECTHANDLE handle)
{
    FCALL_CONTRACT;

    if (CORProfilerTrackGC())
    {
        FC_INNER_RETURN_VOID(FCDiagDestroyHandle(handle));
    }

    GCHandleUtilities::GetGCHandleManager()->DestroyHandleOfUnknownType(handle);
}
FCIMPLEND

// Get the object referenced by a GC handle.
FCIMPL1(LPVOID, MarshalNative::GCHandleInternalGet, OBJECTHANDLE handle)
{
    FCALL_CONTRACT;

    OBJECTREF objRef;

    objRef = ObjectFromHandle(handle);

    return *((LPVOID*)&objRef);
}
FCIMPLEND

// Update the object referenced by a GC handle.
FCIMPL2(VOID, MarshalNative::GCHandleInternalSet, OBJECTHANDLE handle, Object *obj)
{
    FCALL_CONTRACT;

    OBJECTREF objRef(obj);
    StoreObjectInHandle(handle, objRef);
}
FCIMPLEND

// Update the object referenced by a GC handle.
FCIMPL3(Object*, MarshalNative::GCHandleInternalCompareExchange, OBJECTHANDLE handle, Object *obj, Object* oldObj)
{
    FCALL_CONTRACT;

    OBJECTREF newObjref(obj);
    OBJECTREF oldObjref(oldObj);
    LPVOID ret = NULL;
    // Update the stored object reference.
    ret = InterlockedCompareExchangeObjectInHandle(handle, newObjref, oldObjref);
    return (Object*)ret;
}
FCIMPLEND

//====================================================================
// *** Interop Helpers ***
//====================================================================

FCIMPL2(Object *, MarshalNative::GetExceptionForHR, INT32 errorCode, LPVOID errorInfo)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(FAILED(errorCode));
        PRECONDITION(CheckPointer(errorInfo, NULL_OK));
    }
    CONTRACTL_END;

    OBJECTREF RetExceptionObj = NULL;
    
    HELPER_METHOD_FRAME_BEGIN_RET_1(RetExceptionObj);

    // Retrieve the IErrorInfo to use.
    IErrorInfo *pErrorInfo = (IErrorInfo*)errorInfo;
    if (pErrorInfo == (IErrorInfo*)(-1))
    {
        pErrorInfo = NULL;
    }
    else if (!pErrorInfo)
    {
        if (SafeGetErrorInfo(&pErrorInfo) != S_OK)
            pErrorInfo = NULL;
    }

    ::GetExceptionForHR(errorCode, pErrorInfo, &RetExceptionObj);

    HELPER_METHOD_FRAME_END();

    return OBJECTREFToObject(RetExceptionObj);
}
FCIMPLEND

FCIMPL1(int, MarshalNative::GetHRForException, Object* eUNSAFE)
{
    CONTRACTL {
       NOTHROW;    // Used by reverse COM IL stubs, so we must not throw exceptions back to COM
       DISABLED(GC_TRIGGERS); // FCALLS with HELPER frames have issues with GC_TRIGGERS
       MODE_COOPERATIVE;
    } CONTRACTL_END;

    int retVal = 0;
    OBJECTREF e = (OBJECTREF) eUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_NOTHROW_1({ retVal = COR_E_STACKOVERFLOW; }, e);

    retVal = SetupErrorInfo(e);

    HELPER_METHOD_FRAME_END_NOTHROW();
    return retVal;
}
FCIMPLEND

FCIMPL1(int, MarshalNative::GetHRForException_WinRT, Object* eUNSAFE)
{
    CONTRACTL {
       NOTHROW;    // Used by reverse COM IL stubs, so we must not throw exceptions back to COM
       DISABLED(GC_TRIGGERS); // FCALLS with HELPER frames have issues with GC_TRIGGERS
       MODE_COOPERATIVE;
    } CONTRACTL_END;

    int retVal = 0;
    OBJECTREF e = (OBJECTREF) eUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_NOTHROW_1({ retVal = COR_E_STACKOVERFLOW; }, e);

    retVal = SetupErrorInfo(e, /* isWinRTScenario = */ TRUE);

    HELPER_METHOD_FRAME_END_NOTHROW();
    return retVal;
}
FCIMPLEND

#ifdef FEATURE_COMINTEROP

//====================================================================
// map GUID to Type
//====================================================================  

/*OBJECTREF */
FCIMPL1(Object*, MarshalNative::GetLoadedTypeForGUID, GUID* pGuid)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(pGuid, NULL_OK));
    }
    CONTRACTL_END;

    OBJECTREF refRetVal = NULL;
    HELPER_METHOD_FRAME_BEGIN_RET_1(refRetVal);

    if (!pGuid)
        COMPlusThrowArgumentNull(W(""pGuid""));

    AppDomain* pDomain = SystemDomain::GetCurrentDomain();
    _ASSERTE(pDomain);

    MethodTable* pMT = pDomain->LookupClass(*(pGuid));
    if (pMT)
        refRetVal = pMT->GetManagedClassObject();

    HELPER_METHOD_FRAME_END();
    return OBJECTREFToObject(refRetVal);
}
FCIMPLEND

//====================================================================
// map Type to ITypeInfo*
//====================================================================
FCIMPL1(ITypeInfo*, MarshalNative::GetITypeInfoForType, ReflectClassBaseObject* refClassUNSAFE)
{
    FCALL_CONTRACT;

    ITypeInfo* pTI = NULL;
    REFLECTCLASSBASEREF refClass = (REFLECTCLASSBASEREF) refClassUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_1(refClass);

    // Check for null arguments.
    if(!refClass)
        COMPlusThrowArgumentNull(W(""t""));
        
    MethodTable *pRefMT = refClass->GetMethodTable();
    if (pRefMT != g_pRuntimeTypeClass)
        COMPlusThrowArgumentException(W(""t""), W(""Argument_MustBeRuntimeType""));

    TypeHandle th = refClass->GetType();

    if (th.GetMethodTable() != NULL && (th.IsProjectedFromWinRT() || th.IsExportedToWinRT()))
        COMPlusThrowArgumentException(W(""t""), W(""Argument_ObjIsWinRTObject""));

    if (th.HasInstantiation())
        COMPlusThrowArgumentException(W(""t""), W(""Argument_NeedNonGenericType""));

    // Make sure the type is visible from COM.
    if (!::IsTypeVisibleFromCom(th))
        COMPlusThrowArgumentException(W(""t""), W(""Argument_TypeMustBeVisibleFromCom""));

    // Retrieve the EE class from the reflection type.
    MethodTable* pMT = th.GetMethodTable();          
    _ASSERTE(pMT);

    // Retrieve the ITypeInfo for the class.
    IfFailThrow(GetITypeInfoForEEClass(pMT, &pTI, true /* bClassInfo */));
    _ASSERTE(pTI != NULL);

    HELPER_METHOD_FRAME_END();
    return pTI;
}
FCIMPLEND

//====================================================================
// return the IUnknown* for an Object.
//====================================================================
FCIMPL2(IUnknown*, MarshalNative::GetIUnknownForObjectNative, Object* orefUNSAFE, CLR_BOOL fOnlyInContext)
{
    FCALL_CONTRACT;

    IUnknown* retVal = NULL;
    OBJECTREF oref = (OBJECTREF) orefUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_1(oref);

    HRESULT hr = S_OK;

    if(!oref)
        COMPlusThrowArgumentNull(W(""o""));

    // Ensure COM is started up.
    EnsureComStarted();

    if (fOnlyInContext && !IsObjectInContext(&oref))
        retVal = NULL;
    else
        retVal = GetComIPFromObjectRef(&oref, ComIpType_OuterUnknown, NULL);

    HELPER_METHOD_FRAME_END();
    return retVal;
}
FCIMPLEND

//====================================================================
// return the raw IUnknown* for a COM Object not related to current 
// context.
// Does not AddRef the returned pointer
//====================================================================
FCIMPL1(IUnknown*, MarshalNative::GetRawIUnknownForComObjectNoAddRef, Object* orefUNSAFE)
{
    FCALL_CONTRACT;

    IUnknown* retVal = NULL;
    OBJECTREF oref = (OBJECTREF) orefUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_1(oref);

    HRESULT hr = S_OK;

    if(!oref)
        COMPlusThrowArgumentNull(W(""o""));

    MethodTable* pMT = oref->GetMethodTable();
    PREFIX_ASSUME(pMT != NULL);    
    if(!pMT->IsComObjectType())
        COMPlusThrow(kArgumentException, IDS_EE_SRC_OBJ_NOT_COMOBJECT);
    
    // Ensure COM is started up.
    EnsureComStarted();

    RCWHolder pRCW(GetThread());
    pRCW.Init(oref);

    // Retrieve raw IUnknown * without AddRef for better performance
    retVal = pRCW->GetRawIUnknown_NoAddRef();
    
    HELPER_METHOD_FRAME_END();
    return retVal;
}
FCIMPLEND

//====================================================================
// return the IDispatch* for an Object.
//====================================================================
FCIMPL2(IDispatch*, MarshalNative::GetIDispatchForObjectNative, Object* orefUNSAFE, CLR_BOOL fOnlyInContext)
{
    FCALL_CONTRACT;

    IDispatch* retVal = NULL;
    OBJECTREF oref = (OBJECTREF) orefUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_1(oref);

    HRESULT hr = S_OK;

    if(!oref)
        COMPlusThrowArgumentNull(W(""o""));

    // Ensure COM is started up.
    EnsureComStarted();

    if (fOnlyInContext && !IsObjectInContext(&oref))
        retVal = NULL;
    else
        retVal = (IDispatch*)GetComIPFromObjectRef(&oref, ComIpType_Dispatch, NULL);

    HELPER_METHOD_FRAME_END();
    return retVal;
}
FCIMPLEND

//====================================================================
// return the IUnknown* representing the interface for the Object
// Object o should support Type T
//====================================================================
FCIMPL4(IUnknown*, MarshalNative::GetComInterfaceForObjectNative, Object* orefUNSAFE, ReflectClassBaseObject* refClassUNSAFE, CLR_BOOL fOnlyInContext, CLR_BOOL bEnableCustomizedQueryInterface)
{
    FCALL_CONTRACT;

    IUnknown* retVal  = NULL;
    OBJECTREF oref = (OBJECTREF) orefUNSAFE;
    REFLECTCLASSBASEREF refClass = (REFLECTCLASSBASEREF) refClassUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_2(oref, refClass);

    HRESULT hr = S_OK;

    if(!oref)
        COMPlusThrowArgumentNull(W(""o""));
    if(!refClass)
        COMPlusThrowArgumentNull(W(""t""));

    // Ensure COM is started up.
    EnsureComStarted();

    if (refClass->GetMethodTable() != g_pRuntimeTypeClass)
        COMPlusThrowArgumentException(W(""t""), W(""Argument_MustBeRuntimeType""));

    TypeHandle th = refClass->GetType();

    if (!th.SupportsGenericInterop(TypeHandle::Interop_NativeToManaged))
    {
        if (th.HasInstantiation())
            COMPlusThrowArgumentException(W(""t""), W(""Argument_NeedNonGenericType""));

        if (oref->GetMethodTable()->HasInstantiation())
            COMPlusThrowArgumentException(W(""o""), W(""Argument_NeedNonGenericObject""));
    }

    // If the IID being asked for does not represent an interface then
    // throw an argument exception.
    if (!th.IsInterface())
        COMPlusThrowArgumentException(W(""t""), W(""Arg_MustBeInterface""));

    // If the interface being asked for is not visible from COM then
    // throw an argument exception.
    if (!::IsTypeVisibleFromCom(th))
        COMPlusThrowArgumentException(W(""t""), W(""Argument_TypeMustBeVisibleFromCom""));

    if (fOnlyInContext && !IsObjectInContext(&oref))
        retVal = NULL;
    else
        retVal = GetComIPFromObjectRef(&oref, th.GetMethodTable(), TRUE, bEnableCustomizedQueryInterface);

    HELPER_METHOD_FRAME_END();
    return retVal;
}
FCIMPLEND

//====================================================================
// return an Object for IUnknown
//====================================================================
FCIMPL1(Object*, MarshalNative::GetObjectForIUnknown, IUnknown* pUnk)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(pUnk, NULL_OK));
    }
    CONTRACTL_END;

    OBJECTREF oref = NULL;
    HELPER_METHOD_FRAME_BEGIN_RET_1(oref);

    HRESULT hr = S_OK;

    if(!pUnk)
        COMPlusThrowArgumentNull(W(""pUnk""));

    // Ensure COM is started up.
    EnsureComStarted();

    GetObjectRefFromComIP(&oref, pUnk);

    HELPER_METHOD_FRAME_END();
    return OBJECTREFToObject(oref);
}
FCIMPLEND


FCIMPL1(Object*, MarshalNative::GetUniqueObjectForIUnknown, IUnknown* pUnk)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(pUnk, NULL_OK));
    }
    CONTRACTL_END;

    OBJECTREF oref = NULL;
    HELPER_METHOD_FRAME_BEGIN_RET_1(oref);

    HRESULT hr = S_OK;

    if(!pUnk)
        COMPlusThrowArgumentNull(W(""pUnk""));

    // Ensure COM is started up.
    EnsureComStarted();

    GetObjectRefFromComIP(&oref, pUnk, NULL, NULL, ObjFromComIP::UNIQUE_OBJECT);

    HELPER_METHOD_FRAME_END();
    return OBJECTREFToObject(oref);    
}
FCIMPLEND

//====================================================================
// return an Object for IUnknown, using the Type T, 
//  NOTE: 
//  Type T should be either a COM imported Type or a sub-type of COM imported Type
//====================================================================
FCIMPL2(Object*, MarshalNative::GetTypedObjectForIUnknown, IUnknown* pUnk, ReflectClassBaseObject* refClassUNSAFE)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(pUnk, NULL_OK));
    }
    CONTRACTL_END;

    OBJECTREF oref = NULL;
    REFLECTCLASSBASEREF refClass = (REFLECTCLASSBASEREF) refClassUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_2(refClass, oref);

    HRESULT hr = S_OK;

    MethodTable* pMTClass =  NULL;

    if(!pUnk)
        COMPlusThrowArgumentNull(W(""pUnk""));

    if(refClass != NULL)
    {
        if (refClass->GetMethodTable() != g_pRuntimeTypeClass)
            COMPlusThrowArgumentException(W(""t""), W(""Argument_MustBeRuntimeType""));

        TypeHandle th = refClass->GetType();
        
        if (th.GetMethodTable() != NULL && (th.IsProjectedFromWinRT() || th.IsExportedToWinRT()))
            COMPlusThrowArgumentException(W(""t""), W(""Argument_ObjIsWinRTObject""));

        if (th.HasInstantiation())
            COMPlusThrowArgumentException(W(""t""), W(""Argument_NeedNonGenericType""));

        pMTClass = th.GetMethodTable();
    }
    else 
        COMPlusThrowArgumentNull(W(""t""));


    // Ensure COM is started up.
    EnsureComStarted();

    GetObjectRefFromComIP(&oref, pUnk, pMTClass);

    HELPER_METHOD_FRAME_END();
    return OBJECTREFToObject(oref);
}
FCIMPLEND

FCIMPL2(IUnknown*, MarshalNative::CreateAggregatedObject, IUnknown* pOuter, Object* refObjUNSAFE)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(pOuter, NULL_OK));
    }
    CONTRACTL_END;

    IUnknown* pInner = NULL;
    
    OBJECTREF oref =  (OBJECTREF)refObjUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_1(oref);

    HRESULT hr = S_OK;

    if (!pOuter)
        COMPlusThrowArgumentNull(W(""pOuter""));

    if (oref == NULL)
        COMPlusThrowArgumentNull(W(""o""));

    MethodTable *pMT = oref->GetMethodTable();
    if (pMT->IsWinRTObjectType() || pMT->IsExportedToWinRT())
        COMPlusThrowArgumentException(W(""o""), W(""Argument_ObjIsWinRTObject""));

    // Ensure COM is started up.
    EnsureComStarted();

    if (NULL != ComCallWrapper::GetWrapperForObject(oref))
        COMPlusThrowArgumentException(W(""o""), W(""Argument_AlreadyACCW""));

    //get wrapper for the object, this could enable GC
    CCWHolder pWrap =  ComCallWrapper::InlineGetWrapper(&oref); 

    // Aggregation support, 
    pWrap->InitializeOuter(pOuter);                                             
    IfFailThrow(pWrap->GetInnerUnknown((LPVOID*)&pInner));           

    HELPER_METHOD_FRAME_END();
    return pInner;
}
FCIMPLEND

//====================================================================
// Free unused RCWs in the current COM+ context.
//====================================================================
FCIMPL0(void, MarshalNative::CleanupUnusedObjectsInCurrentContext)
{
    FCALL_CONTRACT;

    HELPER_METHOD_FRAME_BEGIN_0();

    if (g_pRCWCleanupList)
    {
        g_pRCWCleanupList->CleanupWrappersInCurrentCtxThread(
            TRUE,       // fWait
            TRUE,       // fManualCleanupRequested
            TRUE        // bIgnoreComObjectEagerCleanupSetting
            );
    }

    HELPER_METHOD_FRAME_END();
}
FCIMPLEND

//====================================================================
// Checks whether there are RCWs from any context available for cleanup.
//====================================================================
FCIMPL0(FC_BOOL_RET, MarshalNative::AreComObjectsAvailableForCleanup)
{
    FCALL_CONTRACT;

    BOOL retVal = FALSE;
    if (g_pRCWCleanupList)
    {
        retVal = !g_pRCWCleanupList->IsEmpty();
    }

    FC_RETURN_BOOL(retVal);
}
FCIMPLEND

//====================================================================
// check if the object is classic COM component
//====================================================================
FCIMPL1(FC_BOOL_RET, MarshalNative::IsComObject, Object* objUNSAFE)
{
    FCALL_CONTRACT;

    BOOL retVal = FALSE;
    OBJECTREF obj = (OBJECTREF) objUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_1(obj);

    if(!obj)
        COMPlusThrowArgumentNull(W(""o""));

    MethodTable* pMT = obj->GetMethodTable();
    PREFIX_ASSUME(pMT != NULL);
    retVal = pMT->IsComObjectType();

    HELPER_METHOD_FRAME_END();
    FC_RETURN_BOOL(retVal);
}
FCIMPLEND


//====================================================================
// free the COM component and zombie this object if the ref count hits 0
// further usage of this Object might throw an exception, 
//====================================================================
FCIMPL1(INT32, MarshalNative::ReleaseComObject, Object* objUNSAFE)
{
    FCALL_CONTRACT;

    INT32 retVal = 0;
    OBJECTREF obj = (OBJECTREF) objUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_1(obj);

    if(!obj)
        COMPlusThrowArgumentNull(W(""o""));

    MethodTable* pMT = obj->GetMethodTable();
    PREFIX_ASSUME(pMT != NULL);    
    if(!pMT->IsComObjectType())
        COMPlusThrow(kArgumentException, IDS_EE_SRC_OBJ_NOT_COMOBJECT);

    // remove the wrapper from the object
    retVal = RCW::ExternalRelease(&obj);

    HELPER_METHOD_FRAME_END();
    return retVal;
}
FCIMPLEND

//====================================================================
// free the COM component and zombie this object
// further usage of this Object might throw an exception, 
//====================================================================
FCIMPL1(void, MarshalNative::FinalReleaseComObject, Object* objUNSAFE)
{
    FCALL_CONTRACT;

    OBJECTREF obj = (OBJECTREF) objUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_1(obj);

    if(!obj)
        COMPlusThrowArgumentNull(W(""o""));

    MethodTable* pMT = obj->GetMethodTable();
    PREFIX_ASSUME(pMT != NULL);    
    if(!pMT->IsComObjectType())
        COMPlusThrow(kArgumentException, IDS_EE_SRC_OBJ_NOT_COMOBJECT);

    // remove the wrapper from the object
    RCW::FinalExternalRelease(&obj);

    HELPER_METHOD_FRAME_END();
}
FCIMPLEND


//====================================================================
// This method takes the given COM object and wraps it in an object
// of the specified type. The type must be derived from __ComObject.
//====================================================================
FCIMPL2(Object*, MarshalNative::InternalCreateWrapperOfType, Object* objUNSAFE, ReflectClassBaseObject* refClassUNSAFE)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(objUNSAFE != NULL);
        PRECONDITION(refClassUNSAFE != NULL);
    }
    CONTRACTL_END;

    struct _gc
    {
        OBJECTREF refRetVal;
        OBJECTREF obj;
        REFLECTCLASSBASEREF refClass;
    } gc;

    gc.refRetVal = NULL;
    gc.obj = (OBJECTREF) objUNSAFE;
    gc.refClass = (REFLECTCLASSBASEREF) refClassUNSAFE;
    
    HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);

    // Validate the arguments.
    if (gc.refClass->GetMethodTable() != g_pRuntimeTypeClass)
        COMPlusThrowArgumentException(W(""t""), W(""Argument_MustBeRuntimeType""));

    // Retrieve the class of the COM object.
    MethodTable *pObjMT = gc.obj->GetMethodTable();

    // Retrieve the method table for new wrapper type.
    MethodTable *pNewWrapMT = gc.refClass->GetType().GetMethodTable();

    // Validate that the destination type is a COM object.
    _ASSERTE(pNewWrapMT->IsComObjectType());

    BOOL fSet = FALSE;
    
    // Start by checking if we can cast the obj to the wrapper type.
    if (TypeHandle(pObjMT).CanCastTo(TypeHandle(pNewWrapMT)))
    {
        gc.refRetVal = gc.obj;
        fSet = TRUE;
    }

    if (!fSet)
    {
        // Validate that the source object is a valid COM object.
        _ASSERTE(pObjMT->IsComObjectType());

        RCWHolder pRCW(GetThread());

        RCWPROTECT_BEGIN(pRCW, gc.obj);
        
        // Make sure the COM object supports all the COM imported interfaces that the new 
        // wrapper class implements.
        MethodTable::InterfaceMapIterator it = pNewWrapMT->IterateInterfaceMap();
        while (it.Next())
        {
            MethodTable *pItfMT = it.GetInterface();
            if (pItfMT->IsComImport())
            {
                if (!Object::SupportsInterface(gc.obj, pItfMT))
                    COMPlusThrow(kInvalidCastException, IDS_EE_CANNOT_COERCE_COMOBJECT);
            }
        }
        
        // Create the duplicate wrapper object.
        {
            RCWHolder pNewRCW(GetThread());
            pRCW->CreateDuplicateWrapper(pNewWrapMT, &pNewRCW);
            
            gc.refRetVal = pNewRCW->GetExposedObject();
        }

        RCWPROTECT_END(pRCW);
    }
    
    HELPER_METHOD_FRAME_END();
    return OBJECTREFToObject(gc.refRetVal);
}
FCIMPLEND


//====================================================================
// check if the type is visible from COM.
//====================================================================
FCIMPL1(FC_BOOL_RET, MarshalNative::IsTypeVisibleFromCom, ReflectClassBaseObject* refClassUNSAFE)
{
    FCALL_CONTRACT;

    BOOL retVal = FALSE;
    REFLECTCLASSBASEREF refClass = (REFLECTCLASSBASEREF) refClassUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_1(refClass);

    // Validate the arguments.
    if (refClass == NULL) 
        COMPlusThrowArgumentNull(W(""t""));
        
    MethodTable *pRefMT = refClass->GetMethodTable();
    if (pRefMT != g_pRuntimeTypeClass)
        COMPlusThrowArgumentException(W(""t""), W(""Argument_MustBeRuntimeType""));

    // Call the internal version of IsTypeVisibleFromCom.
    retVal = ::IsTypeVisibleFromCom(refClass->GetType());

    HELPER_METHOD_FRAME_END();
    FC_RETURN_BOOL(retVal);
}
FCIMPLEND


//====================================================================
// IUnknown Helpers
//====================================================================
// IUnknown::QueryInterface
FCIMPL3(HRESULT, MarshalNative::QueryInterface, IUnknown* pUnk, REFGUID iid, void** ppv)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(pUnk, NULL_OK));
        PRECONDITION(CheckPointer(ppv));
    }
    CONTRACTL_END;

    HRESULT hr = S_OK;
    HELPER_METHOD_FRAME_BEGIN_RET_0();

    if (!pUnk)
        COMPlusThrowArgumentNull(W(""pUnk""));

    hr = SafeQueryInterface(pUnk,iid,(IUnknown**)ppv);
    LogInteropQI(pUnk, iid, hr, ""PInvoke::QI"");

    HELPER_METHOD_FRAME_END();
    return hr;
}
FCIMPLEND

// IUnknown::AddRef
FCIMPL1(ULONG, MarshalNative::AddRef, IUnknown* pUnk)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(pUnk, NULL_OK));
    }
    CONTRACTL_END;

    ULONG cbRef = 0;
    HELPER_METHOD_FRAME_BEGIN_RET_0();

    if (!pUnk)
        COMPlusThrowArgumentNull(W(""pUnk""));

    cbRef = SafeAddRef(pUnk);
    LogInteropAddRef(pUnk, cbRef, ""PInvoke.AddRef"");

    HELPER_METHOD_FRAME_END();
    return cbRef;
}
FCIMPLEND

//IUnknown::Release
FCIMPL1(ULONG, MarshalNative::Release, IUnknown* pUnk)
{   
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(pUnk, NULL_OK));
    }
    CONTRACTL_END;

    ULONG cbRef = 0;
    HELPER_METHOD_FRAME_BEGIN_RET_0();

    if (!pUnk)
        COMPlusThrowArgumentNull(W(""pUnk""));

    cbRef = SafeRelease(pUnk);
    LogInteropRelease(pUnk, cbRef, ""PInvoke.Release"");

    HELPER_METHOD_FRAME_END();
    return cbRef;
}
FCIMPLEND

FCIMPL2(void, MarshalNative::GetNativeVariantForObject, Object* ObjUNSAFE, LPVOID pDestNativeVariant)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(pDestNativeVariant, NULL_OK));
    }
    CONTRACTL_END;

    OBJECTREF Obj = (OBJECTREF) ObjUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_1(Obj);

    if (pDestNativeVariant == NULL)
        COMPlusThrowArgumentNull(W(""pDstNativeVariant""));
    
    if (Obj == NULL)
    {
        // Will return empty variant in MarshalOleVariantForObject
    }
    else if (Obj->GetMethodTable()->HasInstantiation())
    {
        COMPlusThrowArgumentException(W(""obj""), W(""Argument_NeedNonGenericObject""));
    }

    // intialize the output variant
    SafeVariantInit((VARIANT*)pDestNativeVariant);
    OleVariant::MarshalOleVariantForObject(&Obj, (VARIANT*)pDestNativeVariant);

    HELPER_METHOD_FRAME_END();
}
FCIMPLEND

FCIMPL1(Object*, MarshalNative::GetObjectForNativeVariant, LPVOID pSrcNativeVariant)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(pSrcNativeVariant, NULL_OK));
    }
    CONTRACTL_END;

    OBJECTREF Obj = NULL;
    HELPER_METHOD_FRAME_BEGIN_RET_1(Obj);

    if (pSrcNativeVariant == NULL)
        COMPlusThrowArgumentNull(W(""pSrcNativeVariant""));

    OleVariant::MarshalObjectForOleVariant((VARIANT*)pSrcNativeVariant, &Obj);

    HELPER_METHOD_FRAME_END();
    return OBJECTREFToObject(Obj);
}
FCIMPLEND

FCIMPL2(Object*, MarshalNative::GetObjectsForNativeVariants, VARIANT* aSrcNativeVariant, int cVars)
{
    CONTRACTL
    {
        FCALL_CHECK;
        INJECT_FAULT(FCThrow(kOutOfMemoryException););
        PRECONDITION(CheckPointer(aSrcNativeVariant, NULL_OK));
    }
    CONTRACTL_END;

    PTRARRAYREF Array = NULL;
    HELPER_METHOD_FRAME_BEGIN_RET_1(Array);

    if (aSrcNativeVariant == NULL)
        COMPlusThrowArgumentNull(W(""aSrcNativeVariant""));
    if (cVars < 0)
        COMPlusThrowArgumentOutOfRange(W(""cVars""), W(""ArgumentOutOfRange_NeedNonNegNum""));

    OBJECTREF Obj = NULL;
    GCPROTECT_BEGIN(Obj)
    {
        // Allocate the array of objects.
        Array = (PTRARRAYREF)AllocateObjectArray(cVars, g_pObjectClass);

        // Convert each VARIANT in the array into an object.
        for (int i = 0; i < cVars; i++)
        {
            OleVariant::MarshalObjectForOleVariant(&aSrcNativeVariant[i], &Obj);
            Array->SetAt(i, Obj);
        }
    }
    GCPROTECT_END();

    HELPER_METHOD_FRAME_END();
    return OBJECTREFToObject(Array);
}
FCIMPLEND


FCIMPL2(void, MarshalNative::DoGenerateGuidForType, GUID * result, ReflectClassBaseObject* refTypeUNSAFE)
{
    FCALL_CONTRACT;

    REFLECTCLASSBASEREF refType = (REFLECTCLASSBASEREF) refTypeUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_1(refType);
    GCPROTECT_BEGININTERIOR (result);

    // Validate the arguments.
    if (refType == NULL)
        COMPlusThrowArgumentNull(W(""type""));
        
    MethodTable *pRefMT = refType->GetMethodTable();
    if (pRefMT != g_pRuntimeTypeClass)
        COMPlusThrowArgumentException(W(""type""), W(""Argument_MustBeRuntimeType""));
    if (result == NULL)
        COMPlusThrow(kArgumentNullException, W(""ArgumentNull_GUID""));

    // Check to see if the type is a COM object or not.
    if (IsComObjectClass(refType->GetType())) 
    {
#ifdef FEATURE_COMINTEROP_UNMANAGED_ACTIVATION
        // The type is a COM object then we get the GUID from the class factory.
        SyncBlock* pSyncBlock = refType->GetSyncBlock();

        ComClassFactory* pComClsFac = pSyncBlock->GetInteropInfo()->GetComClassFactory();
        memcpy(result, &pComClsFac->m_rclsid, sizeof(GUID));
#else // FEATURE_COMINTEROP_UNMANAGED_ACTIVATION
        memset(result,0,sizeof(GUID));
#endif // FEATURE_COMINTEROP_UNMANAGED_ACTIVATION
    }
    else
    {
        // The type is a normal COM+ class so we need to generate the GUID.
        TypeHandle classTH = refType->GetType();
        classTH.GetMethodTable()->GetGuid(result, TRUE);
    }
    
    GCPROTECT_END ();
    HELPER_METHOD_FRAME_END();
}
FCIMPLEND

FCIMPL2(void, MarshalNative::DoGetTypeLibGuid, GUID * result, Object* refTlbUNSAFE)
{
    FCALL_CONTRACT;

    OBJECTREF refTlb = (OBJECTREF) refTlbUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_1(refTlb);
    GCPROTECT_BEGININTERIOR (result);

    if (refTlb == NULL)
        COMPlusThrowArgumentNull(W(""pTLB""));

    // Ensure COM is started up.
    EnsureComStarted();

    SafeComHolder<ITypeLib> pTLB = (ITypeLib*)GetComIPFromObjectRef(&refTlb, IID_ITypeLib);
    if (!pTLB)
        COMPlusThrow(kArgumentException, W(""Arg_NoITypeLib""));

    GCX_PREEMP();

    // Retrieve the TLIBATTR.
    TLIBATTR *pAttr;
    IfFailThrow(pTLB->GetLibAttr(&pAttr));

    // Extract the guid from the TLIBATTR.
    *result = pAttr->guid;

    // Release the TLIBATTR now that we have the GUID.
    pTLB->ReleaseTLibAttr(pAttr);

    GCPROTECT_END ();
    HELPER_METHOD_FRAME_END();
}
FCIMPLEND

FCIMPL1(LCID, MarshalNative::GetTypeLibLcid, Object* refTlbUNSAFE)
{
    FCALL_CONTRACT;

    LCID retVal = 0;
    OBJECTREF refTlb = (OBJECTREF) refTlbUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_1(refTlb);

    if (refTlb == NULL)
        COMPlusThrowArgumentNull(W(""pTLB""));

    // Ensure COM is started up.
    EnsureComStarted();

    SafeComHolder<ITypeLib> pTLB = (ITypeLib*)GetComIPFromObjectRef(&refTlb, IID_ITypeLib);
    if (!pTLB)
        COMPlusThrow(kArgumentException, W(""Arg_NoITypeLib""));

    GCX_PREEMP();

    // Retrieve the TLIBATTR.
    TLIBATTR *pAttr;
    IfFailThrow(pTLB->GetLibAttr(&pAttr));

    // Extract the LCID from the TLIBATTR.
    retVal = pAttr->lcid;

    // Release the TLIBATTR now that we have the LCID.
    pTLB->ReleaseTLibAttr(pAttr);

    HELPER_METHOD_FRAME_END();
    return retVal;
}
FCIMPLEND

FCIMPL3(void, MarshalNative::GetTypeLibVersion, Object* refTlbUNSAFE, int *pMajor, int *pMinor)
{
    FCALL_CONTRACT;

    OBJECTREF refTlb = (OBJECTREF) refTlbUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_1(refTlb);

    if (refTlb == NULL)
        COMPlusThrowArgumentNull(W(""typeLibrary""));

    // Ensure COM is started up.
    EnsureComStarted();

    SafeComHolder<ITypeLib> pTLB = (ITypeLib*)GetComIPFromObjectRef(&refTlb, IID_ITypeLib);
    if (!pTLB)
        COMPlusThrow(kArgumentException, W(""Arg_NoITypeLib""));

    GCX_PREEMP();

    // Retrieve the TLIBATTR.
    TLIBATTR *pAttr;
    IfFailThrow(pTLB->GetLibAttr(&pAttr));

    // Extract the LCID from the TLIBATTR.
    *pMajor = pAttr->wMajorVerNum;
    *pMinor = pAttr->wMinorVerNum;

    // Release the TLIBATTR now that we have the version numbers.
    pTLB->ReleaseTLibAttr(pAttr);

    HELPER_METHOD_FRAME_END();
}
FCIMPLEND

FCIMPL2(void, MarshalNative::DoGetTypeInfoGuid, GUID * result, Object* refTypeInfoUNSAFE)
{
    FCALL_CONTRACT;

    OBJECTREF refTypeInfo = (OBJECTREF) refTypeInfoUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_1(refTypeInfo);
    GCPROTECT_BEGININTERIOR (result);

    if (refTypeInfo == NULL)
        COMPlusThrowArgumentNull(W(""typeInfo""));

    // Ensure COM is started up.
    EnsureComStarted();

    SafeComHolder<ITypeInfo> pTI = (ITypeInfo*)GetComIPFromObjectRef(&refTypeInfo, IID_ITypeInfo);
    if (!pTI)
        COMPlusThrow(kArgumentException, W(""Arg_NoITypeInfo""));

    GCX_PREEMP();

    // Retrieve the TYPEATTR.
    TYPEATTR *pAttr;
    IfFailThrow(pTI->GetTypeAttr(&pAttr));

    // Extract the guid from the TYPEATTR.
    *result = pAttr->guid;

    // Release the TYPEATTR now that we have the GUID.
    pTI->ReleaseTypeAttr(pAttr);

    GCPROTECT_END ();
    HELPER_METHOD_FRAME_END();
}
FCIMPLEND

FCIMPL2(void, MarshalNative::DoGetTypeLibGuidForAssembly, GUID * result, AssemblyBaseObject* refAsmUNSAFE)
{
    FCALL_CONTRACT;

    // Validate the arguments.
    _ASSERTE(refAsmUNSAFE != NULL);
    _ASSERTE(result != NULL);

    ASSEMBLYREF refAsm = (ASSEMBLYREF) refAsmUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_1(refAsm);
    GCPROTECT_BEGININTERIOR (result)

    HRESULT hr = S_OK;

    // Retrieve the assembly from the ASSEMBLYREF.
    Assembly *pAssembly = refAsm->GetAssembly();
    _ASSERTE(pAssembly);

    // Retrieve the TLBID for the assembly.
    IfFailThrow(::GetTypeLibGuidForAssembly(pAssembly, result));

    GCPROTECT_END ();
    HELPER_METHOD_FRAME_END();
}
FCIMPLEND

FCIMPL3(void, MarshalNative::GetTypeLibVersionForAssembly, AssemblyBaseObject* refAsmUNSAFE, INT32 *pMajorVersion, INT32 *pMinorVersion)
{
    FCALL_CONTRACT;

    // Validate the arguments.
    _ASSERTE(refAsmUNSAFE != NULL);

    ASSEMBLYREF refAsm = (ASSEMBLYREF) refAsmUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_1(refAsm);

    HRESULT hr = S_OK;

    // Retrieve the assembly from the ASSEMBLYREF.
    Assembly *pAssembly = refAsm->GetAssembly();
    _ASSERTE(pAssembly);

    // Retrieve the version for the assembly.
    USHORT usMaj, usMin;
    IfFailThrow(::GetTypeLibVersionForAssembly(pAssembly, &usMaj, &usMin));

    // Set the out parameters.
    *pMajorVersion = usMaj;
    *pMinorVersion = usMin;

    HELPER_METHOD_FRAME_END();
}
FCIMPLEND

FCIMPL1(int, MarshalNative::GetStartComSlot, ReflectClassBaseObject* tUNSAFE)
{
    FCALL_CONTRACT;

    int retVal = 0;
    REFLECTCLASSBASEREF t = (REFLECTCLASSBASEREF) tUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_1(t);

    if (!(t))
        COMPlusThrow(kArgumentNullException);
    
    MethodTable *pTMT = t->GetMethodTable();
    if (pTMT != g_pRuntimeTypeClass)
        COMPlusThrowArgumentException(W(""t""), W(""Argument_MustBeRuntimeType""));

    MethodTable *pMT = t->GetType().GetMethodTable();
    if (NULL == pMT)
        COMPlusThrow(kArgumentNullException);

    // The service does not make any sense to be called for non COM visible types.
    if (!::IsTypeVisibleFromCom(TypeHandle(pMT)))
        COMPlusThrowArgumentException(W(""t""), W(""Argument_TypeMustBeVisibleFromCom""));

    retVal = GetComSlotInfo(pMT, &pMT);

    HELPER_METHOD_FRAME_END();
    return retVal;
}
FCIMPLEND


FCIMPL1(int, MarshalNative::GetEndComSlot, ReflectClassBaseObject* tUNSAFE)
{
    FCALL_CONTRACT;

    int retVal = 0;
    REFLECTCLASSBASEREF t = (REFLECTCLASSBASEREF) tUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_RET_1(t);

    int StartSlot = -1;

    if (!(t))
        COMPlusThrow(kArgumentNullException);
    
    MethodTable *pTMT = t->GetMethodTable();
    if (pTMT != g_pRuntimeTypeClass)
        COMPlusThrowArgumentException(W(""t""), W(""Argument_MustBeRuntimeType""));

    TypeHandle classTH = t->GetType();
    MethodTable *pMT = classTH.GetMethodTable();
    if (NULL == pMT)
        COMPlusThrow(kArgumentNullException);

    // The service does not make any sense to be called for non COM visible types.
    if (!::IsTypeVisibleFromCom(classTH))
        COMPlusThrowArgumentException(W(""t""), W(""Argument_TypeMustBeVisibleFromCom""));

    // Retrieve the start slot and the default interface class.
    StartSlot = GetComSlotInfo(pMT, &pMT);
    if (StartSlot == -1)
    {
        retVal = StartSlot;
    }
    else
    {
        // Retrieve the map of members.
        ComMTMemberInfoMap MemberMap(pMT);
        MemberMap.Init(sizeof(void*));

        // The end slot is the start slot plus the number of user defined methods.
        retVal = int(StartSlot + MemberMap.GetMethods().Size() - 1);
    }

    HELPER_METHOD_FRAME_END();
    return retVal;
}
FCIMPLEND

FCIMPL1(int, MarshalNative::GetComSlotForMethodInfo, ReflectMethodObject* pMethodUNSAFE)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(pMethodUNSAFE));
        PRECONDITION(pMethodUNSAFE->GetMethod()->GetMethodTable()->IsInterface());
    }
    CONTRACTL_END;

    REFLECTMETHODREF refMethod = (REFLECTMETHODREF)ObjectToOBJECTREF(pMethodUNSAFE);
    MethodDesc *pMeth = refMethod->GetMethod();
    _ASSERTE(pMeth);
    int retVal = 0;
    HELPER_METHOD_FRAME_BEGIN_RET_1(refMethod);

    retVal = pMeth->GetComSlot();    

    HELPER_METHOD_FRAME_END();
    return retVal;
}
FCIMPLEND

FCIMPL3(Object*, MarshalNative::GetMethodInfoForComSlot, ReflectClassBaseObject* tUNSAFE, INT32 slot, ComMemberType* pMemberType)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(pMemberType, NULL_OK));
    }
    CONTRACTL_END;

    OBJECTREF refRetVal = NULL;
    REFLECTCLASSBASEREF t = (REFLECTCLASSBASEREF) tUNSAFE;
    REFLECTCLASSBASEREF tInterface = NULL;
    
    HELPER_METHOD_FRAME_BEGIN_RET_2(t, tInterface);

    int StartSlot = -1;
    OBJECTREF MemberInfoObj = NULL;

    if (!(t))
        COMPlusThrow(kArgumentNullException);
    
    MethodTable *pTMT = t->GetMethodTable();
    if (pTMT != g_pRuntimeTypeClass)
        COMPlusThrowArgumentException(W(""t""), W(""Argument_MustBeRuntimeType""));

    TypeHandle type = t->GetType();
    MethodTable *pMT= type.GetMethodTable();
    if (NULL == pMT)
        COMPlusThrow(kArgumentNullException);

    // The service does not make any sense to be called for non COM visible types.
    if (!::IsTypeVisibleFromCom(type))
        COMPlusThrowArgumentException(W(""t""), W(""Argument_TypeMustBeVisibleFromCom""));

    // Retrieve the start slot and the default interface class.
    StartSlot = GetComSlotInfo(pMT, &pMT);
    if (StartSlot == -1)
        COMPlusThrowArgumentOutOfRange(W(""slot""), W(""ArgumentOutOfRange_Count""));

    // Retrieve the map of members.
    ComMTMemberInfoMap MemberMap(pMT);
    MemberMap.Init(sizeof(void*));
    CQuickArray<ComMTMethodProps> &rProps = MemberMap.GetMethods();

    // Update the typehandle we'll be using based on the interface returned by GetComSlotInfo.
    tInterface = (REFLECTCLASSBASEREF)pMT->GetManagedClassObject();
    type = TypeHandle(pMT);

    // Make sure the specified slot is valid.
    if (slot < StartSlot)
        COMPlusThrowArgumentOutOfRange(W(""slot""), W(""ArgumentOutOfRange_Count""));
    if (slot >= StartSlot + (int)rProps.Size())
        COMPlusThrowArgumentOutOfRange(W(""slot""), W(""ArgumentOutOfRange_Count""));

    ComMTMethodProps *pProps = &rProps[slot - StartSlot];
    if (pProps->semantic >= FieldSemanticOffset)
    {
        // We are dealing with a field.
        ComCallMethodDesc *pFieldMeth = reinterpret_cast<ComCallMethodDesc*>(pProps->pMeth);
        FieldDesc *pField = pFieldMeth->GetFieldDesc();

        // call the managed code to get the FieldInfo
        MethodDescCallSite getFieldInfo(METHOD__CLASS__GET_FIELD_INFO);
        ARG_SLOT args[] =
        {
            ObjToArgSlot(tInterface),
            (ARG_SLOT)pField
        };
        
        MemberInfoObj = getFieldInfo.Call_RetOBJECTREF(args);

        *(pMemberType) = (pProps->semantic == (FieldSemanticOffset + msGetter)) ? CMT_PropGet : CMT_PropSet;
    }
    else if (pProps->property == mdPropertyNil)
    {
        // We are dealing with a normal property.

        // call the managed code to get the MethodInfo
        MethodDescCallSite getMethodBase(METHOD__CLASS__GET_METHOD_BASE);
        ARG_SLOT args[] = 
        {
            ObjToArgSlot(tInterface),
            (ARG_SLOT)pProps->pMeth
        };
        
        MemberInfoObj = getMethodBase.Call_RetOBJECTREF(args);
        
        *(pMemberType) = CMT_Method;
    }
    else
    {
        // We are dealing with a property.
        mdProperty tkProp;
        if (TypeFromToken(pProps->property) == mdtProperty)
            tkProp = pProps->property;
        else
            tkProp = rProps[pProps->property].property;

        // call the managed code to get the PropertyInfo
        MethodDescCallSite getPropertyInfo(METHOD__CLASS__GET_PROPERTY_INFO);
        ARG_SLOT args[] =
        {
            ObjToArgSlot(tInterface),
            tkProp
        };
        
        MemberInfoObj = getPropertyInfo.Call_RetOBJECTREF(args);

        *(pMemberType) = (pProps->semantic == msGetter) ? CMT_PropGet : CMT_PropSet;
    }

    refRetVal = MemberInfoObj;

    HELPER_METHOD_FRAME_END();
    return OBJECTREFToObject(refRetVal);
}
FCIMPLEND

//+----------------------------------------------------------------------------
//
//  Method:     MarshalNative::WrapIUnknownWithComObject
//  Synopsis:   unmarshal the buffer and return IUnknown
//

//
//+----------------------------------------------------------------------------
FCIMPL1(Object*, MarshalNative::WrapIUnknownWithComObject, IUnknown* pUnk)
{
    CONTRACTL
    {
        FCALL_CHECK;
        PRECONDITION(CheckPointer(pUnk, NULL_OK));
    }
    CONTRACTL_END;

    OBJECTREF cref = NULL;
    HELPER_METHOD_FRAME_BEGIN_RET_0();

    if(pUnk == NULL)
        COMPlusThrowArgumentNull(W(""punk""));
        
    EnsureComStarted();

    COMInterfaceMarshaler marshaler;
    marshaler.Init(pUnk, g_pBaseCOMObject, GET_THREAD());
    
    cref = marshaler.WrapWithComObject();
    
    if (cref == NULL)
        COMPlusThrowOM();
        
    HELPER_METHOD_FRAME_END();
    return OBJECTREFToObject(cref);
}
FCIMPLEND

FCIMPL2(void, MarshalNative::ChangeWrapperHandleStrength, Object* orefUNSAFE, CLR_BOOL fIsWeak)
{
    FCALL_CONTRACT;

    OBJECTREF oref = (OBJECTREF) orefUNSAFE;
    HELPER_METHOD_FRAME_BEGIN_1(oref);

    if(oref == NULL)
        COMPlusThrowArgumentNull(W(""otp""));
    
    if (
        !oref->GetMethodTable()->IsComImport())
    {
        CCWHolder pWrap = ComCallWrapper::InlineGetWrapper(&oref);
        
        if (pWrap == NULL)
            COMPlusThrowOM();
        if (fIsWeak != 0)
            pWrap->MarkHandleWeak();
        else
            pWrap->ResetHandleStrength();
    }        

    HELPER_METHOD_FRAME_END();
}
FCIMPLEND

FCIMPL2(void, MarshalNative::InitializeWrapperForWinRT, Object *unsafe_pThis, IUnknown **ppUnk)
{
    FCALL_CONTRACT;

    OBJECTREF oref = ObjectToOBJECTREF(unsafe_pThis);
    HELPER_METHOD_FRAME_BEGIN_1(oref);

    _ASSERTE(ppUnk != NULL);
    if (*ppUnk == NULL)
    {
        // this should never happen but it's not nice to AV if the factory method is busted and returns NULL
        COMPlusThrow(kNullReferenceException);
    }

    // the object does not have the right RCW yet
    COMInterfaceMarshaler marshaler;
    marshaler.Init(*ppUnk, oref->GetMethodTable(), GET_THREAD(), RCW::CF_SupportsIInspectable | RCW::CF_QueryForIdentity);

    // the following will assign NULL to *ppUnk which signals to the caller that we successfully
    // initialized the RCW so (*ppUnk)->Release() should be suppressed
    marshaler.InitializeExistingComObject(&oref, ppUnk);

    HELPER_METHOD_FRAME_END();
}
FCIMPLEND

FCIMPL2(void, MarshalNative::InitializeManagedWinRTFactoryObject, Object *unsafe_pThis, ReflectClassBaseObject *unsafe_pType)
{                                             
    FCALL_CONTRACT;

    OBJECTREF orefThis = ObjectToOBJECTREF(unsafe_pThis);
    REFLECTCLASSBASEREF orefType = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(unsafe_pType);
    HELPER_METHOD_FRAME_BEGIN_2(orefThis, orefType);

    MethodTable *pMT = orefType->GetType().GetMethodTable();

    // get the special ""factory"" template for the type
    _ASSERTE(pMT->IsExportedToWinRT());
    WinRTManagedClassFactory *pFactory = GetComClassFactory(pMT)->AsWinRTManagedClassFactory();

    ComCallWrapperTemplate *pTemplate = pFactory->GetOrCreateComCallWrapperTemplate(orefThis->GetMethodTable());

    // create a CCW for the factory object using the template
    CCWHolder pCCWHold = ComCallWrapper::InlineGetWrapper(&orefThis, pTemplate);

    HELPER_METHOD_FRAME_END();
}
FCIMPLEND

//
// Create activation factory and wraps it with a unique RCW
//
// This is necessary because WinRT factories are often implemented as a singleton, 
// and getting back a RCW for such WinRT factory would usually get back a RCW from 
// another apartment, even if the interface pointe returned from GetActivationFactory
// is a raw pointer. As a result, user would randomly get back RCWs for activation
// factories from other apartments and make transiton to those apartments and cause
// deadlocks and create objects in incorrect apartments
//
// The solution here is to always create a unique RCW
//
FCIMPL1(Object *, MarshalNative::GetNativeActivationFactory, ReflectClassBaseObject *unsafe_pType)
{                                             
    FCALL_CONTRACT;

    REFLECTCLASSBASEREF orefType = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(unsafe_pType);
    OBJECTREF orefFactory = NULL;
    HELPER_METHOD_FRAME_BEGIN_RET_2(orefFactory, orefType);

    MethodTable *pMT = orefType->GetType().GetMethodTable();

    // Must be a native WinRT type
    _ASSERTE(pMT->IsProjectedFromWinRT());

    //
    // Get the activation factory instance for this WinRT type and create a RCW for it
    //
    GetNativeWinRTFactoryObject(
        pMT,                
        GET_THREAD(),       
        NULL,               // No factory interface available at this point
        TRUE,               // Create unique RCW - See comments for this function for more details
        NULL,               // No callback necessary
        &orefFactory        // return value
        );

    HELPER_METHOD_FRAME_END();

    return OBJECTREFToObject(orefFactory);
}
FCIMPLEND

void QCALLTYPE MarshalNative::GetInspectableIIDs(
                        QCall::ObjectHandleOnStack hobj, 
                        QCall::ObjectHandleOnStack retArrayGuids)
{
    CONTRACTL
    {
        QCALL_CHECK;
        PRECONDITION(CheckPointer(*hobj.m_ppObject));
    }
    CONTRACTL_END;

    BEGIN_QCALL;

    SyncBlock * pSyncBlock = NULL;

    {
        GCX_COOP();

        // set return to failure value
        retArrayGuids.Set(NULL);

        OBJECTREF orComObject = NULL;
        GCPROTECT_BEGIN(orComObject);

        orComObject = ObjectToOBJECTREF(*hobj.m_ppObject);

        // Validation: hobj represents a non-NULL System.__ComObject instance
        if(orComObject == NULL)
            COMPlusThrowArgumentNull(W(""obj""));

        MethodTable* pMT = orComObject->GetMethodTable();
        PREFIX_ASSUME(pMT != NULL);
        if(!pMT->IsComObjectType())
            COMPlusThrow(kArgumentException, IDS_EE_SRC_OBJ_NOT_COMOBJECT);

        // while in cooperative mode, retrieve the object's sync block
        pSyncBlock = orComObject->PassiveGetSyncBlock();

        GCPROTECT_END();
    } // close the GCX_COOP scope


    InteropSyncBlockInfo * pInteropInfo;
    RCW * pRCW;
    SafeComHolderPreemp<IInspectable> pInspectable;

    // Retrieve obj's IInspectable interface pointer
    if (pSyncBlock != NULL
        && (pInteropInfo = pSyncBlock->GetInteropInfoNoCreate()) != NULL
        && (pRCW = pInteropInfo->GetRawRCW()) != NULL
        && (pInspectable = pRCW->GetIInspectable()) != NULL)
    {
        // retrieve IIDs using IInspectable::GetIids()
        ULONG size = 0;
        CoTaskMemHolder<IID> rgIIDs(NULL);
        if (SUCCEEDED(pInspectable->GetIids(&size, &rgIIDs)))
        {
            retArrayGuids.SetGuidArray(rgIIDs, size);
        }
    }

    END_QCALL;
}

//====================================================================
// Helper function used in the COM slot to method info mapping.
//====================================================================  

int MarshalNative::GetComSlotInfo(MethodTable *pMT, MethodTable **ppDefItfMT)
{
    CONTRACTL
    {
        THROWS;
        GC_TRIGGERS;
        MODE_ANY;
        PRECONDITION(CheckPointer(pMT));
        PRECONDITION(CheckPointer(ppDefItfMT));
    }
    CONTRACTL_END;
    
    *ppDefItfMT = NULL;

    // If a class was passed in then retrieve the default interface.
    if (!pMT->IsInterface())
    {
        TypeHandle hndDefItfClass;
        DefaultInterfaceType DefItfType = GetDefaultInterfaceForClassWrapper(TypeHandle(pMT), &hndDefItfClass);
        
        if (DefItfType == DefaultInterfaceType_AutoDual || DefItfType == DefaultInterfaceType_Explicit)
        {
            pMT = hndDefItfClass.GetMethodTable();
            PREFIX_ASSUME(pMT != NULL);
        }
        else
        {
            // The default interface does not have any user defined methods.
            return -1;
        }
    }

    // Set the default interface class.
    *ppDefItfMT = pMT;

    if (pMT->IsInterface())
    {
        // Return the right number of slots depending on interface type.
        return ComMethodTable::GetNumExtraSlots(pMT->GetComInterfaceType());
    }
    else
    {
        // We are dealing with an IClassX which are always IDispatch based.
        return ComMethodTable::GetNumExtraSlots(ifDispatch);
    }
}

BOOL MarshalNative::IsObjectInContext(OBJECTREF *pObj)
{
    CONTRACTL
    {
        THROWS;
        GC_TRIGGERS;
        MODE_COOPERATIVE;
        PRECONDITION(pObj != NULL);
    }
    CONTRACTL_END;

    SyncBlock* pBlock = (*pObj)->GetSyncBlock();

    InteropSyncBlockInfo* pInteropInfo = pBlock->GetInteropInfo();

    ComCallWrapper* pCCW = pInteropInfo->GetCCW();
    
    if((pCCW) || (!pInteropInfo->RCWWasUsed()))
    {
        // We are dealing with a CCW. Since CCW's are agile, they are always in the 
        // correct context.
        return TRUE;
    }
    else
    {
        RCWHolder pRCW(GetThread());
        pRCW.Init(pBlock);
        
        // We are dealing with an RCW, we need to check to see if the current 
        // context is the one it was first seen in.
        LPVOID pCtxCookie = GetCurrentCtxCookie();
        _ASSERTE(pCtxCookie != NULL);

        return pCtxCookie == pRCW->GetWrapperCtxCookie();
    }
}

#endif // FEATURE_COMINTEROP
",16229,True,3736.5305945898244,median
"
[[springSpringBoot]]


=== Spring Boot

Spring Boot is an application framework which, according to link:$$http://projects.spring.io/spring-boot/$$[its website], _makes it easy to create stand-alone, production-grade Spring based Applications that you can ""just run"". It takes an opinionated view of the Spring platform and third-party libraries so you can get started with minimum fuss. Most Spring Boot applications need very little Spring configuration_.

For more information on Spring Boot, see link:$$http://projects.spring.io/spring-boot/$$[http://projects.spring.io/spring-boot/]

The Spring Boot - Flowable integration has been developed together with Spring committers. 

==== Compatibility

Flowable supports both Spring Boot 2.0 and 1.5 with the same starters. The base support is for Spring Boot 2.0, which means that the actuator endpoints are only supported on 2.0.
The Flowable starters are also puling spring boot starter transitively, which means that users will have to define the 1.5 version of the spring boot starters in their own build files.

[[springSpringBootGettingStarted]]
==== Getting started

Spring Boot is all about convention over configuration.
To get started, you would need to create a Spring Boot project.
The easiest way to do this would be to create a project via link:$$https://start.spring.io/$$[start.spring.io].
For example create a project with web and h2 dependencies.
Then in the created project simply add the _flowable-spring-boot-starter_ or _flowable-spring-boot-starter-rest_ dependency.
In case you don't need all the engines see the other <<springBootFlowableStarter, Flowable starters>>.
For example for Maven:


[source,xml,linenums]
----
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-spring-boot-starter</artifactId>
    <version>${flowable.version}</version>
</dependency>
----

That's all that's needed. This dependency will transitively add the correct Flowable dependencies to the classpath.
You can now run your Spring Boot application:

[source,java,,linenums]
----
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication(proxyBeanMethods = false)
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }

}
----


You will see an output like this:

----
  .   ____          _            __ _ _
 /\\\\ / ___'_ __ _ _(_)_ __  __ _ \\ \\ \\ \\
( ( )\\___ | '_ | '_| | '_ \\/ _` | \\ \\ \\ \\
 \\\\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.0.0.RELEASE)

MyApplication                            : Starting MyApplication on ...
MyApplication                            : No active profile set, falling back to default profiles: default
ConfigServletWebServerApplicationContext : Refreshing org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@4fdfa676: startup date [Wed Mar 28 12:04:00 CEST 2018]; root of context hierarchy
o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
o.apache.catalina.core.StandardService   : Starting service [Tomcat]
org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/8.5.28
o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 3085 ms
o.s.b.w.servlet.ServletRegistrationBean  : Servlet dispatcherServlet mapped to [/]
o.s.b.w.servlet.ServletRegistrationBean  : Servlet Flowable IDM Rest API mapped to [/idm-api/*]
o.s.b.w.servlet.ServletRegistrationBean  : Servlet Flowable Form Rest API mapped to [/form-api/*]
o.s.b.w.servlet.ServletRegistrationBean  : Servlet Flowable DMN Rest API mapped to [/dmn-api/*]
o.s.b.w.servlet.ServletRegistrationBean  : Servlet Flowable Content Rest API mapped to [/content-api/*]
o.s.b.w.servlet.ServletRegistrationBean  : Servlet Flowable CMMN Rest API mapped to [/cmmn-api/*]
o.s.b.w.servlet.ServletRegistrationBean  : Servlet Flowable BPMN Rest API mapped to [/process-api/*]
o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'characterEncodingFilter' to: [/*]
o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'httpPutFormContentFilter' to: [/*]
o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'requestContextFilter' to: [/*]
uration$$EnhancerBySpringCGLIB$$3d0c70ac : No deployment resources were found for autodeployment
uration$$EnhancerBySpringCGLIB$$8131eb1a : No deployment resources were found for autodeployment
o.f.e.i.c.ProcessEngineConfigurationImpl : Found 5 Engine Configurators in total:
o.f.e.i.c.ProcessEngineConfigurationImpl : class org.flowable.idm.spring.configurator.SpringIdmEngineConfigurator (priority:100000)
o.f.e.i.c.ProcessEngineConfigurationImpl : class org.flowable.dmn.spring.configurator.SpringDmnEngineConfigurator (priority:200000)
o.f.e.i.c.ProcessEngineConfigurationImpl : class org.flowable.form.spring.configurator.SpringFormEngineConfigurator (priority:300000)
o.f.e.i.c.ProcessEngineConfigurationImpl : class org.flowable.content.spring.configurator.SpringContentEngineConfigurator (priority:400000)
o.f.e.i.c.ProcessEngineConfigurationImpl : class org.flowable.cmmn.spring.configurator.SpringCmmnEngineConfigurator (priority:500000)
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing beforeInit() of class org.flowable.idm.spring.configurator.SpringIdmEngineConfigurator (priority:100000)
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing beforeInit() of class org.flowable.dmn.spring.configurator.SpringDmnEngineConfigurator (priority:200000)
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing beforeInit() of class org.flowable.form.spring.configurator.SpringFormEngineConfigurator (priority:300000)
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing beforeInit() of class org.flowable.content.spring.configurator.SpringContentEngineConfigurator (priority:400000)
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing beforeInit() of class org.flowable.cmmn.spring.configurator.SpringCmmnEngineConfigurator (priority:500000)
com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing configure() of class org.flowable.idm.spring.configurator.SpringIdmEngineConfigurator (priority:100000)
.d.AbstractSqlScriptBasedDbSchemaManager : performing create on identity with resource org/flowable/idm/db/create/flowable.h2.create.identity.sql
o.f.idm.engine.impl.IdmEngineImpl        : IdmEngine default created
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing configure() of class org.flowable.dmn.spring.configurator.SpringDmnEngineConfigurator (priority:200000)
o.f.dmn.engine.impl.DmnEngineImpl        : DmnEngine default created
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing configure() of class org.flowable.form.spring.configurator.SpringFormEngineConfigurator (priority:300000)
o.f.form.engine.impl.FormEngineImpl      : FormEngine default created
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing configure() of class org.flowable.content.spring.configurator.SpringContentEngineConfigurator (priority:400000)
o.f.c.engine.ContentEngineConfiguration  : Content file system root : ...
o.f.c.engine.impl.ContentEngineImpl      : ContentEngine default created
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing configure() of class org.flowable.cmmn.spring.configurator.SpringCmmnEngineConfigurator (priority:500000)
o.f.cmmn.engine.CmmnEngineConfiguration  : Found 1 Engine Configurators in total:
o.f.cmmn.engine.CmmnEngineConfiguration  : class org.flowable.idm.engine.configurator.IdmEngineConfigurator (priority:100000)
o.f.cmmn.engine.CmmnEngineConfiguration  : Executing beforeInit() of class org.flowable.idm.engine.configurator.IdmEngineConfigurator (priority:100000)
o.f.cmmn.engine.CmmnEngineConfiguration  : Executing configure() of class org.flowable.idm.engine.configurator.IdmEngineConfigurator (priority:100000)
o.f.idm.engine.impl.IdmEngineImpl        : IdmEngine default created
o.f.cmmn.engine.impl.CmmnEngineImpl      : CmmnEngine default created
o.f.engine.impl.ProcessEngineImpl        : ProcessEngine default created
o.f.j.s.i.a.AbstractAsyncExecutor        : Starting up the async job executor [org.flowable.spring.job.service.SpringAsyncExecutor].
o.f.j.s.i.a.AcquireAsyncJobsDueRunnable  : starting to acquire async jobs due
o.f.j.s.i.a.AcquireTimerJobsRunnable     : starting to acquire async jobs due
o.f.j.s.i.a.ResetExpiredJobsRunnable     : starting to reset expired jobs
o.f.e.impl.cmd.ValidateV5EntitiesCmd     : Total of v5 deployments found: 0
s.w.s.m.m.a.RequestMappingHandlerAdapter : Looking for @ControllerAdvice: org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@4fdfa676: startup date [Wed Mar 28 12:04:00 CEST 2018]; root of context hierarchy
s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped ""{[/error]}"" onto public org.springframework.http.ResponseEntity<java.util.Map<java.lang.String, java.lang.Object>> org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.error(javax.servlet.http.HttpServletRequest)
s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped ""{[/error],produces=[text/html]}"" onto public org.springframework.web.servlet.ModelAndView org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.errorHtml(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)
o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/webjars/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/**/favicon.ico] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
o.s.j.e.a.AnnotationMBeanExporter        : Bean with name 'dataSource' has been autodetected for JMX exposure
o.s.j.e.a.AnnotationMBeanExporter        : Located MBean 'dataSource': registering with JMX server as MBean [com.zaxxer.hikari:name=dataSource,type=HikariDataSource]
o.s.c.support.DefaultLifecycleProcessor  : Starting beans in phase -20
o.s.c.support.DefaultLifecycleProcessor  : Starting beans in phase 0
o.s.c.support.DefaultLifecycleProcessor  : Starting beans in phase 20
o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
flowable.Application                     : Started Application in 18.235 seconds (JVM running for 19.661)
----

So, by just adding the dependency to the classpath and using the _@SpringBootAplication_ annotation a lot has happened behind the scenes:

* An in-memory datasource is created automatically (because the H2 driver is on the classpath) and passed to the Flowable process engine configuration
* A Flowable ProcessEngine, CmmnEngine, DmnEngine, FormEngine, ContentEngine and IdmEngine beans have been created and exposed
* All the Flowable services are exposed as Spring beans
* The Spring Job Executor is created

Also:

* Any BPMN 2.0 process definitions in the _processes_ folder will be automatically deployed. Create a folder _processes_ and add a dummy process definition (named _one-task-process.bpmn20.xml_) to this folder. The content of this file is shown below.
* Any CMMN 1.1 case definitions in the _cases_ folder will be automatically deployed.
* Any DMN 1.1 dmn definitions in the _dmn_ folder will be automatically deployed.
* Any Form definitions in the _forms_ folder will be automatically deployed.

The XML content of the process definition is shown below. Notice that, for the moment, we are hard-coding an assignee called ""kermit"" to the user task. We'll come back to this later.

[source,xml,linenums]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<definitions
        xmlns=""http://www.omg.org/spec/BPMN/20100524/MODEL""
        xmlns:flowable=""http://flowable.org/bpmn""
        targetNamespace=""Examples"">

    <process id=""oneTaskProcess"" name=""The One Task Process"">
        <startEvent id=""theStart"" />
        <sequenceFlow id=""flow1"" sourceRef=""theStart"" targetRef=""theTask"" />
        <userTask id=""theTask"" name=""my task"" flowable:assignee=""kermit"" />
        <sequenceFlow id=""flow2"" sourceRef=""theTask"" targetRef=""theEnd"" />
        <endEvent id=""theEnd"" />
    </process>

</definitions>
----

Also, add following code lines to test if the deployment actually worked. The _CommandLineRunner_ is a special kind of Spring bean that is executed when the application boots:

[source,java,linenums]
----
@SpringBootApplication(proxyBeanMethods = false)
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }

    @Bean
    public CommandLineRunner init(final RepositoryService repositoryService,
                                  final RuntimeService runtimeService,
                                  final TaskService taskService) {

        return new CommandLineRunner() {
            @Override
            public void run(String... strings) throws Exception {
                System.out.println(""Number of process definitions : "" 
                	+ repositoryService.createProcessDefinitionQuery().count());
                System.out.println(""Number of tasks : "" + taskService.createTaskQuery().count());
                runtimeService.startProcessInstanceByKey(""oneTaskProcess"");
                System.out.println(""Number of tasks after process start: "" 
                    + taskService.createTaskQuery().count());
            }
        };
    }
}
----

The output expected will be:

----
Number of process definitions : 1
Number of tasks : 0
Number of tasks after process start : 1
----


==== Changing the database and connection pool

As stated above, Spring Boot is about convention over configuration. By default, by having only H2 on the classpath, it created an in-memory datasource and passed that to the Flowable process engine configuration.

To change the datasource, simply add the database driver dependencies and provide the URL to the database.
For example, to switch to a MySQL database:

[source,linenums]
----
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/flowable-spring-boot?characterEncoding=UTF-8
spring.datasource.username=flowable
spring.datasource.password=flowable
----

Remove H2 from the Maven dependencies and add the MySQL driver to the classpath:

[source,xml,linenums]
----
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.45</version>
</dependency>
----

When the app is now booted up, you'll see it uses MySQL as database (and the HikariCP connection pooling framework):

----
org.flowable.engine.impl.db.DbSqlSession   : performing create on engine with resource org/flowable/db/create/flowable.mysql.create.engine.sql
org.flowable.engine.impl.db.DbSqlSession   : performing create on history with resource org/flowable/db/create/flowable.mysql.create.history.sql
org.flowable.engine.impl.db.DbSqlSession   : performing create on identity with resource org/flowable/db/create/flowable.mysql.create.identity.sql
----

When you reboot the application multiple times, you'll see the number of tasks go up (the H2 in-memory database does not survive a shutdown, MySQL does).

For more information about how to configure the datasource have a look in link:$$https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-sql.html#boot-features-configure-datasource$$[Configure a DataSource] in the Spring Boot reference guide.

==== REST support

Often, a REST API is used on top of the embedded Flowable engine (interacting with the different services in a company). Spring Boot makes this really easy. Add following dependency to the classpath:

[source,xml,linenums]
----
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>${spring.boot.version}</version>
</dependency>
----

Create a new class, a Spring service and create two methods: one to start our process and one to get a task list for a given assignee. We simply wrap Flowable calls here, but in real-life scenarios this will be more complex.

[source,java,linenums]
----
@Service
public class MyService {

    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private TaskService taskService;

    @Transactional
    public void startProcess() {
        runtimeService.startProcessInstanceByKey(""oneTaskProcess"");
    }

    @Transactional
    public List<Task> getTasks(String assignee) {
        return taskService.createTaskQuery().taskAssignee(assignee).list();
    }

}
----

We can now create a REST endpoint by annotating a class with _@RestController_. Here, we simply delegate to the service defined above.

[source,java,linenums]
----
@RestController
public class MyRestController {

    @Autowired
    private MyService myService;

    @PostMapping(value=""/process"")
    public void startProcessInstance() {
        myService.startProcess();
    }

    @RequestMapping(value=""/tasks"", method= RequestMethod.GET, produces=MediaType.APPLICATION_JSON_VALUE)
    public List<TaskRepresentation> getTasks(@RequestParam String assignee) {
        List<Task> tasks = myService.getTasks(assignee);
        List<TaskRepresentation> dtos = new ArrayList<TaskRepresentation>();
        for (Task task : tasks) {
            dtos.add(new TaskRepresentation(task.getId(), task.getName()));
        }
        return dtos;
    }

    static class TaskRepresentation {

        private String id;
        private String name;

        public TaskRepresentation(String id, String name) {
            this.id = id;
            this.name = name;
        }
        
        public String getId() {
            return id;
        }
        public void setId(String id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }

    }

}
----

Both the _@Service_ and the _@RestController_ will be found by the automatic component scan for a Spring Boot application.
Run the application class again. We can now interact with the REST API, for example, by using cURL:

----
curl http://localhost:8080/tasks?assignee=kermit
[]

curl -X POST  http://localhost:8080/process
curl http://localhost:8080/tasks?assignee=kermit
[{""id"":""10004"",""name"":""my task""}]
----

As can be seen, we are referring to the assignee, ""kermit"", which was hard-coded into the process definition XML earlier. We'll change this later on to allow the assignee to be set when the workflow instance is started.

==== JPA support

To add JPA support for Flowable in Spring Boot, add following dependency:

[source,xml,linenums]
----
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-spring-boot-starter</artifactId>
    <version>${flowable.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    <version>${spring-boot.version}</version>
</dependency>
----

This will add in the Spring configuration and beans for using JPA. By default, the JPA provider will be Hibernate.

Let's create a simple Entity class:

[source,java,linenums]
----
@Entity
class Person {

    @Id
    @GeneratedValue
    private Long id;

    private String username;

    private String firstName;

    private String lastName;

    private Date birthDate;

    public Person() {
    }

    public Person(String username, String firstName, String lastName, Date birthDate) {
        this.username = username;
        this.firstName = firstName;
        this.lastName = lastName;
        this.birthDate = birthDate;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Date getBirthDate() {
        return birthDate;
    }

    public void setBirthDate(Date birthDate) {
        this.birthDate = birthDate;
    }
}
----

By default, when not using an in-memory database, the tables won't be created automatically. Create a file _application.properties_ on the classpath and add following property:

----
spring.jpa.hibernate.ddl-auto=update
----

Add following class:

[source,java,linenums]
----
@Repository
public interface PersonRepository extends JpaRepository<Person, Long> {

    Person findByUsername(String username);
}
----

This is a Spring repository, which offers CRUD out of the box. We add the method to find a Person by username. Spring will automatically implement this based on conventions (typically, the property names used).

We now enhance our service further:

* by adding _@Transactional_ to the class. Note that by adding the JPA dependency above, the DataSourceTransactionManager which we were using before is now automatically swapped out by a JpaTransactionManager. 
* The _startProcess_ now gets an assignee username passed in, which is used to look up the Person, and put the Person JPA object as a process variable in the process instance.
* A method to create Dummy users is added. This is used in the CommandLineRunner to populate the database.

[source,java,linenums]
----
@Service
@Transactional
public class MyService {

    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private TaskService taskService;

    @Autowired
    private PersonRepository personRepository;

    public void startProcess(String assignee) {

        Person person = personRepository.findByUsername(assignee);

        Map<String, Object> variables = new HashMap<String, Object>();
        variables.put(""person"", person);
        runtimeService.startProcessInstanceByKey(""oneTaskProcess"", variables);
    }

    public List<Task> getTasks(String assignee) {
        return taskService.createTaskQuery().taskAssignee(assignee).list();
    }

    public void createDemoUsers() {
        if (personRepository.findAll().size() == 0) {
            personRepository.save(new Person(""jbarrez"", ""Joram"", ""Barrez"", new Date()));
            personRepository.save(new Person(""trademakers"", ""Tijs"", ""Rademakers"", new Date()));
        }
    }

}
----

The CommandLineRunner now looks like:

[source,java,linenums]
----
@Bean
public CommandLineRunner init(final MyService myService) {

    return new CommandLineRunner() {
    	public void run(String... strings) throws Exception {
        	myService.createDemoUsers();
        }
    };
}
----

The RestController is also modified slightly to incorporate the changes above (only showing new methods) and the HTTP POST now has a body that contains the assignee username:

----
@RestController
public class MyRestController {

    @Autowired
    private MyService myService;

    @PostMapping(value=""/process"")
    public void startProcessInstance(@RequestBody StartProcessRepresentation startProcessRepresentation) {
        myService.startProcess(startProcessRepresentation.getAssignee());
    }

   ...

    static class StartProcessRepresentation {

        private String assignee;

        public String getAssignee() {
            return assignee;
        }

        public void setAssignee(String assignee) {
            this.assignee = assignee;
        }
    }
----

And finally, to try out the Spring-JPA-Flowable integration, we assign the task using the ID of the Person JPA object in the process definition:

[source,xml,linenums]
----
<userTask id=""theTask"" name=""my task"" flowable:assignee=""${person.id}""/>
----

This replaces the hard-coded recipient, ""kermit"", which we had initially set.

We can now start a new process instance, providing the user name in the POST body:

----
curl -H ""Content-Type: application/json"" -d '{""assignee"" : ""jbarrez""}' http://localhost:8080/process
----

And the task list is now fetched using the person ID:

----
curl http://localhost:8080/tasks?assignee=1

[{""id"":""12505"",""name"":""my task""}]
----

[[springBootActuatorEndpoint]]
==== Flowable Actuator Endpoints

Flowable provides a Spring Boot Actuator Endpoint that exposes information for the Processes that are running.
By default, the `flowable` endpoint is mapped to `/actuator/flowable`.
Spring Boot by default only exposes a few endpoints to the web (e.g.: In `spring-boot-starter-actuator:2.5.4` , Spring Boot by default only exposes the `health` endpoint to the web. For more information about the endpoints exposed to the web by default, see link:$$https://docs.spring.io/spring-boot/docs/current/reference/html/actuator.html#actuator.endpoints.exposing$$[https://docs.spring.io/spring-boot/docs/current/reference/html/actuator.html#actuator.endpoints.exposing]). In order to use the `flowable` endpoint through the web, you need to add `management.endpoints.web.exposure.include=flowable` to your `application.properties` (Note: The `org.flowable.spring.boot.EndpointAutoConfiguration` class does not use the `@ConditionalOnAvailableEndpoint` annotation to check whether the `flowable` endpoint is both enabled and exposed like the `HealthEndpointAutoConfiguration` class. So the only thing you need to do to use the `flowable` endpoint through the web is to add `management.endpoints.web.exposure.include=flowable` or `management.endpoints.web.exposure.include=*` to your configuration file. ).

In order to make enable Actuator endpoints you need to add a dependency on Actuator, e.g. by using {sc-flowable-starter}/flowable-spring-boot-starter-actuator/pom.xml[flowable-spring-boot-starter-actuator].

`curl http://localhost:8080/actuator/flowable`

[source,json]
----

{
  ""completedTaskCountToday"": 0,
  ""deployedProcessDefinitions"": [
    ""oneTaskProcess (v1)""
  ],
  ""processDefinitionCount"": 1,
  ""cachedProcessDefinitionCount"": 0,
  ""runningProcessInstanceCount"": {
    ""oneTaskProcess (v1)"": 0
  },
  ""completedTaskCount"": 2,
  ""completedActivities"": 3,
  ""completedProcessInstanceCount"": {
    ""oneTaskProcess (v1)"": 0
  },
  ""openTaskCount"": 0
}
----

For more information about Spring Boot Actuator see link:$$https://docs.spring.io/spring-boot/docs/current/reference/html/production-ready-endpoints.html$$[Production Ready Endpoint] in the Spring Boot reference documentation.

[[springBootInfoContributor]]
==== Flowable Info Contributor

Flowable also provides a Spring Boot `InfoContributor` which looks like:

`curl http://localhost:8080/actuator/info`

[source,json]
----
{
  ""flowable"": {
    ""version"": ""6.5.0.event-SNAPSHOT""
  }
}
----

[[springBootFlowableProperties]]
==== Flowable Application Properties

The Flowable auto configuration is leveraging the Spring Boot properties and configuration mechanism.
See link:$$https://docs.spring.io/spring-boot/docs/current/reference/html/howto-properties-and-configuration.html$$[Properties and Configuration] in the Spring Boot reference guide.

Here is a list of configuration properties that the Flowable Spring Boot support consumes.

[source,properties,indent=0,subs=""verbatim,attributes,macros""]
----

# ===================================================================
# Common Flowable Spring Boot Properties
#
# This sample file is provided as a guideline. Do NOT copy it in its
# entirety to your own application.	           ^^^
# ===================================================================

# Core (Process) {sc-flowable-boot}/FlowableProperties.java[FlowableProperties]
flowable.check-process-definitions=true # Whether process definitions need to be auto deployed.
flowable.custom-mybatis-mappers= # The FQN of custom Mybatis mappers that need to be added to the engine.
flowable.custom-mybatis-x-m-l-mappers= # The location of the custom Mybatis XML Mappers that need to be added to the engine.
flowable.database-schema= # In some situations you want to set the schema to use for table checks / generation if the database metadata doesn't return that correctly.
flowable.database-schema-update=true # The strategy that should be used for the database schema.
flowable.db-history-used=true # Whether db history should be used.
flowable.deployment-name=SpringBootAutoDeployment # The name of the auto deployment.
flowable.history-level=audit # The history level that needs to be used.
flowable.process-definition-location-prefix=classpath*:/processes/ # The folder in which processes need to be searched for auto deployment.
flowable.process-definition-location-suffixes=**.bpmn20.xml,**.bpmn # The suffixes (extensions) of the files that needs to be deployed from the 'processDefinitionLocationPrefix' location.

# Process {sc-flowable-boot}/process/FlowableProcessProperties.java[FlowableProcessProperties]
flowable.process.definition-cache-limit=-1 # The maximum amount of process definitions available in the process definition cache. Per default it is -1 (all process definitions).
flowable.process.enable-safe-xml=true # Enables extra checks on the BPMN xml that is parsed. See https://www.flowable.org/docs/userguide/index.html#advanced.safe.bpmn.xml. Unfortunately, this feature is not available on some platforms (JDK 6, JBoss), hence you need to disable if your platform does not allow the use of StaxSource during XML parsing.
flowable.process.servlet.load-on-startup=-1 # Load on startup of the Process dispatcher servlet.
flowable.process.servlet.name=Flowable BPMN Rest API # The name of the Process servlet.
flowable.process.servlet.path=/process-api # The context path for the Process rest servlet.

# Process Async Executor
flowable.process.async-executor-activate=true # Whether the async executor should be activated.
flowable.process.async.executor.async-job-lock-time-in-millis=300000 # The amount of time (in milliseconds) an async job is locked when acquired by the async executor. During this period of time, no other async executor will try to acquire and lock this job.
flowable.process.async.executor.default-async-job-acquire-wait-time-in-millis=10000 # The time (in milliseconds) the async job acquisition thread will wait to execute the next acquirement query. This happens when no new async jobs were found or when less async jobs have been fetched. Default value = 10 seconds.
flowable.process.async.executor.default-queue-size-full-wait-time-in-millis=0 # The time (in milliseconds) the async job (both timer and async continuations) acquisition thread will wait when the queue is full to execute the next query. By default set to 0 (for backwards compatibility)
flowable.process.async.executor.default-timer-job-acquire-wait-time-in-millis=10000 # The time (in milliseconds) the timer job acquisition thread will wait to execute the next acquirement query. This happens when no new timer jobs were found or when less async jobs have been fetched. Default value = 10 seconds.
flowable.process.async.executor.max-async-jobs-due-per-acquisition=1 # ???
flowable.process.async.executor.retry-wait-time-in-millis=500 # ???
flowable.process.async.executor.timer-lock-time-in-millis=300000 # The amount of time (in milliseconds) a timer job is locked when acquired by the async executor. During this period of time, no other async executor will try to acquire and lock this job.


# CMMN {sc-flowable-boot}/cmmn/FlowableCmmnProperties.java[FlowableCmmnProperties]
flowable.cmmn.deploy-resources=true # Whether to perform deployment of resources, default is 'true'.
flowable.cmmn.deployment-name=SpringBootAutoDeployment # The name of the deployment for the CMMN resources.
flowable.cmmn.enable-safe-xml=true # Enables extra checks on the DMN xml that is parsed. See https://www.flowable.org/docs/userguide/index.html#advanced.safe.bpmn.xml. Unfortunately, this feature is not available on some platforms (JDK 6, JBoss), hence you need to disable if your platform does not allow the use of StaxSource during XML parsing.
flowable.cmmn.enabled=true # Whether the CMMN engine needs to be started.
flowable.cmmn.resource-location=classpath*:/cases/ # The location where the CMMN resources are located.
flowable.cmmn.resource-suffixes=**.cmmn,**.cmmn11,**.cmmn.xml,**.cmmn11.xml # The suffixes for the resources that need to be scanned.
flowable.cmmn.servlet.load-on-startup=-1 # Load on startup of the CMMN dispatcher servlet.
flowable.cmmn.servlet.name=Flowable CMMN Rest API # The name of the CMMN servlet.
flowable.cmmn.servlet.path=/cmmn-api # The context path for the CMMN rest servlet.

# CMMN Async Executor
flowable.cmmn.async-executor-activate=true # Whether the async executor should be activated.
flowable.cmmn.async.executor.async-job-lock-time-in-millis=300000 # The amount of time (in milliseconds) an async job is locked when acquired by the async executor. During this period of time, no other async executor will try to acquire and lock this job.
flowable.cmmn.async.executor.default-async-job-acquire-wait-time-in-millis=10000 # The time (in milliseconds) the async job acquisition thread will wait to execute the next acquirement query. This happens when no new async jobs were found or when less async jobs have been fetched. Default value = 10 seconds.
flowable.cmmn.async.executor.default-queue-size-full-wait-time-in-millis=0 # The time (in milliseconds) the async job (both timer and async continuations) acquisition thread will wait when the queue is full to execute the next query. By default set to 0 (for backwards compatibility)
flowable.cmmn.async.executor.default-timer-job-acquire-wait-time-in-millis=10000 # The time (in milliseconds) the timer job acquisition thread will wait to execute the next acquirement query. This happens when no new timer jobs were found or when less async jobs have been fetched. Default value = 10 seconds.
flowable.cmmn.async.executor.max-async-jobs-due-per-acquisition=1 # ???
flowable.cmmn.async.executor.retry-wait-time-in-millis=500 # ???
flowable.cmmn.async.executor.timer-lock-time-in-millis=300000 # The amount of time (in milliseconds) a timer job is locked when acquired by the async executor. During this period of time, no other async executor will try to acquire and lock this job.

# Content {sc-flowable-boot}/content/FlowableContentProperties.java[FlowableContentProperties]
flowable.content.enabled=true # Whether the content engine needs to be started.
flowable.content.servlet.load-on-startup=-1 # Load on startup of the Content dispatcher servlet.
flowable.content.servlet.name=Flowable Content Rest API # The name of the Content servlet.
flowable.content.servlet.path=/content-api # The context path for the Content rest servlet.
flowable.content.storage.create-root=true # If the root folder doesn't exist, should it be created?
flowable.content.storage.root-folder= # Root folder location where content files will be stored, for example, task attachments or form file uploads.

# DMN {sc-flowable-boot}/dmn/FlowableDmnProperties.java[FlowableDmnProperties]
flowable.dmn.deploy-resources=true # Whether to perform deployment of resources, default is 'true'.
flowable.dmn.deployment-name=SpringBootAutoDeployment # The name of the deployment for the dmn resources.
flowable.dmn.enable-safe-xml=true # Enables extra checks on the DMN xml that is parsed. See https://www.flowable.org/docs/userguide/index.html#advanced.safe.bpmn.xml. Unfortunately, this feature is not available on some platforms (JDK 6, JBoss), hence you need to disable if your platform does not allow the use of StaxSource during XML parsing.
flowable.dmn.enabled=true # Whether the dmn engine needs to be started.
flowable.dmn.history-enabled=true # Whether the history for the DMN engine should be enabled.
flowable.dmn.resource-location=classpath*:/dmn/ # The location where the dmn resources are located.
flowable.dmn.resource-suffixes=**.dmn,**.dmn.xml,**.dmn11,**.dmn11.xml # The suffixes for the resources that need to be scanned.
flowable.dmn.servlet.load-on-startup=-1 # Load on startup of the DMN dispatcher servlet.
flowable.dmn.servlet.name=Flowable DMN Rest API # The name of the DMN servlet.
flowable.dmn.servlet.path=/dmn-api # The context path for the DMN rest servlet.
flowable.dmn.strict-mode=true # Set this to false if you want to ignore the decision table hit policy validity checks to result in an failed decision table state. A result is that intermediate results created up to the point the validation error occurs are returned.

# Form {sc-flowable-boot}/form/FlowableFormProperties.java[FlowableFormProperties]
flowable.form.deploy-resources=true # Whether to perform deployment of resources, default is true.
flowable.form.deployment-name=SpringBootAutoDeployment # The name of the deployment for the form resources.
flowable.form.enabled=true # Whether the form engine needs to be started.
flowable.form.resource-location=classpath*:/forms/ # The location where the form resources are located.
flowable.form.resource-suffixes=**.form # The suffixes for the resources that need to be scanned.
flowable.form.servlet.load-on-startup=-1 # Load on startup of the Form dispatcher servlet.
flowable.form.servlet.name=Flowable Form Rest API # The name of the Form servlet.
flowable.form.servlet.path=/form-api # The context path for the Form rest servlet.

# IDM {sc-flowable-boot}/idm/FlowableIdmProperties.java[FlowableIdmProperties]
flowable.idm.enabled=true # Whether the idm engine needs to be started.
flowable.idm.password-encoder= # The type of the password encoder that needs to be used.
flowable.idm.servlet.load-on-startup=-1 # Load on startup of the IDM dispatcher servlet.
flowable.idm.servlet.name=Flowable IDM Rest API # The name of the IDM servlet.
flowable.idm.servlet.path=/idm-api # The context path for the IDM rest servlet.

# IDM Ldap {sc-flowable-boot}/ldap/FlowableLdapProperties.java[FlowableLdapProperties]
flowable.idm.ldap.attribute.email= # Name of the attribute that matches the user email.
flowable.idm.ldap.attribute.first-name= # Name of the attribute that matches the user first name.
flowable.idm.ldap.attribute.group-id= # Name of the attribute that matches the group id.
flowable.idm.ldap.attribute.group-name= # Name of the attribute that matches the group name.
flowable.idm.ldap.attribute.group-type= # Name of the attribute that matches the group type.
flowable.idm.ldap.attribute.last-name= # Name of the attribute that matches the user last name.
flowable.idm.ldap.attribute.user-id= # Name of the attribute that matches the user id.
flowable.idm.ldap.base-dn= # The base 'distinguished name' (DN) from which the searches for users and groups are started.
flowable.idm.ldap.cache.group-size=-1 # Allows to set the size of the {@link org.flowable.ldap.LDAPGroupCache}. This is an LRU cache that caches groups for users and thus avoids hitting the LDAP system each time the groups of a user needs to be known.
flowable.idm.ldap.custom-connection-parameters= # Allows to set all LDAP connection parameters which do not have a dedicated setter. See for example http://docs.oracle.com/javase/tutorial/jndi/ldap/jndi.html for custom properties. Such properties are for example to configure connection pooling, specific security settings, etc.
flowable.idm.ldap.enabled=false # Whether to enable LDAP IDM Service.
flowable.idm.ldap.group-base-dn= # The base 'distinguished name' (DN) from which the searches for groups are started.
flowable.idm.ldap.initial-context-factory=com.sun.jndi.ldap.LdapCtxFactory # The class name for the initial context factory.
flowable.idm.ldap.password= # The password that is used to connect to the LDAP system.
flowable.idm.ldap.port=-1 # The port on which the LDAP system is running.
flowable.idm.ldap.query.all-groups= # The query that is executed when searching for all groups.
flowable.idm.ldap.query.all-users= # The query that is executed when searching for all users.
flowable.idm.ldap.query.groups-for-user= # The query that is executed when searching for the groups of a specific user.
flowable.idm.ldap.query.user-by-full-name-like= # The query that is executed when searching for a user by full name.
flowable.idm.ldap.query.user-by-id= # The query that is executed when searching for a user by userId.
flowable.idm.ldap.query.group-by-id= # The query that is executed when searching for a specific group by groupId.
flowable.idm.ldap.search-time-limit=0 # The timeout (in milliseconds) that is used when doing a search in LDAP. By default set to '0', which means 'wait forever'.
flowable.idm.ldap.security-authentication=simple # The value that is used for the 'java.naming.security.authentication' property used to connect to the LDAP system.
flowable.idm.ldap.server= # The server host on which the LDAP system can be reached. For example 'ldap://localhost'.
flowable.idm.ldap.user= # The user id that is used to connect to the LDAP system.
flowable.idm.ldap.user-base-dn= # The base 'distinguished name' (DN) from which the searches for users are started.

# Flowable Mail {sc-flowable-boot}/FlowableMailProperties.java[FlowableMailProperties]
flowable.mail.server.default-from=flowable@localhost # The default from address that needs to be used when sending emails.
flowable.mail.server.force-to= # The force to address(es) that would be used when sending out emails. IMPORTANT: If this is set then all emails will be send to defined address(es) instead of the address configured in the MailActivity.
flowable.mail.server.host=localhost # The host of the mail server.
flowable.mail.server.password= # The password for the mail server authentication.
flowable.mail.server.port=1025 # The port of the mail server.
flowable.mail.server.ssl-port=1465 # The SSL port of the mail server.
flowable.mail.server.use-ssl=false # Sets whether SSL/TLS encryption should be enabled for the SMTP transport upon connection (SMTPS/POPS).
flowable.mail.server.use-tls=false # Set or disable the STARTTLS encryption.
flowable.mail.server.username= # The username that needs to be used for the mail server authentication. If empty no authentication would be used.

# Flowable Http {sc-flowable-boot}/FlowableHttpProperties.java[FlowableHttpProperties]
flowable.http.user-system-properties=false # Whether to use system properties (e.g. http.proxyPort).
flowable.http.connect-timeout=5s # Connect timeout for the http client
flowable.http.socket-timeout=5s # Socket timeout for the http client
flowable.http.connection-request-timeout=5s # Connection Request Timeout for the http client
flowable.http.request-retry-limit=3 # Request retry limit for the http client
flowable.http.disable-cert-verify=false # Whether to disable certificate validation for the http client

# Flowable REST
flowable.rest.app.cors.enabled=true # Whether to enable CORS requests at all. If false, the other properties have no effect
flowable.rest.app.cors.allow-credentials=true # Whether to include credentials in a CORS request
flowable.rest.app.cors.allowed-origins=* # Comma-separated URLs to accept CORS requests from
flowable.rest.app.cors.allowed-headers=* # Comma-separated HTTP headers to allow in a CORS request
flowable.rest.app.cors.allowed-methods=DELETE,GET,PATCH,POST,PUT # Comma-separated HTTP verbs to allow in a CORS request
flowable.rest.app.cors.exposed-headers=* # Comma-separated list of headers to expose in CORS response

# Actuator
management.endpoint.flowable.cache.time-to-live=0ms # Maximum time that a response can be cached.
management.endpoint.flowable.enabled=true # Whether to enable the flowable endpoint.

----

.Deprecated properties
[cols=""4*"",options=""header""]
|===============
|Property name
|Old Property
|Default value
|Description

|flowable.process.servlet.name
|flowable.rest-api-servlet-name
|Flowable BPMN Rest API
|The name of the Process servlet.

|flowable.process.servlet.path
|flowable.rest-api-mapping
|/process-api
|The context path for the Process rest servlet.

|flowable.mail.server.host
|flowable.mail-server-host
|localhost
|The host of the mail server.

|flowable.mail.server.password
|flowable.mail-server-password
|-
|The password for the mail server authentication.

|flowable.mail.server.port
|flowable.mail-server-port
|1025
|The port of the mail server.

|flowable.mail.server.ssl-port
|flowable.mail-server-ssl-port
|1465
|The SSL port of the mail server.

|flowable.mail.server.use-ssl
|flowable.mail-server-use-ssl
|false
|Sets whether SSL/TLS encryption should be enabled for the SMTP transport upon connection (SMTPS/POPS).

|flowable.mail.server.use-tls
|flowable.mail-server-use-tls
|false
|Set or disable the STARTTLS encryption.

|flowable.mail.server.username
|flowable.mail-server-user-name
|-
|The username that needs to be used for the mail server authentication.
If empty no authentication would be used.

|flowable.process.definition-cache-limit
|flowable.process-definitions.cache.max
|-1
|The maximum amount of process definitions available in the process definition cache.
 Per default it is -1 (all process definitions)
|===============

[[springBootFlowableAutoConfiguration]]
==== Flowable Auto-configuration classes

Here is a list of all auto-configuration classes provided by Flowable, with links to documentation and source code.
Remember to also look at the conditions report in your application for more details of which features are switched on.
(To do so, start the app with --debug or -Ddebug or, in an Actuator application, use the conditions endpoint).

[cols=*,options=""header""]
|===
|Configuration Class

|{sc-flowable-boot}/content/ContentEngineAutoConfiguration.java[ContentEngineAutoConfiguration]
|{sc-flowable-boot}/content/ContentEngineServicesAutoConfiguration.java[ContentEngineServicesAutoConfiguration]
|{sc-flowable-boot}/cmmn/CmmnEngineAutoConfiguration.java[CmmnEngineAutoConfiguration]
|{sc-flowable-boot}/cmmn/CmmnEngineServicesAutoConfiguration.java[CmmnEngineServicesAutoConfiguration]
|{sc-flowable-boot}/dmn/DmnEngineAutoConfiguration.java[DmnEngineAutoConfiguration]
|{sc-flowable-boot}/dmn/DmnEngineServicesAutoConfiguration.java[DmnEngineServicesAutoConfiguration]
|{sc-flowable-boot}/EndpointAutoConfiguration.java[EndpointAutoConfiguration]
|{sc-flowable-boot}/actuate/info/FlowableInfoAutoConfiguration.java[FlowableInfoAutoConfiguration]
|{sc-flowable-boot}/ldap/FlowableLdapAutoConfiguration.java[FlowableLdapAutoConfiguration]
|{sc-flowable-boot}/FlowableTransactionAutoConfiguration.java[FlowableTransactionAutoConfiguration]
|{sc-flowable-boot}/form/FormEngineAutoConfiguration.java[FormEngineAutoConfiguration]
|{sc-flowable-boot}/form/FormEngineServicesAutoConfiguration.java[FormEngineServicesAutoConfiguration]
|{sc-flowable-boot}/idm/IdmEngineAutoConfiguration.java[IdmEngineAutoConfiguration]
|{sc-flowable-boot}/idm/IdmEngineServicesAutoConfiguration.java[IdmEngineServicesAutoConfiguration]
|{sc-flowable-boot}/ProcessEngineAutoConfiguration.java[ProcessEngineAutoConfiguration]
|{sc-flowable-boot}/RestApiAutoConfiguration.java[RestApiAutoConfiguration]
|{sc-flowable-boot}/SecurityAutoConfiguration.java[SecurityAutoConfiguration]

|===

[[springBootFlowableStarter]]
==== Flowable Starters

Here is a list of the flowable spring boot starters.

[cols=2*,options=""header""]
|===
|Starter
|Description

|{sc-flowable-starter}/flowable-spring-boot-starter-cmmn/pom.xml[flowable-spring-boot-starter-cmmn]
|Contains the dependencies for booting the CMMN Engine in Standalone mode

|{sc-flowable-starter}/flowable-spring-boot-starter-cmmn-rest/pom.xml[flowable-spring-boot-starter-cmmn-rest]
|Contains the dependencies for booting the CMMN Engine in Standalone mode and starts its REST API

|{sc-flowable-starter}/flowable-spring-boot-starter-dmn/pom.xml[flowable-spring-boot-starter-dmn]
|Contains the dependencies for booting the DMN Engine in Standalone mode

|{sc-flowable-starter}/flowable-spring-boot-starter-dmn-rest/pom.xml[flowable-spring-boot-starter-dmn-rest]
|Contains the dependencies for booting the DMN Engine in Standalone mode and starts its REST API

|{sc-flowable-starter}/flowable-spring-boot-starter-process/pom.xml[flowable-spring-boot-starter-process]
|Contains the dependencies for booting the Process Engine in Standalone mode

|{sc-flowable-starter}/flowable-spring-boot-starter-process-rest/pom.xml[flowable-spring-boot-starter-process-rest]
|Contains the dependencies for booting the Process Engine in Standalone mode and starts its REST API

|{sc-flowable-starter}/flowable-spring-boot-starter/pom.xml[flowable-spring-boot-starter]
|Contains the dependencies for booting all Flowable Engines (Process, CMMN, DMN, Form, Content and IDM)

|{sc-flowable-starter}/flowable-spring-boot-starter-rest/pom.xml[flowable-spring-boot-starter-rest]
|Contains the dependencies for booting all Flowable Engines and their respective REST API

|{sc-flowable-starter}/flowable-spring-boot-starter-actuator/pom.xml[flowable-spring-boot-starter-actuator]
|Contains the required dependencies for Spring Boot

|===

==== Using Liquibase

The Flowable engines are using Liquibase to manage the versioning of it's tables.
This means that the `LiquibaseAutoConfiguration` from Spring Boot would automatically kick in.
However, if you are not using Liquibase then the application will not start and would throw an exception.
For this reason Flowable is setting `spring.liquibase.enabled` to `false`, which means that if you need to use Liquibase you have to explicitly enable it.

==== Further Reading

Obviously, there is a lot about Spring Boot that hasn't been touched upon yet, like very easy JTA integration or building a WAR file that can be run on major application servers. And there is a lot more to the Spring Boot integration: 

* Actuator support
* Spring Integration support
* Rest API integration: boot up the Flowable Rest API embedded within the Spring application
* Spring Security support

==== Advanced Configuration

===== Customizing Engine Configuration

It's possible to get a hold of the engine configuration by implementing the _org.flowable.spring.boot.EngineConfigurationConfigurer<T>_ interface.
Where _T_ is the Spring Type of the particular Engine Configuration.
This can be useful for advanced configuration settings or simply because a property has not been exposed (yet).
For example:

[source, java, linenums]
----
public class MyConfigurer implements EngineConfigurationConfigurer<SpringProcessEngineConfiguration> {

    public void configure(SpringProcessEngineConfiguration processEngineConfiguration) {
        // advanced configuration
    }
    
}
----

By exposing an instance of this class as an _@Bean_ in the Spring Boot configuration, the instance will be called before the process engine is fully created.

[TIP]
====
You can provide a custom implementation of a Flowable Service by using this. See {sc-flowable-boot}/ldap/FlowableLdapAutoConfiguration.java[FlowableLdapAutoConfiguration]
====

===== Combining starters

In case you need only a combination of the engines then you can add only the required dependencies.
For example to use the Process, CMMN, Form and IDM engine and use LDAP you need to add the following dependencies:

[source,xml,linenums]
----
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-spring-boot-starter-process</artifactId>
    <version>${flowable.version}</version>
</dependency>
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-spring-boot-starter-cmmn</artifactId>
    <version>${flowable.version}</version>
</dependency>
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-content-spring-configurator</artifactId>
    <version>${flowable.version}</version>
</dependency>
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-form-spring-configurator</artifactId>
    <version>${flowable.version}</version>
</dependency>
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-ldap</artifactId>
    <version>${flowable.version}</version>
</dependency>
----

===== Configuring Async Executors

The Process and CMMN engines have dedicated `AsyncExecutor`(s) and they can be configured with the `flowable.{engine}.async.executor` property group.
Where `engine` is either `process` or `cmmn`.

The `AsyncExecutor`(s) per default share the same Spring `TaskExecutor` and `SpringRejectedJobsHandler`.
In case you want to provide a dedicated executor for each of the engines you need define a qualified bean with `@Process` and `@Cmmn`.

You can configure custom executors in the following way:

[source,java,linenums]
----
@Configuration
public class MyConfiguration {

    @Process <1>
    @Bean
    public TaskExecutor processTaskExecutor() {
        return new SimpleAsyncTaskExecutor();
    }

    @Cmmn <2>
    @Bean
    public TaskExecutor cmmnTaskExecutor() {
        return new SyncTaskExecutor();
    }
}
----
<1> The Async Executor for the Process Engine would use a `SimpleAsyncTaskExecutor`
<2> The Async Executor for the CMMN Engine would use a `SyncTaskExecutor`

[IMPORTANT]
======
If you define a custom `TaskExecutor` bean the Flowable creation of the bean is not triggered.
Which means that if you define a bean qualified with `@Process` you have to define one with `@Cmmn` or `@Primary`, otherwise the Cmmn Async Executor will use the one for the Process
======

",12464,False,1887.2268945960961,median
"//
// basic_socket.hpp
// ~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#ifndef BOOST_ASIO_BASIC_SOCKET_HPP
#define BOOST_ASIO_BASIC_SOCKET_HPP

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)

#include <boost/asio/detail/config.hpp>
#include <boost/asio/async_result.hpp>
#include <boost/asio/detail/handler_type_requirements.hpp>
#include <boost/asio/detail/io_object_impl.hpp>
#include <boost/asio/detail/non_const_lvalue.hpp>
#include <boost/asio/detail/throw_error.hpp>
#include <boost/asio/detail/type_traits.hpp>
#include <boost/asio/error.hpp>
#include <boost/asio/execution_context.hpp>
#include <boost/asio/executor.hpp>
#include <boost/asio/post.hpp>
#include <boost/asio/socket_base.hpp>

#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
# include <boost/asio/detail/null_socket_service.hpp>
#elif defined(BOOST_ASIO_HAS_IOCP)
# include <boost/asio/detail/win_iocp_socket_service.hpp>
#else
# include <boost/asio/detail/reactive_socket_service.hpp>
#endif

#if defined(BOOST_ASIO_HAS_MOVE)
# include <utility>
#endif // defined(BOOST_ASIO_HAS_MOVE)

#include <boost/asio/detail/push_options.hpp>

namespace boost {
namespace asio {

#if !defined(BOOST_ASIO_BASIC_SOCKET_FWD_DECL)
#define BOOST_ASIO_BASIC_SOCKET_FWD_DECL

// Forward declaration with defaulted arguments.
template <typename Protocol, typename Executor = executor>
class basic_socket;

#endif // !defined(BOOST_ASIO_BASIC_SOCKET_FWD_DECL)

/// Provides socket functionality.
/**
 * The basic_socket class template provides functionality that is common to both
 * stream-oriented and datagram-oriented sockets.
 *
 * @par Thread Safety
 * @e Distinct @e objects: Safe.@n
 * @e Shared @e objects: Unsafe.
 */
template <typename Protocol, typename Executor>
class basic_socket
  : public socket_base
{
public:
  /// The type of the executor associated with the object.
  typedef Executor executor_type;

  /// Rebinds the socket type to another executor.
  template <typename Executor1>
  struct rebind_executor
  {
    /// The socket type when rebound to the specified executor.
    typedef basic_socket<Protocol, Executor1> other;
  };

  /// The native representation of a socket.
#if defined(GENERATING_DOCUMENTATION)
  typedef implementation_defined native_handle_type;
#elif defined(BOOST_ASIO_WINDOWS_RUNTIME)
  typedef typename detail::null_socket_service<
    Protocol>::native_handle_type native_handle_type;
#elif defined(BOOST_ASIO_HAS_IOCP)
  typedef typename detail::win_iocp_socket_service<
    Protocol>::native_handle_type native_handle_type;
#else
  typedef typename detail::reactive_socket_service<
    Protocol>::native_handle_type native_handle_type;
#endif

  /// The protocol type.
  typedef Protocol protocol_type;

  /// The endpoint type.
  typedef typename Protocol::endpoint endpoint_type;

#if !defined(BOOST_ASIO_NO_EXTENSIONS)
  /// A basic_socket is always the lowest layer.
  typedef basic_socket<Protocol, Executor> lowest_layer_type;
#endif // !defined(BOOST_ASIO_NO_EXTENSIONS)

  /// Construct a basic_socket without opening it.
  /**
   * This constructor creates a socket without opening it.
   *
   * @param ex The I/O executor that the socket will use, by default, to
   * dispatch handlers for any asynchronous operations performed on the socket.
   */
  explicit basic_socket(const executor_type& ex)
    : impl_(ex)
  {
  }

  /// Construct a basic_socket without opening it.
  /**
   * This constructor creates a socket without opening it.
   *
   * @param context An execution context which provides the I/O executor that
   * the socket will use, by default, to dispatch handlers for any asynchronous
   * operations performed on the socket.
   */
  template <typename ExecutionContext>
  explicit basic_socket(ExecutionContext& context,
      typename enable_if<
        is_convertible<ExecutionContext&, execution_context&>::value
      >::type* = 0)
    : impl_(context)
  {
  }

  /// Construct and open a basic_socket.
  /**
   * This constructor creates and opens a socket.
   *
   * @param ex The I/O executor that the socket will use, by default, to
   * dispatch handlers for any asynchronous operations performed on the socket.
   *
   * @param protocol An object specifying protocol parameters to be used.
   *
   * @throws boost::system::system_error Thrown on failure.
   */
  basic_socket(const executor_type& ex, const protocol_type& protocol)
    : impl_(ex)
  {
    boost::system::error_code ec;
    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
    boost::asio::detail::throw_error(ec, ""open"");
  }

  /// Construct and open a basic_socket.
  /**
   * This constructor creates and opens a socket.
   *
   * @param context An execution context which provides the I/O executor that
   * the socket will use, by default, to dispatch handlers for any asynchronous
   * operations performed on the socket.
   *
   * @param protocol An object specifying protocol parameters to be used.
   *
   * @throws boost::system::system_error Thrown on failure.
   */
  template <typename ExecutionContext>
  basic_socket(ExecutionContext& context, const protocol_type& protocol,
      typename enable_if<
        is_convertible<ExecutionContext&, execution_context&>::value
      >::type* = 0)
    : impl_(context)
  {
    boost::system::error_code ec;
    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
    boost::asio::detail::throw_error(ec, ""open"");
  }

  /// Construct a basic_socket, opening it and binding it to the given local
  /// endpoint.
  /**
   * This constructor creates a socket and automatically opens it bound to the
   * specified endpoint on the local machine. The protocol used is the protocol
   * associated with the given endpoint.
   *
   * @param ex The I/O executor that the socket will use, by default, to
   * dispatch handlers for any asynchronous operations performed on the socket.
   *
   * @param endpoint An endpoint on the local machine to which the socket will
   * be bound.
   *
   * @throws boost::system::system_error Thrown on failure.
   */
  basic_socket(const executor_type& ex, const endpoint_type& endpoint)
    : impl_(ex)
  {
    boost::system::error_code ec;
    const protocol_type protocol = endpoint.protocol();
    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
    boost::asio::detail::throw_error(ec, ""open"");
    impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);
    boost::asio::detail::throw_error(ec, ""bind"");
  }

  /// Construct a basic_socket, opening it and binding it to the given local
  /// endpoint.
  /**
   * This constructor creates a socket and automatically opens it bound to the
   * specified endpoint on the local machine. The protocol used is the protocol
   * associated with the given endpoint.
   *
   * @param context An execution context which provides the I/O executor that
   * the socket will use, by default, to dispatch handlers for any asynchronous
   * operations performed on the socket.
   *
   * @param endpoint An endpoint on the local machine to which the socket will
   * be bound.
   *
   * @throws boost::system::system_error Thrown on failure.
   */
  template <typename ExecutionContext>
  basic_socket(ExecutionContext& context, const endpoint_type& endpoint,
      typename enable_if<
        is_convertible<ExecutionContext&, execution_context&>::value
      >::type* = 0)
    : impl_(context)
  {
    boost::system::error_code ec;
    const protocol_type protocol = endpoint.protocol();
    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
    boost::asio::detail::throw_error(ec, ""open"");
    impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);
    boost::asio::detail::throw_error(ec, ""bind"");
  }

  /// Construct a basic_socket on an existing native socket.
  /**
   * This constructor creates a socket object to hold an existing native socket.
   *
   * @param ex The I/O executor that the socket will use, by default, to
   * dispatch handlers for any asynchronous operations performed on the socket.
   *
   * @param protocol An object specifying protocol parameters to be used.
   *
   * @param native_socket A native socket.
   *
   * @throws boost::system::system_error Thrown on failure.
   */
  basic_socket(const executor_type& ex, const protocol_type& protocol,
      const native_handle_type& native_socket)
    : impl_(ex)
  {
    boost::system::error_code ec;
    impl_.get_service().assign(impl_.get_implementation(),
        protocol, native_socket, ec);
    boost::asio::detail::throw_error(ec, ""assign"");
  }

  /// Construct a basic_socket on an existing native socket.
  /**
   * This constructor creates a socket object to hold an existing native socket.
   *
   * @param context An execution context which provides the I/O executor that
   * the socket will use, by default, to dispatch handlers for any asynchronous
   * operations performed on the socket.
   *
   * @param protocol An object specifying protocol parameters to be used.
   *
   * @param native_socket A native socket.
   *
   * @throws boost::system::system_error Thrown on failure.
   */
  template <typename ExecutionContext>
  basic_socket(ExecutionContext& context, const protocol_type& protocol,
      const native_handle_type& native_socket,
      typename enable_if<
        is_convertible<ExecutionContext&, execution_context&>::value
      >::type* = 0)
    : impl_(context)
  {
    boost::system::error_code ec;
    impl_.get_service().assign(impl_.get_implementation(),
        protocol, native_socket, ec);
    boost::asio::detail::throw_error(ec, ""assign"");
  }

#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
  /// Move-construct a basic_socket from another.
  /**
   * This constructor moves a socket from one object to another.
   *
   * @param other The other basic_socket object from which the move will
   * occur.
   *
   * @note Following the move, the moved-from object is in the same state as if
   * constructed using the @c basic_socket(const executor_type&) constructor.
   */
  basic_socket(basic_socket&& other) BOOST_ASIO_NOEXCEPT
    : impl_(std::move(other.impl_))
  {
  }

  /// Move-assign a basic_socket from another.
  /**
   * This assignment operator moves a socket from one object to another.
   *
   * @param other The other basic_socket object from which the move will
   * occur.
   *
   * @note Following the move, the moved-from object is in the same state as if
   * constructed using the @c basic_socket(const executor_type&) constructor.
   */
  basic_socket& operator=(basic_socket&& other)
  {
    impl_ = std::move(other.impl_);
    return *this;
  }

  // All sockets have access to each other's implementations.
  template <typename Protocol1, typename Executor1>
  friend class basic_socket;

  /// Move-construct a basic_socket from a socket of another protocol type.
  /**
   * This constructor moves a socket from one object to another.
   *
   * @param other The other basic_socket object from which the move will
   * occur.
   *
   * @note Following the move, the moved-from object is in the same state as if
   * constructed using the @c basic_socket(const executor_type&) constructor.
   */
  template <typename Protocol1, typename Executor1>
  basic_socket(basic_socket<Protocol1, Executor1>&& other,
      typename enable_if<
        is_convertible<Protocol1, Protocol>::value
          && is_convertible<Executor1, Executor>::value
      >::type* = 0)
    : impl_(std::move(other.impl_))
  {
  }

  /// Move-assign a basic_socket from a socket of another protocol type.
  /**
   * This assignment operator moves a socket from one object to another.
   *
   * @param other The other basic_socket object from which the move will
   * occur.
   *
   * @note Following the move, the moved-from object is in the same state as if
   * constructed using the @c basic_socket(const executor_type&) constructor.
   */
  template <typename Protocol1, typename Executor1>
  typename enable_if<
    is_convertible<Protocol1, Protocol>::value
      && is_convertible<Executor1, Executor>::value,
    basic_socket&
  >::type operator=(basic_socket<Protocol1, Executor1> && other)
  {
    basic_socket tmp(std::move(other));
    impl_ = std::move(tmp.impl_);
    return *this;
  }
#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)

  /// Get the executor associated with the object.
  executor_type get_executor() BOOST_ASIO_NOEXCEPT
  {
    return impl_.get_executor();
  }

#if !defined(BOOST_ASIO_NO_EXTENSIONS)
  /// Get a reference to the lowest layer.
  /**
   * This function returns a reference to the lowest layer in a stack of
   * layers. Since a basic_socket cannot contain any further layers, it simply
   * returns a reference to itself.
   *
   * @return A reference to the lowest layer in the stack of layers. Ownership
   * is not transferred to the caller.
   */
  lowest_layer_type& lowest_layer()
  {
    return *this;
  }

  /// Get a const reference to the lowest layer.
  /**
   * This function returns a const reference to the lowest layer in a stack of
   * layers. Since a basic_socket cannot contain any further layers, it simply
   * returns a reference to itself.
   *
   * @return A const reference to the lowest layer in the stack of layers.
   * Ownership is not transferred to the caller.
   */
  const lowest_layer_type& lowest_layer() const
  {
    return *this;
  }
#endif // !defined(BOOST_ASIO_NO_EXTENSIONS)

  /// Open the socket using the specified protocol.
  /**
   * This function opens the socket so that it will use the specified protocol.
   *
   * @param protocol An object specifying protocol parameters to be used.
   *
   * @throws boost::system::system_error Thrown on failure.
   *
   * @par Example
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * socket.open(boost::asio::ip::tcp::v4());
   * @endcode
   */
  void open(const protocol_type& protocol = protocol_type())
  {
    boost::system::error_code ec;
    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
    boost::asio::detail::throw_error(ec, ""open"");
  }

  /// Open the socket using the specified protocol.
  /**
   * This function opens the socket so that it will use the specified protocol.
   *
   * @param protocol An object specifying which protocol is to be used.
   *
   * @param ec Set to indicate what error occurred, if any.
   *
   * @par Example
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * boost::system::error_code ec;
   * socket.open(boost::asio::ip::tcp::v4(), ec);
   * if (ec)
   * {
   *   // An error occurred.
   * }
   * @endcode
   */
  BOOST_ASIO_SYNC_OP_VOID open(const protocol_type& protocol,
      boost::system::error_code& ec)
  {
    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
  }

  /// Assign an existing native socket to the socket.
  /*
   * This function opens the socket to hold an existing native socket.
   *
   * @param protocol An object specifying which protocol is to be used.
   *
   * @param native_socket A native socket.
   *
   * @throws boost::system::system_error Thrown on failure.
   */
  void assign(const protocol_type& protocol,
      const native_handle_type& native_socket)
  {
    boost::system::error_code ec;
    impl_.get_service().assign(impl_.get_implementation(),
        protocol, native_socket, ec);
    boost::asio::detail::throw_error(ec, ""assign"");
  }

  /// Assign an existing native socket to the socket.
  /*
   * This function opens the socket to hold an existing native socket.
   *
   * @param protocol An object specifying which protocol is to be used.
   *
   * @param native_socket A native socket.
   *
   * @param ec Set to indicate what error occurred, if any.
   */
  BOOST_ASIO_SYNC_OP_VOID assign(const protocol_type& protocol,
      const native_handle_type& native_socket, boost::system::error_code& ec)
  {
    impl_.get_service().assign(impl_.get_implementation(),
        protocol, native_socket, ec);
    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
  }

  /// Determine whether the socket is open.
  bool is_open() const
  {
    return impl_.get_service().is_open(impl_.get_implementation());
  }

  /// Close the socket.
  /**
   * This function is used to close the socket. Any asynchronous send, receive
   * or connect operations will be cancelled immediately, and will complete
   * with the boost::asio::error::operation_aborted error.
   *
   * @throws boost::system::system_error Thrown on failure. Note that, even if
   * the function indicates an error, the underlying descriptor is closed.
   *
   * @note For portable behaviour with respect to graceful closure of a
   * connected socket, call shutdown() before closing the socket.
   */
  void close()
  {
    boost::system::error_code ec;
    impl_.get_service().close(impl_.get_implementation(), ec);
    boost::asio::detail::throw_error(ec, ""close"");
  }

  /// Close the socket.
  /**
   * This function is used to close the socket. Any asynchronous send, receive
   * or connect operations will be cancelled immediately, and will complete
   * with the boost::asio::error::operation_aborted error.
   *
   * @param ec Set to indicate what error occurred, if any. Note that, even if
   * the function indicates an error, the underlying descriptor is closed.
   *
   * @par Example
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * ...
   * boost::system::error_code ec;
   * socket.close(ec);
   * if (ec)
   * {
   *   // An error occurred.
   * }
   * @endcode
   *
   * @note For portable behaviour with respect to graceful closure of a
   * connected socket, call shutdown() before closing the socket.
   */
  BOOST_ASIO_SYNC_OP_VOID close(boost::system::error_code& ec)
  {
    impl_.get_service().close(impl_.get_implementation(), ec);
    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
  }

  /// Release ownership of the underlying native socket.
  /**
   * This function causes all outstanding asynchronous connect, send and receive
   * operations to finish immediately, and the handlers for cancelled operations
   * will be passed the boost::asio::error::operation_aborted error. Ownership
   * of the native socket is then transferred to the caller.
   *
   * @throws boost::system::system_error Thrown on failure.
   *
   * @note This function is unsupported on Windows versions prior to Windows
   * 8.1, and will fail with boost::asio::error::operation_not_supported on
   * these platforms.
   */
#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \\
  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
  __declspec(deprecated(""This function always fails with ""
        ""operation_not_supported when used on Windows versions ""
        ""prior to Windows 8.1.""))
#endif
  native_handle_type release()
  {
    boost::system::error_code ec;
    native_handle_type s = impl_.get_service().release(
        impl_.get_implementation(), ec);
    boost::asio::detail::throw_error(ec, ""release"");
    return s;
  }

  /// Release ownership of the underlying native socket.
  /**
   * This function causes all outstanding asynchronous connect, send and receive
   * operations to finish immediately, and the handlers for cancelled operations
   * will be passed the boost::asio::error::operation_aborted error. Ownership
   * of the native socket is then transferred to the caller.
   *
   * @param ec Set to indicate what error occurred, if any.
   *
   * @note This function is unsupported on Windows versions prior to Windows
   * 8.1, and will fail with boost::asio::error::operation_not_supported on
   * these platforms.
   */
#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \\
  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
  __declspec(deprecated(""This function always fails with ""
        ""operation_not_supported when used on Windows versions ""
        ""prior to Windows 8.1.""))
#endif
  native_handle_type release(boost::system::error_code& ec)
  {
    return impl_.get_service().release(impl_.get_implementation(), ec);
  }

  /// Get the native socket representation.
  /**
   * This function may be used to obtain the underlying representation of the
   * socket. This is intended to allow access to native socket functionality
   * that is not otherwise provided.
   */
  native_handle_type native_handle()
  {
    return impl_.get_service().native_handle(impl_.get_implementation());
  }

  /// Cancel all asynchronous operations associated with the socket.
  /**
   * This function causes all outstanding asynchronous connect, send and receive
   * operations to finish immediately, and the handlers for cancelled operations
   * will be passed the boost::asio::error::operation_aborted error.
   *
   * @throws boost::system::system_error Thrown on failure.
   *
   * @note Calls to cancel() will always fail with
   * boost::asio::error::operation_not_supported when run on Windows XP, Windows
   * Server 2003, and earlier versions of Windows, unless
   * BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo function has
   * two issues that should be considered before enabling its use:
   *
   * @li It will only cancel asynchronous operations that were initiated in the
   * current thread.
   *
   * @li It can appear to complete without error, but the request to cancel the
   * unfinished operations may be silently ignored by the operating system.
   * Whether it works or not seems to depend on the drivers that are installed.
   *
   * For portable cancellation, consider using one of the following
   * alternatives:
   *
   * @li Disable asio's I/O completion port backend by defining
   * BOOST_ASIO_DISABLE_IOCP.
   *
   * @li Use the close() function to simultaneously cancel the outstanding
   * operations and close the socket.
   *
   * When running on Windows Vista, Windows Server 2008, and later, the
   * CancelIoEx function is always used. This function does not have the
   * problems described above.
   */
#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \\
  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600) \\
  && !defined(BOOST_ASIO_ENABLE_CANCELIO)
  __declspec(deprecated(""By default, this function always fails with ""
        ""operation_not_supported when used on Windows XP, Windows Server 2003, ""
        ""or earlier. Consult documentation for details.""))
#endif
  void cancel()
  {
    boost::system::error_code ec;
    impl_.get_service().cancel(impl_.get_implementation(), ec);
    boost::asio::detail::throw_error(ec, ""cancel"");
  }

  /// Cancel all asynchronous operations associated with the socket.
  /**
   * This function causes all outstanding asynchronous connect, send and receive
   * operations to finish immediately, and the handlers for cancelled operations
   * will be passed the boost::asio::error::operation_aborted error.
   *
   * @param ec Set to indicate what error occurred, if any.
   *
   * @note Calls to cancel() will always fail with
   * boost::asio::error::operation_not_supported when run on Windows XP, Windows
   * Server 2003, and earlier versions of Windows, unless
   * BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo function has
   * two issues that should be considered before enabling its use:
   *
   * @li It will only cancel asynchronous operations that were initiated in the
   * current thread.
   *
   * @li It can appear to complete without error, but the request to cancel the
   * unfinished operations may be silently ignored by the operating system.
   * Whether it works or not seems to depend on the drivers that are installed.
   *
   * For portable cancellation, consider using one of the following
   * alternatives:
   *
   * @li Disable asio's I/O completion port backend by defining
   * BOOST_ASIO_DISABLE_IOCP.
   *
   * @li Use the close() function to simultaneously cancel the outstanding
   * operations and close the socket.
   *
   * When running on Windows Vista, Windows Server 2008, and later, the
   * CancelIoEx function is always used. This function does not have the
   * problems described above.
   */
#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \\
  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600) \\
  && !defined(BOOST_ASIO_ENABLE_CANCELIO)
  __declspec(deprecated(""By default, this function always fails with ""
        ""operation_not_supported when used on Windows XP, Windows Server 2003, ""
        ""or earlier. Consult documentation for details.""))
#endif
  BOOST_ASIO_SYNC_OP_VOID cancel(boost::system::error_code& ec)
  {
    impl_.get_service().cancel(impl_.get_implementation(), ec);
    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
  }

  /// Determine whether the socket is at the out-of-band data mark.
  /**
   * This function is used to check whether the socket input is currently
   * positioned at the out-of-band data mark.
   *
   * @return A bool indicating whether the socket is at the out-of-band data
   * mark.
   *
   * @throws boost::system::system_error Thrown on failure.
   */
  bool at_mark() const
  {
    boost::system::error_code ec;
    bool b = impl_.get_service().at_mark(impl_.get_implementation(), ec);
    boost::asio::detail::throw_error(ec, ""at_mark"");
    return b;
  }

  /// Determine whether the socket is at the out-of-band data mark.
  /**
   * This function is used to check whether the socket input is currently
   * positioned at the out-of-band data mark.
   *
   * @param ec Set to indicate what error occurred, if any.
   *
   * @return A bool indicating whether the socket is at the out-of-band data
   * mark.
   */
  bool at_mark(boost::system::error_code& ec) const
  {
    return impl_.get_service().at_mark(impl_.get_implementation(), ec);
  }

  /// Determine the number of bytes available for reading.
  /**
   * This function is used to determine the number of bytes that may be read
   * without blocking.
   *
   * @return The number of bytes that may be read without blocking, or 0 if an
   * error occurs.
   *
   * @throws boost::system::system_error Thrown on failure.
   */
  std::size_t available() const
  {
    boost::system::error_code ec;
    std::size_t s = impl_.get_service().available(
        impl_.get_implementation(), ec);
    boost::asio::detail::throw_error(ec, ""available"");
    return s;
  }

  /// Determine the number of bytes available for reading.
  /**
   * This function is used to determine the number of bytes that may be read
   * without blocking.
   *
   * @param ec Set to indicate what error occurred, if any.
   *
   * @return The number of bytes that may be read without blocking, or 0 if an
   * error occurs.
   */
  std::size_t available(boost::system::error_code& ec) const
  {
    return impl_.get_service().available(impl_.get_implementation(), ec);
  }

  /// Bind the socket to the given local endpoint.
  /**
   * This function binds the socket to the specified endpoint on the local
   * machine.
   *
   * @param endpoint An endpoint on the local machine to which the socket will
   * be bound.
   *
   * @throws boost::system::system_error Thrown on failure.
   *
   * @par Example
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * socket.open(boost::asio::ip::tcp::v4());
   * socket.bind(boost::asio::ip::tcp::endpoint(
   *       boost::asio::ip::tcp::v4(), 12345));
   * @endcode
   */
  void bind(const endpoint_type& endpoint)
  {
    boost::system::error_code ec;
    impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);
    boost::asio::detail::throw_error(ec, ""bind"");
  }

  /// Bind the socket to the given local endpoint.
  /**
   * This function binds the socket to the specified endpoint on the local
   * machine.
   *
   * @param endpoint An endpoint on the local machine to which the socket will
   * be bound.
   *
   * @param ec Set to indicate what error occurred, if any.
   *
   * @par Example
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * socket.open(boost::asio::ip::tcp::v4());
   * boost::system::error_code ec;
   * socket.bind(boost::asio::ip::tcp::endpoint(
   *       boost::asio::ip::tcp::v4(), 12345), ec);
   * if (ec)
   * {
   *   // An error occurred.
   * }
   * @endcode
   */
  BOOST_ASIO_SYNC_OP_VOID bind(const endpoint_type& endpoint,
      boost::system::error_code& ec)
  {
    impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);
    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
  }

  /// Connect the socket to the specified endpoint.
  /**
   * This function is used to connect a socket to the specified remote endpoint.
   * The function call will block until the connection is successfully made or
   * an error occurs.
   *
   * The socket is automatically opened if it is not already open. If the
   * connect fails, and the socket was automatically opened, the socket is
   * not returned to the closed state.
   *
   * @param peer_endpoint The remote endpoint to which the socket will be
   * connected.
   *
   * @throws boost::system::system_error Thrown on failure.
   *
   * @par Example
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * boost::asio::ip::tcp::endpoint endpoint(
   *     boost::asio::ip::address::from_string(""1.2.3.4""), 12345);
   * socket.connect(endpoint);
   * @endcode
   */
  void connect(const endpoint_type& peer_endpoint)
  {
    boost::system::error_code ec;
    if (!is_open())
    {
      impl_.get_service().open(impl_.get_implementation(),
          peer_endpoint.protocol(), ec);
      boost::asio::detail::throw_error(ec, ""connect"");
    }
    impl_.get_service().connect(impl_.get_implementation(), peer_endpoint, ec);
    boost::asio::detail::throw_error(ec, ""connect"");
  }

  /// Connect the socket to the specified endpoint.
  /**
   * This function is used to connect a socket to the specified remote endpoint.
   * The function call will block until the connection is successfully made or
   * an error occurs.
   *
   * The socket is automatically opened if it is not already open. If the
   * connect fails, and the socket was automatically opened, the socket is
   * not returned to the closed state.
   *
   * @param peer_endpoint The remote endpoint to which the socket will be
   * connected.
   *
   * @param ec Set to indicate what error occurred, if any.
   *
   * @par Example
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * boost::asio::ip::tcp::endpoint endpoint(
   *     boost::asio::ip::address::from_string(""1.2.3.4""), 12345);
   * boost::system::error_code ec;
   * socket.connect(endpoint, ec);
   * if (ec)
   * {
   *   // An error occurred.
   * }
   * @endcode
   */
  BOOST_ASIO_SYNC_OP_VOID connect(const endpoint_type& peer_endpoint,
      boost::system::error_code& ec)
  {
    if (!is_open())
    {
      impl_.get_service().open(impl_.get_implementation(),
            peer_endpoint.protocol(), ec);
      if (ec)
      {
        BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
      }
    }

    impl_.get_service().connect(impl_.get_implementation(), peer_endpoint, ec);
    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
  }

  /// Start an asynchronous connect.
  /**
   * This function is used to asynchronously connect a socket to the specified
   * remote endpoint. The function call always returns immediately.
   *
   * The socket is automatically opened if it is not already open. If the
   * connect fails, and the socket was automatically opened, the socket is
   * not returned to the closed state.
   *
   * @param peer_endpoint The remote endpoint to which the socket will be
   * connected. Copies will be made of the endpoint object as required.
   *
   * @param handler The handler to be called when the connection operation
   * completes. Copies will be made of the handler as required. The function
   * signature of the handler must be:
   * @code void handler(
   *   const boost::system::error_code& error // Result of operation
   * ); @endcode
   * Regardless of whether the asynchronous operation completes immediately or
   * not, the handler will not be invoked from within this function. On
   * immediate completion, invocation of the handler will be performed in a
   * manner equivalent to using boost::asio::post().
   *
   * @par Example
   * @code
   * void connect_handler(const boost::system::error_code& error)
   * {
   *   if (!error)
   *   {
   *     // Connect succeeded.
   *   }
   * }
   *
   * ...
   *
   * boost::asio::ip::tcp::socket socket(my_context);
   * boost::asio::ip::tcp::endpoint endpoint(
   *     boost::asio::ip::address::from_string(""1.2.3.4""), 12345);
   * socket.async_connect(endpoint, connect_handler);
   * @endcode
   */
  template <
      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
        ConnectHandler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ConnectHandler,
      void (boost::system::error_code))
  async_connect(const endpoint_type& peer_endpoint,
      BOOST_ASIO_MOVE_ARG(ConnectHandler) handler
        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
  {
    boost::system::error_code open_ec;
    if (!is_open())
    {
      const protocol_type protocol = peer_endpoint.protocol();
      impl_.get_service().open(impl_.get_implementation(), protocol, open_ec);
    }

    return async_initiate<ConnectHandler, void (boost::system::error_code)>(
        initiate_async_connect(this), handler, peer_endpoint, open_ec);
  }

  /// Set an option on the socket.
  /**
   * This function is used to set an option on the socket.
   *
   * @param option The new option value to be set on the socket.
   *
   * @throws boost::system::system_error Thrown on failure.
   *
   * @sa SettableSocketOption @n
   * boost::asio::socket_base::broadcast @n
   * boost::asio::socket_base::do_not_route @n
   * boost::asio::socket_base::keep_alive @n
   * boost::asio::socket_base::linger @n
   * boost::asio::socket_base::receive_buffer_size @n
   * boost::asio::socket_base::receive_low_watermark @n
   * boost::asio::socket_base::reuse_address @n
   * boost::asio::socket_base::send_buffer_size @n
   * boost::asio::socket_base::send_low_watermark @n
   * boost::asio::ip::multicast::join_group @n
   * boost::asio::ip::multicast::leave_group @n
   * boost::asio::ip::multicast::enable_loopback @n
   * boost::asio::ip::multicast::outbound_interface @n
   * boost::asio::ip::multicast::hops @n
   * boost::asio::ip::tcp::no_delay
   *
   * @par Example
   * Setting the IPPROTO_TCP/TCP_NODELAY option:
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * ...
   * boost::asio::ip::tcp::no_delay option(true);
   * socket.set_option(option);
   * @endcode
   */
  template <typename SettableSocketOption>
  void set_option(const SettableSocketOption& option)
  {
    boost::system::error_code ec;
    impl_.get_service().set_option(impl_.get_implementation(), option, ec);
    boost::asio::detail::throw_error(ec, ""set_option"");
  }

  /// Set an option on the socket.
  /**
   * This function is used to set an option on the socket.
   *
   * @param option The new option value to be set on the socket.
   *
   * @param ec Set to indicate what error occurred, if any.
   *
   * @sa SettableSocketOption @n
   * boost::asio::socket_base::broadcast @n
   * boost::asio::socket_base::do_not_route @n
   * boost::asio::socket_base::keep_alive @n
   * boost::asio::socket_base::linger @n
   * boost::asio::socket_base::receive_buffer_size @n
   * boost::asio::socket_base::receive_low_watermark @n
   * boost::asio::socket_base::reuse_address @n
   * boost::asio::socket_base::send_buffer_size @n
   * boost::asio::socket_base::send_low_watermark @n
   * boost::asio::ip::multicast::join_group @n
   * boost::asio::ip::multicast::leave_group @n
   * boost::asio::ip::multicast::enable_loopback @n
   * boost::asio::ip::multicast::outbound_interface @n
   * boost::asio::ip::multicast::hops @n
   * boost::asio::ip::tcp::no_delay
   *
   * @par Example
   * Setting the IPPROTO_TCP/TCP_NODELAY option:
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * ...
   * boost::asio::ip::tcp::no_delay option(true);
   * boost::system::error_code ec;
   * socket.set_option(option, ec);
   * if (ec)
   * {
   *   // An error occurred.
   * }
   * @endcode
   */
  template <typename SettableSocketOption>
  BOOST_ASIO_SYNC_OP_VOID set_option(const SettableSocketOption& option,
      boost::system::error_code& ec)
  {
    impl_.get_service().set_option(impl_.get_implementation(), option, ec);
    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
  }

  /// Get an option from the socket.
  /**
   * This function is used to get the current value of an option on the socket.
   *
   * @param option The option value to be obtained from the socket.
   *
   * @throws boost::system::system_error Thrown on failure.
   *
   * @sa GettableSocketOption @n
   * boost::asio::socket_base::broadcast @n
   * boost::asio::socket_base::do_not_route @n
   * boost::asio::socket_base::keep_alive @n
   * boost::asio::socket_base::linger @n
   * boost::asio::socket_base::receive_buffer_size @n
   * boost::asio::socket_base::receive_low_watermark @n
   * boost::asio::socket_base::reuse_address @n
   * boost::asio::socket_base::send_buffer_size @n
   * boost::asio::socket_base::send_low_watermark @n
   * boost::asio::ip::multicast::join_group @n
   * boost::asio::ip::multicast::leave_group @n
   * boost::asio::ip::multicast::enable_loopback @n
   * boost::asio::ip::multicast::outbound_interface @n
   * boost::asio::ip::multicast::hops @n
   * boost::asio::ip::tcp::no_delay
   *
   * @par Example
   * Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * ...
   * boost::asio::ip::tcp::socket::keep_alive option;
   * socket.get_option(option);
   * bool is_set = option.value();
   * @endcode
   */
  template <typename GettableSocketOption>
  void get_option(GettableSocketOption& option) const
  {
    boost::system::error_code ec;
    impl_.get_service().get_option(impl_.get_implementation(), option, ec);
    boost::asio::detail::throw_error(ec, ""get_option"");
  }

  /// Get an option from the socket.
  /**
   * This function is used to get the current value of an option on the socket.
   *
   * @param option The option value to be obtained from the socket.
   *
   * @param ec Set to indicate what error occurred, if any.
   *
   * @sa GettableSocketOption @n
   * boost::asio::socket_base::broadcast @n
   * boost::asio::socket_base::do_not_route @n
   * boost::asio::socket_base::keep_alive @n
   * boost::asio::socket_base::linger @n
   * boost::asio::socket_base::receive_buffer_size @n
   * boost::asio::socket_base::receive_low_watermark @n
   * boost::asio::socket_base::reuse_address @n
   * boost::asio::socket_base::send_buffer_size @n
   * boost::asio::socket_base::send_low_watermark @n
   * boost::asio::ip::multicast::join_group @n
   * boost::asio::ip::multicast::leave_group @n
   * boost::asio::ip::multicast::enable_loopback @n
   * boost::asio::ip::multicast::outbound_interface @n
   * boost::asio::ip::multicast::hops @n
   * boost::asio::ip::tcp::no_delay
   *
   * @par Example
   * Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * ...
   * boost::asio::ip::tcp::socket::keep_alive option;
   * boost::system::error_code ec;
   * socket.get_option(option, ec);
   * if (ec)
   * {
   *   // An error occurred.
   * }
   * bool is_set = option.value();
   * @endcode
   */
  template <typename GettableSocketOption>
  BOOST_ASIO_SYNC_OP_VOID get_option(GettableSocketOption& option,
      boost::system::error_code& ec) const
  {
    impl_.get_service().get_option(impl_.get_implementation(), option, ec);
    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
  }

  /// Perform an IO control command on the socket.
  /**
   * This function is used to execute an IO control command on the socket.
   *
   * @param command The IO control command to be performed on the socket.
   *
   * @throws boost::system::system_error Thrown on failure.
   *
   * @sa IoControlCommand @n
   * boost::asio::socket_base::bytes_readable @n
   * boost::asio::socket_base::non_blocking_io
   *
   * @par Example
   * Getting the number of bytes ready to read:
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * ...
   * boost::asio::ip::tcp::socket::bytes_readable command;
   * socket.io_control(command);
   * std::size_t bytes_readable = command.get();
   * @endcode
   */
  template <typename IoControlCommand>
  void io_control(IoControlCommand& command)
  {
    boost::system::error_code ec;
    impl_.get_service().io_control(impl_.get_implementation(), command, ec);
    boost::asio::detail::throw_error(ec, ""io_control"");
  }

  /// Perform an IO control command on the socket.
  /**
   * This function is used to execute an IO control command on the socket.
   *
   * @param command The IO control command to be performed on the socket.
   *
   * @param ec Set to indicate what error occurred, if any.
   *
   * @sa IoControlCommand @n
   * boost::asio::socket_base::bytes_readable @n
   * boost::asio::socket_base::non_blocking_io
   *
   * @par Example
   * Getting the number of bytes ready to read:
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * ...
   * boost::asio::ip::tcp::socket::bytes_readable command;
   * boost::system::error_code ec;
   * socket.io_control(command, ec);
   * if (ec)
   * {
   *   // An error occurred.
   * }
   * std::size_t bytes_readable = command.get();
   * @endcode
   */
  template <typename IoControlCommand>
  BOOST_ASIO_SYNC_OP_VOID io_control(IoControlCommand& command,
      boost::system::error_code& ec)
  {
    impl_.get_service().io_control(impl_.get_implementation(), command, ec);
    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
  }

  /// Gets the non-blocking mode of the socket.
  /**
   * @returns @c true if the socket's synchronous operations will fail with
   * boost::asio::error::would_block if they are unable to perform the requested
   * operation immediately. If @c false, synchronous operations will block
   * until complete.
   *
   * @note The non-blocking mode has no effect on the behaviour of asynchronous
   * operations. Asynchronous operations will never fail with the error
   * boost::asio::error::would_block.
   */
  bool non_blocking() const
  {
    return impl_.get_service().non_blocking(impl_.get_implementation());
  }

  /// Sets the non-blocking mode of the socket.
  /**
   * @param mode If @c true, the socket's synchronous operations will fail with
   * boost::asio::error::would_block if they are unable to perform the requested
   * operation immediately. If @c false, synchronous operations will block
   * until complete.
   *
   * @throws boost::system::system_error Thrown on failure.
   *
   * @note The non-blocking mode has no effect on the behaviour of asynchronous
   * operations. Asynchronous operations will never fail with the error
   * boost::asio::error::would_block.
   */
  void non_blocking(bool mode)
  {
    boost::system::error_code ec;
    impl_.get_service().non_blocking(impl_.get_implementation(), mode, ec);
    boost::asio::detail::throw_error(ec, ""non_blocking"");
  }

  /// Sets the non-blocking mode of the socket.
  /**
   * @param mode If @c true, the socket's synchronous operations will fail with
   * boost::asio::error::would_block if they are unable to perform the requested
   * operation immediately. If @c false, synchronous operations will block
   * until complete.
   *
   * @param ec Set to indicate what error occurred, if any.
   *
   * @note The non-blocking mode has no effect on the behaviour of asynchronous
   * operations. Asynchronous operations will never fail with the error
   * boost::asio::error::would_block.
   */
  BOOST_ASIO_SYNC_OP_VOID non_blocking(
      bool mode, boost::system::error_code& ec)
  {
    impl_.get_service().non_blocking(impl_.get_implementation(), mode, ec);
    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
  }

  /// Gets the non-blocking mode of the native socket implementation.
  /**
   * This function is used to retrieve the non-blocking mode of the underlying
   * native socket. This mode has no effect on the behaviour of the socket
   * object's synchronous operations.
   *
   * @returns @c true if the underlying socket is in non-blocking mode and
   * direct system calls may fail with boost::asio::error::would_block (or the
   * equivalent system error).
   *
   * @note The current non-blocking mode is cached by the socket object.
   * Consequently, the return value may be incorrect if the non-blocking mode
   * was set directly on the native socket.
   *
   * @par Example
   * This function is intended to allow the encapsulation of arbitrary
   * non-blocking system calls as asynchronous operations, in a way that is
   * transparent to the user of the socket object. The following example
   * illustrates how Linux's @c sendfile system call might be encapsulated:
   * @code template <typename Handler>
   * struct sendfile_op
   * {
   *   tcp::socket& sock_;
   *   int fd_;
   *   Handler handler_;
   *   off_t offset_;
   *   std::size_t total_bytes_transferred_;
   *
   *   // Function call operator meeting WriteHandler requirements.
   *   // Used as the handler for the async_write_some operation.
   *   void operator()(boost::system::error_code ec, std::size_t)
   *   {
   *     // Put the underlying socket into non-blocking mode.
   *     if (!ec)
   *       if (!sock_.native_non_blocking())
   *         sock_.native_non_blocking(true, ec);
   *
   *     if (!ec)
   *     {
   *       for (;;)
   *       {
   *         // Try the system call.
   *         errno = 0;
   *         int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
   *         ec = boost::system::error_code(n < 0 ? errno : 0,
   *             boost::asio::error::get_system_category());
   *         total_bytes_transferred_ += ec ? 0 : n;
   *
   *         // Retry operation immediately if interrupted by signal.
   *         if (ec == boost::asio::error::interrupted)
   *           continue;
   *
   *         // Check if we need to run the operation again.
   *         if (ec == boost::asio::error::would_block
   *             || ec == boost::asio::error::try_again)
   *         {
   *           // We have to wait for the socket to become ready again.
   *           sock_.async_wait(tcp::socket::wait_write, *this);
   *           return;
   *         }
   *
   *         if (ec || n == 0)
   *         {
   *           // An error occurred, or we have reached the end of the file.
   *           // Either way we must exit the loop so we can call the handler.
   *           break;
   *         }
   *
   *         // Loop around to try calling sendfile again.
   *       }
   *     }
   *
   *     // Pass result back to user's handler.
   *     handler_(ec, total_bytes_transferred_);
   *   }
   * };
   *
   * template <typename Handler>
   * void async_sendfile(tcp::socket& sock, int fd, Handler h)
   * {
   *   sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
   *   sock.async_wait(tcp::socket::wait_write, op);
   * } @endcode
   */
  bool native_non_blocking() const
  {
    return impl_.get_service().native_non_blocking(impl_.get_implementation());
  }

  /// Sets the non-blocking mode of the native socket implementation.
  /**
   * This function is used to modify the non-blocking mode of the underlying
   * native socket. It has no effect on the behaviour of the socket object's
   * synchronous operations.
   *
   * @param mode If @c true, the underlying socket is put into non-blocking
   * mode and direct system calls may fail with boost::asio::error::would_block
   * (or the equivalent system error).
   *
   * @throws boost::system::system_error Thrown on failure. If the @c mode is
   * @c false, but the current value of @c non_blocking() is @c true, this
   * function fails with boost::asio::error::invalid_argument, as the
   * combination does not make sense.
   *
   * @par Example
   * This function is intended to allow the encapsulation of arbitrary
   * non-blocking system calls as asynchronous operations, in a way that is
   * transparent to the user of the socket object. The following example
   * illustrates how Linux's @c sendfile system call might be encapsulated:
   * @code template <typename Handler>
   * struct sendfile_op
   * {
   *   tcp::socket& sock_;
   *   int fd_;
   *   Handler handler_;
   *   off_t offset_;
   *   std::size_t total_bytes_transferred_;
   *
   *   // Function call operator meeting WriteHandler requirements.
   *   // Used as the handler for the async_write_some operation.
   *   void operator()(boost::system::error_code ec, std::size_t)
   *   {
   *     // Put the underlying socket into non-blocking mode.
   *     if (!ec)
   *       if (!sock_.native_non_blocking())
   *         sock_.native_non_blocking(true, ec);
   *
   *     if (!ec)
   *     {
   *       for (;;)
   *       {
   *         // Try the system call.
   *         errno = 0;
   *         int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
   *         ec = boost::system::error_code(n < 0 ? errno : 0,
   *             boost::asio::error::get_system_category());
   *         total_bytes_transferred_ += ec ? 0 : n;
   *
   *         // Retry operation immediately if interrupted by signal.
   *         if (ec == boost::asio::error::interrupted)
   *           continue;
   *
   *         // Check if we need to run the operation again.
   *         if (ec == boost::asio::error::would_block
   *             || ec == boost::asio::error::try_again)
   *         {
   *           // We have to wait for the socket to become ready again.
   *           sock_.async_wait(tcp::socket::wait_write, *this);
   *           return;
   *         }
   *
   *         if (ec || n == 0)
   *         {
   *           // An error occurred, or we have reached the end of the file.
   *           // Either way we must exit the loop so we can call the handler.
   *           break;
   *         }
   *
   *         // Loop around to try calling sendfile again.
   *       }
   *     }
   *
   *     // Pass result back to user's handler.
   *     handler_(ec, total_bytes_transferred_);
   *   }
   * };
   *
   * template <typename Handler>
   * void async_sendfile(tcp::socket& sock, int fd, Handler h)
   * {
   *   sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
   *   sock.async_wait(tcp::socket::wait_write, op);
   * } @endcode
   */
  void native_non_blocking(bool mode)
  {
    boost::system::error_code ec;
    impl_.get_service().native_non_blocking(
        impl_.get_implementation(), mode, ec);
    boost::asio::detail::throw_error(ec, ""native_non_blocking"");
  }

  /// Sets the non-blocking mode of the native socket implementation.
  /**
   * This function is used to modify the non-blocking mode of the underlying
   * native socket. It has no effect on the behaviour of the socket object's
   * synchronous operations.
   *
   * @param mode If @c true, the underlying socket is put into non-blocking
   * mode and direct system calls may fail with boost::asio::error::would_block
   * (or the equivalent system error).
   *
   * @param ec Set to indicate what error occurred, if any. If the @c mode is
   * @c false, but the current value of @c non_blocking() is @c true, this
   * function fails with boost::asio::error::invalid_argument, as the
   * combination does not make sense.
   *
   * @par Example
   * This function is intended to allow the encapsulation of arbitrary
   * non-blocking system calls as asynchronous operations, in a way that is
   * transparent to the user of the socket object. The following example
   * illustrates how Linux's @c sendfile system call might be encapsulated:
   * @code template <typename Handler>
   * struct sendfile_op
   * {
   *   tcp::socket& sock_;
   *   int fd_;
   *   Handler handler_;
   *   off_t offset_;
   *   std::size_t total_bytes_transferred_;
   *
   *   // Function call operator meeting WriteHandler requirements.
   *   // Used as the handler for the async_write_some operation.
   *   void operator()(boost::system::error_code ec, std::size_t)
   *   {
   *     // Put the underlying socket into non-blocking mode.
   *     if (!ec)
   *       if (!sock_.native_non_blocking())
   *         sock_.native_non_blocking(true, ec);
   *
   *     if (!ec)
   *     {
   *       for (;;)
   *       {
   *         // Try the system call.
   *         errno = 0;
   *         int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
   *         ec = boost::system::error_code(n < 0 ? errno : 0,
   *             boost::asio::error::get_system_category());
   *         total_bytes_transferred_ += ec ? 0 : n;
   *
   *         // Retry operation immediately if interrupted by signal.
   *         if (ec == boost::asio::error::interrupted)
   *           continue;
   *
   *         // Check if we need to run the operation again.
   *         if (ec == boost::asio::error::would_block
   *             || ec == boost::asio::error::try_again)
   *         {
   *           // We have to wait for the socket to become ready again.
   *           sock_.async_wait(tcp::socket::wait_write, *this);
   *           return;
   *         }
   *
   *         if (ec || n == 0)
   *         {
   *           // An error occurred, or we have reached the end of the file.
   *           // Either way we must exit the loop so we can call the handler.
   *           break;
   *         }
   *
   *         // Loop around to try calling sendfile again.
   *       }
   *     }
   *
   *     // Pass result back to user's handler.
   *     handler_(ec, total_bytes_transferred_);
   *   }
   * };
   *
   * template <typename Handler>
   * void async_sendfile(tcp::socket& sock, int fd, Handler h)
   * {
   *   sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
   *   sock.async_wait(tcp::socket::wait_write, op);
   * } @endcode
   */
  BOOST_ASIO_SYNC_OP_VOID native_non_blocking(
      bool mode, boost::system::error_code& ec)
  {
    impl_.get_service().native_non_blocking(
        impl_.get_implementation(), mode, ec);
    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
  }

  /// Get the local endpoint of the socket.
  /**
   * This function is used to obtain the locally bound endpoint of the socket.
   *
   * @returns An object that represents the local endpoint of the socket.
   *
   * @throws boost::system::system_error Thrown on failure.
   *
   * @par Example
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * ...
   * boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint();
   * @endcode
   */
  endpoint_type local_endpoint() const
  {
    boost::system::error_code ec;
    endpoint_type ep = impl_.get_service().local_endpoint(
        impl_.get_implementation(), ec);
    boost::asio::detail::throw_error(ec, ""local_endpoint"");
    return ep;
  }

  /// Get the local endpoint of the socket.
  /**
   * This function is used to obtain the locally bound endpoint of the socket.
   *
   * @param ec Set to indicate what error occurred, if any.
   *
   * @returns An object that represents the local endpoint of the socket.
   * Returns a default-constructed endpoint object if an error occurred.
   *
   * @par Example
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * ...
   * boost::system::error_code ec;
   * boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec);
   * if (ec)
   * {
   *   // An error occurred.
   * }
   * @endcode
   */
  endpoint_type local_endpoint(boost::system::error_code& ec) const
  {
    return impl_.get_service().local_endpoint(impl_.get_implementation(), ec);
  }

  /// Get the remote endpoint of the socket.
  /**
   * This function is used to obtain the remote endpoint of the socket.
   *
   * @returns An object that represents the remote endpoint of the socket.
   *
   * @throws boost::system::system_error Thrown on failure.
   *
   * @par Example
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * ...
   * boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();
   * @endcode
   */
  endpoint_type remote_endpoint() const
  {
    boost::system::error_code ec;
    endpoint_type ep = impl_.get_service().remote_endpoint(
        impl_.get_implementation(), ec);
    boost::asio::detail::throw_error(ec, ""remote_endpoint"");
    return ep;
  }

  /// Get the remote endpoint of the socket.
  /**
   * This function is used to obtain the remote endpoint of the socket.
   *
   * @param ec Set to indicate what error occurred, if any.
   *
   * @returns An object that represents the remote endpoint of the socket.
   * Returns a default-constructed endpoint object if an error occurred.
   *
   * @par Example
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * ...
   * boost::system::error_code ec;
   * boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec);
   * if (ec)
   * {
   *   // An error occurred.
   * }
   * @endcode
   */
  endpoint_type remote_endpoint(boost::system::error_code& ec) const
  {
    return impl_.get_service().remote_endpoint(impl_.get_implementation(), ec);
  }

  /// Disable sends or receives on the socket.
  /**
   * This function is used to disable send operations, receive operations, or
   * both.
   *
   * @param what Determines what types of operation will no longer be allowed.
   *
   * @throws boost::system::system_error Thrown on failure.
   *
   * @par Example
   * Shutting down the send side of the socket:
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * ...
   * socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send);
   * @endcode
   */
  void shutdown(shutdown_type what)
  {
    boost::system::error_code ec;
    impl_.get_service().shutdown(impl_.get_implementation(), what, ec);
    boost::asio::detail::throw_error(ec, ""shutdown"");
  }

  /// Disable sends or receives on the socket.
  /**
   * This function is used to disable send operations, receive operations, or
   * both.
   *
   * @param what Determines what types of operation will no longer be allowed.
   *
   * @param ec Set to indicate what error occurred, if any.
   *
   * @par Example
   * Shutting down the send side of the socket:
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * ...
   * boost::system::error_code ec;
   * socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send, ec);
   * if (ec)
   * {
   *   // An error occurred.
   * }
   * @endcode
   */
  BOOST_ASIO_SYNC_OP_VOID shutdown(shutdown_type what,
      boost::system::error_code& ec)
  {
    impl_.get_service().shutdown(impl_.get_implementation(), what, ec);
    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
  }

  /// Wait for the socket to become ready to read, ready to write, or to have
  /// pending error conditions.
  /**
   * This function is used to perform a blocking wait for a socket to enter
   * a ready to read, write or error condition state.
   *
   * @param w Specifies the desired socket state.
   *
   * @par Example
   * Waiting for a socket to become readable.
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * ...
   * socket.wait(boost::asio::ip::tcp::socket::wait_read);
   * @endcode
   */
  void wait(wait_type w)
  {
    boost::system::error_code ec;
    impl_.get_service().wait(impl_.get_implementation(), w, ec);
    boost::asio::detail::throw_error(ec, ""wait"");
  }

  /// Wait for the socket to become ready to read, ready to write, or to have
  /// pending error conditions.
  /**
   * This function is used to perform a blocking wait for a socket to enter
   * a ready to read, write or error condition state.
   *
   * @param w Specifies the desired socket state.
   *
   * @param ec Set to indicate what error occurred, if any.
   *
   * @par Example
   * Waiting for a socket to become readable.
   * @code
   * boost::asio::ip::tcp::socket socket(my_context);
   * ...
   * boost::system::error_code ec;
   * socket.wait(boost::asio::ip::tcp::socket::wait_read, ec);
   * @endcode
   */
  BOOST_ASIO_SYNC_OP_VOID wait(wait_type w, boost::system::error_code& ec)
  {
    impl_.get_service().wait(impl_.get_implementation(), w, ec);
    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
  }

  /// Asynchronously wait for the socket to become ready to read, ready to
  /// write, or to have pending error conditions.
  /**
   * This function is used to perform an asynchronous wait for a socket to enter
   * a ready to read, write or error condition state.
   *
   * @param w Specifies the desired socket state.
   *
   * @param handler The handler to be called when the wait operation completes.
   * Copies will be made of the handler as required. The function signature of
   * the handler must be:
   * @code void handler(
   *   const boost::system::error_code& error // Result of operation
   * ); @endcode
   * Regardless of whether the asynchronous operation completes immediately or
   * not, the handler will not be invoked from within this function. On
   * immediate completion, invocation of the handler will be performed in a
   * manner equivalent to using boost::asio::post().
   *
   * @par Example
   * @code
   * void wait_handler(const boost::system::error_code& error)
   * {
   *   if (!error)
   *   {
   *     // Wait succeeded.
   *   }
   * }
   *
   * ...
   *
   * boost::asio::ip::tcp::socket socket(my_context);
   * ...
   * socket.async_wait(boost::asio::ip::tcp::socket::wait_read, wait_handler);
   * @endcode
   */
  template <
      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
        WaitHandler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WaitHandler,
      void (boost::system::error_code))
  async_wait(wait_type w,
      BOOST_ASIO_MOVE_ARG(WaitHandler) handler
        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
  {
    return async_initiate<WaitHandler, void (boost::system::error_code)>(
        initiate_async_wait(this), handler, w);
  }

protected:
  /// Protected destructor to prevent deletion through this type.
  /**
   * This function destroys the socket, cancelling any outstanding asynchronous
   * operations associated with the socket as if by calling @c cancel.
   */
  ~basic_socket()
  {
  }

#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
  detail::io_object_impl<
    detail::null_socket_service<Protocol>, Executor> impl_;
#elif defined(BOOST_ASIO_HAS_IOCP)
  detail::io_object_impl<
    detail::win_iocp_socket_service<Protocol>, Executor> impl_;
#else
  detail::io_object_impl<
    detail::reactive_socket_service<Protocol>, Executor> impl_;
#endif

private:
  // Disallow copying and assignment.
  basic_socket(const basic_socket&) BOOST_ASIO_DELETED;
  basic_socket& operator=(const basic_socket&) BOOST_ASIO_DELETED;

  class initiate_async_connect
  {
  public:
    typedef Executor executor_type;

    explicit initiate_async_connect(basic_socket* self)
      : self_(self)
    {
    }

    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
    {
      return self_->get_executor();
    }

    template <typename ConnectHandler>
    void operator()(BOOST_ASIO_MOVE_ARG(ConnectHandler) handler,
        const endpoint_type& peer_endpoint,
        const boost::system::error_code& open_ec) const
    {
      // If you get an error on the following line it means that your handler
      // does not meet the documented type requirements for a ConnectHandler.
      BOOST_ASIO_CONNECT_HANDLER_CHECK(ConnectHandler, handler) type_check;

      if (open_ec)
      {
          boost::asio::post(self_->impl_.get_executor(),
              boost::asio::detail::bind_handler(
                BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler), open_ec));
      }
      else
      {
        detail::non_const_lvalue<ConnectHandler> handler2(handler);
        self_->impl_.get_service().async_connect(
            self_->impl_.get_implementation(), peer_endpoint,
            handler2.value, self_->impl_.get_implementation_executor());
      }
    }

  private:
    basic_socket* self_;
  };

  class initiate_async_wait
  {
  public:
    typedef Executor executor_type;

    explicit initiate_async_wait(basic_socket* self)
      : self_(self)
    {
    }

    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
    {
      return self_->get_executor();
    }

    template <typename WaitHandler>
    void operator()(BOOST_ASIO_MOVE_ARG(WaitHandler) handler, wait_type w) const
    {
      // If you get an error on the following line it means that your handler
      // does not meet the documented type requirements for a WaitHandler.
      BOOST_ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;

      detail::non_const_lvalue<WaitHandler> handler2(handler);
      self_->impl_.get_service().async_wait(
          self_->impl_.get_implementation(), w, handler2.value,
          self_->impl_.get_implementation_executor());
    }

  private:
    basic_socket* self_;
  };
};

} // namespace asio
} // namespace boost

#include <boost/asio/detail/pop_options.hpp>

#endif // BOOST_ASIO_BASIC_SOCKET_HPP
",16377,True,3388.969633851575,median
"= Groundbait Indicators of Compromise

== ESET detection names

- Win32/Agent.UIG trojan
- Win32/Agent.XOR trojan
- Win64/Agent.XOR trojan
- Win32/Agent.XQX trojan
- Win32/Agent.XRA trojan
- Win32/Agent.XRB trojan
- Win32/Agent.XRC trojan
- Win64/Agent.DX trojan
- Win32/TrojanDropper.Agent.RGH trojan
- Win32/TrojanDropper.Agent.RHN trojan
- Win32/Prikormka trojan
- Win64/Prikormka trojan
- MSIL/Prikormka trojan

== Host Based indicators

- `%PROGRAMFILES%\\IntelRestore\\`
- `%USERPROFILE%\\Resent\\roaming\\ocp8.1\\`
- `%USERPROFILE%\\AppData\\Local\\MMC\\`
- `%USERPROFILE%\\AppData\\Local\\PMG\\`
- `%USERPROFILE%\\AppData\\Local\\SKC\\`
- `%USERPROFILE%\\AppData\\Local\\CMS\\`
- `%USERPROFILE%\\AppData\\Local\\VRT\\`
- `%USERPROFILE%\\AppData\\Local\\ioctl\\`
- `%WINDIR%\\ntshrui.dll`
- `%WINDIR%\\hauthuid.dll`
- `%WINDIR%\\hlpuctf.dll`
- `%WINDIR%\\atiml.dll`
- `%WINDIR%\\iomus.dll`
- `%WINDIR%\\swma.dll`
- `%WINDIR%\\helpldr.dll`
- `%WINDIR%\\rbcon.ini`
- `%USERPROFILE%\\AppData\\Local\\CMS\\krman.ini`
- `%USERPROFILE%\\AppData\\Local\\VRT\\_wputproc.dll`

=== Mutexes

- `ZxWinDeffContexLNKINFO64`
- `Zw_&one@ldrContext43`
- `Paramore756Contex43`
- `ZxWinDeffContexSMD64`
- `ZxWinDeffContexWriteUSBIO64x`
- `ZxWinDeffContexRNDRV45scr`
- `ZxWinDeffContexRNDRV45snd`
- `ZxWinDeffContexSkSwmA`
- `ZxWinDeffContexKINP64`
- `ZxWinDeffContexRNDRV65`
- `ZxWinDeffContexRNDRV65new`
- `ZxWinDeffContexRNDRV65xyz`
- `ZxWinDeffContexRNDRV65xy`
- `ZxWinDeffContexRNDRV64`
- `Client67workProc98List3To`

== Network indicators

=== C&C servers

- `disk-fulldatabase.rhcloud.com` (IP addresses: `54.175.208.187`, `23.22.38.222`)
- `wallejob.in.ua` (IP: `185.68.16.35`)
- `wallex.ho.ua` (IP: `91.228.146.13`)
- `gils.ho.ua` (IP: `91.228.146.12`)
- `literat.ho.ua` (IP: `91.228.146.13`)
- `lefting.org` (IP: `91.228.146.11`)
- `celebrat.net` (IP: `91.228.146.11`)
- `bolepaund.com` (IP: `91.228.146.12`)

=== Servers used for sending spear phishing e-mail messages

- `server-eacloud.rhcloud.com` (IP addresses: `54.152.171.48`, `54.163.210.39`)
- `easerver-fulldatabase.rhcloud.com` (IP addresses: `52.23.164.7`, `23.22.221.237`)

== Samples

All hashes are SHA-1.

=== Prikormka droppers

----
42041871308B5711041B7AF69B78F45DF642546C
37F75844C0D0F7F80A699153AF131984D2CE2B6D
029F054A52FE93B0CD6C4D1D815A795EAE9CAAB4
66C143D7C33666903B174F4B94D609BE8791914D
60351035ECDEED071E3FB80AFFE08872A0B582C9
0296191B323900B2BC014E2ACB5E0614C679B682
1BF0E90027EF798727A4496B1928F1FA79146051
76CAE58E4DF4D029155BF2E44BA0F8075DC99020
C0FBE31F1E6E56E93932076BA55A5229E22B5C4A
CF09B0CD03C9D0553F0B82827C989D04F1A1FAF1
7C28B907E1053F825478A74FDC1090FBF71DD878
D7F35B66C554EE1076279DF54C4E931651A7A211
2B0FB236DDC0098ADDF051531912FC2601FFCCDC
EAB122E5857DF838469B5B00DA0A3BD06DF8DA05
00BCCEBB7614BA270CA2908EE5711F25D3740E7E
F908824DB35EFD589449D04E41F8BCEA057F6E52
A8CED2FF8F3D4B77160CB81843652D971469A30B
6002357FB96A786401BAA40A89A85DBA3A7D7AD4
E3E9CA2AC83CFADD80FECD002B377B6B41AC5250
EAFC458AAC3F1564E940BAC7D45C1E659636CC86
FCBC8C75246511F9E4D49FE501F956A857FACE84
803C48A93785581AA89422B6B1E73677BF8DC749
87C34623EBEC481FD430F6CE26849220C641742C
A1EE4E4BA27B4035F29FA6AB943AE072D42E65B8
19AAB5FAE0809F87EF27A18208A3C0C52DEA182A
C88218C2C23555D5E39596B2110BDA54A7AD50DB
EC16141D6C0399B74A26B7B572580B3AC4CBC811
76B77E40182DA242307272B9F77132ABB0B46515
7AB44936E5545C5778C697ABCC20FD8955E35F36
86DD049877B564158020AB9B1A6CA3C30371979D
8665C7A753BA5F619FE79D52DC49724F17D81DAC
8839ED42EC1440CBF30CC345F11B88450EA8FE46
4D2C8CD6C514202CBC133347E2C35F63F03A77BF
CDF0734730EA786AD2D3B0E9D0D82F85D3C4AD07
99345C5E6FC6901B630C044DD5C6A5015A94B046
93FE501BCDF62060798E35643B7E5F4E3FFF05A6
1287205FE5B83583CB28D39D965D182EA1DFCFDB
C0C4DB689F393A26611B7F8FE08F38B456A173DA
3F867CF4AE4B1232B08E40ADABE7BC21EF856FE2
E9A2B1611EDC105FBA65AFFCDAB062D6FA5C67B0
ADDF8193442D145C6BCB4C54B95A5CFE759C6436
CD5AA66AD7C8D418F19B486211591E31B5B74AB6
8A01C06DF6E59F1513146DFE07936E4ACA59B152
E35081B99C5445952AD4E204A4C42F06D7C3707D
A6D8431EFBA501864C4646A63071D28B30EEBF99
613F631D0E384954D2FEA5BE39124AD821C8E5D6
D45CECD9DDD79259C6518300ED77257A9ABBDF92
642033A50EF2C51E1F391D85ED870B09A308469A
FD95C6B33AF4B29EFBD26D388C50164C3167CB68
9A578C7C305BE62167EF87AB52E59A12F336186A
FE9F5018198567F3D3FB3AA09279C65DBE981171
62487DD8EC172462F9B4CBB790EF6F7878D20352
E397F1D784B4A9EEE7EEAC427C549A301DEC0C7C
E8A2734C3FFECB76DD4D1C28D646EE59188BE7BF
8DF79B2734BCD83B3D55FF99521D10E550DFCFF3
64D31BBCF8E224E06BB5F1B350D2F18BFDD78A8E
D5B785F8F92C7588CFAD7A1A21DAFFA6EB9CFA5C
8327A743756FA1B051725BF8EC3FDD9B9E844E9A
98440EC18A7E78925CB760F5016111115C89F1F8
6E56BC6023085D6E88668D1C66B91AB5AA92F294
160CF2ABB25495188A0ACB523BD201B0369CFFD2
6E5A098A3EDDEEC2E4986DE84FB00D7EA7EE26B8
8358EA16A0DE64994FBECE1AAC69E847F91BB1B3
3A6C8CB6688E2A56057BA9B3680E5911D96B2C8C
AB011CD03B3F211F43930AABD909B5611A829D9D
279711B6828B6CF642C0DAB4D16411C87956F566
2BF9CA8B16BCD679AFB6E9E53C3BB0B04E65044A
9551C390B2DF178DED895D531F440FDDBAE122AA
BB8D93A4049968C6D5A243DCFB65A6F4B4DE22A2
80CB14652E8251C79187DF8A01D29ABD46A3118C
6E24C2403DAFAE05C351C5A0A16E2B6403E0F398
09EA7B2F67797915BBFED16F0B21E4E31F4980A3
0AA48DEE8F528B037D8D72AAD039BB2759F362E3
40D7D09053BF60925CBB820417A42DBC6293E017
A6600BD9752E041ED7EE026123A60B19C96259AB
506CCEBDAC5754D1E20D9C3FB280CEC7782EEA6E
40F33CD2AD98FE1E6BF4AB199021498F9E3125A1
9F03A4E0ACD38635104292B8054485E6BF898C48
B373BF4B3AA28FF6D373DA5EAA848AF9772F6454
FD83C2484E2986F22B09623E5971AA54FBD8BCD3
065B075293968732F2BE433B7B492869E4260EE5
B358687593FEBDFD0E1858726098DCFD61D9F8B5
FD2FBB8E4676673A35276B46F2C74562703BCF39
CCD19FD4A1408FCD855B7909578340846904E707
9D84665C00F81C2835E2A41711A139547351D850
69536CAF0522C1A915D6AC4C65177A26EFA7944B
243421FE7C1FC007EFA0C9CCAB6F6E2A0C94FCC2
5B7D6D7C3C4AD74A7F1E32B780776DB41FF18DDD
4418A32BBD215F5DE7B0063B91731B71804E7225
EE1E5D95FCAD429126944804D80D7C2412AF492E
E494328255EF2B9ED9B332EE845513A93339217F
6B53A3A3CB9D87D5925C82839015DAD16042C2FF
----

=== Prikormka early versions

----
1B8BC6924F4CFC641032578622BA8C7B4A92F65E
B5F1B3BD6AD281C8EB9D633A37E0BE63B97A8BEB
BCEDAB81CC5F4D2EA1DA8A71F91DF6E16362723B
DC52EE62B94DC38790C3EF855CE5773E48D6CD55
44B6B8375CF788076C0DD64A93E27F69A01F5DFD
539033DE14539D485481549EF84C9E49D743FC4C
----

=== Prikormka *PERSISTENCE* modules

----
AD9A6F7BA895769844663B4936E776239D3A3D17
E1B5CD1978F6C6D72AA6B07ADD1EE83E9BB8480D
6E312A999EE7DCD9EC8EB4F0A216F50F50EB09F6
8F8BD3C4CE2F932ABFB31B9F586C40D1E22EE210
3F8D8B20B8FCC200939BBB92FB3B93BB3B4ECD24
756730D1C542B57792F68F0C3BC9BCDE149CF7C6
4F1441F16E80272F488BB114DB6508F0BB9B9E1B
2E1C7FFAB7B1047E3438E6BA920D0914F8CC4E35
3C9990B5D66F3AE9AD9A39A10AC6D291DD86A8F9
CC7091228C1B5A0DAF39ECDA570F75F122BE8A16
26FAEAAE2C042C0A416287A7C54D63D5B4C781B3
854F7CB3A436721F445E0D13FB3BEFF11BF4153D
0596EFE47D6C143BE21294EB4E631A4892A0651A
7DAE2A15E364EE06C9301236AE8FC140884CEA95
C2F720DEF2264F08E5211671D46E73311DC6C473
36215D9A691D826E6CEBC65925BFA6B579675158
0354A768508F6B9D88588641397B76A0CBB10BF2
1790B3D73A5DD676D17B39C01A079DEBD6D9F5C5
2F1E4AF1A5A95B3483E901ABDD96454C57419BA4
53174F09C4EDB68ED7D9028B86154B9C7F321A30
FCD81737FF261A84B9899CB713933AA795279364
----

=== Prikormka *DOWNLOADER* modules

----
D12CD6C4CA3388B68FCF3E46E206064CAA75F893
C2EA09D162BDAD2541C97D30A4E171F267305671
C10D6E4ADB3B29C968D7F3086C8E7005DD1E36F4
CE4605994E514086ADA5A767296DB66D7EA84175
148218ECDDE9ECC19B1343080884EB819783D9B2
5B256971F332498ACC833B36CBE9AD0CEC71384C
4A8452575FF69BDD0806AA8915E459E8ADC66DF1
04DFC621649511E1AB6CB800124DD5E2874A1629
D51863CBC1AC4BFC2B87F247DC75975E2A9CD992
C8AF6A8270CBD030F09C24888480AEF093ACCF48
EF127184967BE14A3719978E0236FFF5C0AF811B
2FF9E3AB4912A4AEA3C511D9355B8EDD13888E2A
40B163E8E74397E69F18805BD7DAB67F06D3D9E2
A8DFCD6CDB0755966F3D6766B94989CDAA0C35F9
6D4A80FE57D57B43DAF85401DFDD2CDA48D1F023
7844678942383F8116BAC656BC56D4B230FF62E8
8B9460431296DAF13BBE8D0F81EBFC19A84BB741
995EE9772DDDF2D6B4A55ACF26FA41F40786532D
ED7B147766C1370367D277F7BA7E354DBDDE5E09
37316B972F5C22D069764800475EED7CD3279802
1DF0B7239E48CF8E7391085BE5B835C892A5B3E8
0323D1C5D565627C32FF08780A59EB45D6C0C7C3
4673475BD3307FE8869ACA0402B861DDE5EC43AC
F38CFC487481D2B0167E5B76F06500BC312081B6
35159C96F695B96773C5C1DCF8206DBE75A83D86
----

=== Prikormka *CORE* modules

----
2A64606DB1DB872E7176F0C6C3FF932E2146BFC9
328DE44A4B6140EF49CE1465482EFE0E4C195399
520AA689066D0C69F6FD9C623E263211022CCF21
790367A2032951488FC6F56DCF12062AE56CAA61
551CD9D950A9C610E12451550BD6A3FBF5B00B77
EF3244AB1DF7D74F1FC1D8C3AF26A3D3EA4364A5
1636112D8441A6616B68CBE9DC32DDB5D836BBA1
8A57E5EED18A6DB6F221B1B9E8831FE4A9CAD08C
DCB813E5D2A1C63027AADC7197FD91505FD13380
A360EAC305946FF468E1A33E84ED38176D95CAC9
8F67C4BD2EE7C68249DCD49AD7A3924D3EC6810C
C020EFFD3C7AD06907ECFEA424BE1DCB60C7447D
D2A98115DF0C17648CCB653AF649D24B528B471D
D7EEB8DB22AAD913B38E695A470E8B2F1440D4D3
154AA820D552ABD65C028DED7E970C8DEFA8C237
83B492A2905CE6ACFADE43AB52BF52E6F02FDCD5
4F945A3B3EB058668C3DFC0A8469B42E16C277A7
963963004E4CA0D966D84324EC8ED3694F6A7F5B
9DE8860AD499E64F8BDCFC800DDAFF49D4F948E5
C9C2510654081D621A5B1768520D7D7C04219FCB
9D025A015FDB720C0FDEBCFE54661F3ACED94E3E
D09B6194453BFC59EB438E455D14621B280DF4A6
1A865E934EFF339A826979C70A2FC055E3C9D12F
4C5F412C915FB3F178A81BC4FBDA336F69A22086
7372639A9E5C274DFFAA35ABF4C8E7A0BEBD4305
311672ECB756E52AD396227DD884D1C47234961A
7A22E549BE02F7F4753BB9CBA34079CEB15CA381
6AB00FCABC6BC06586F749F54C4955592285608C
66248AE0A3D6B5091C629343CC535F98E08A2947
0DD8E1922CEB96061C9F6678728DD45CBDC6F675
A093993B9488A9427300B2AC41460BE8164A0F9A
6D861826206D834A224583898BE6AF1A3D46E7CF
64679BDB8A65D278CDA0975F279D8881E1ABD40A
92476C6AE5F976C58D11BDD956878451F361776D
202637EF3C9B236D62BE627C6E1A8C779EB2976B
C41BB97C203D6221FB494D732CB905FF37376622
986E739948E3B5C303F7766F9F9AF3D2E1A5BCA7
3AB61FEC417686AFC1AC430AAF5A17254D05A14A
0D7785E53AB1A7F43902AFF50E7A722C0E0B428F
B5EEAE045F1082438E4C7B7F12F7F4630043A48E
57E345893F508F390F2947E83092A47D845EA445
C9756E95679EAD052D53ADCFA39BB4B1402C9126
D864067BFA52383BC012BA1AAF8FFB893D419C07
CDD58347F873EB7E0BC602DA9930A519683C67C7
DFABE31E58334C873AEDD361D69D5C80016F9F42
625D822EE0D95C6E581B929C6C4E4B44D749D2BB
A224A76DABE62BD7CA055CA1119108AD5812AF06
E4C56D11E84497EEC3E275043E36845EB2F3F57E
B43713CBD307BC12AD7BA61C87975F74221A3439
AED9C3BCA2B42889A9110B92D3D31B5FD3324BDF
6AE2C768D932EDA538983DD7A50CF7DE14BF54D2
BE73A2C17AAE689BC1A20761850374636B67BF0F
80FFA899CB3A6595FAFA66421BCCD6E5AAAD8552
7C5F7296DDDA9B188B572DF348843F822BD6ED21
F9EB705D8A1EDC7FF9B93D9CF9211840C4482865
7979BEC789770860A6F12B7A7D41470DE4AFC873
6DF75137E8966537BB921EAB30DF4F7BC2C6FEB4
2115C50CAF8D1B365D78818DF84A8CE29F7FD9E8
AFDAD724A2C351C750DB43688D107B1300B1D1D4
64002D2C4C6678776C64BB018736C9B0745F47F4
7843CB7DE03C8B564FD72D923B4BD6D28A466A3C
EB4647CA60FEA9049A34EC59D9658946A2C26D9D
ED3D4EEF28174F60F1653F35000B871F6E023D21
860D0CDFC065E91083979DD50A72251C26A638A4
FC2C689C507FED54432AD1726E524B38F52B187A
D219640BA205A7013A23BA19CD6C2B32439F105E
DE60C2A81AE2F3E5DBD2B2D0DBEBDB56FED62F7C
D38FDAE48EABF2642F3327FAC865B079233CC7C6
B23995462751EDFAD19B72BEA4A047CC89533A59
88ED6686CF59F12AA984216EC60097C4BD319007
DEF9B207BFD7C6D4B216DF2B37C33CD851DC7FE1
8D49305FD140B179D2293FBAFF6E7CE46A03AF16
F35B1D2165EC00A56EE6DE89D09963DD3FD02744
B42234F5A5EFB6423E9D4904BA282127F1282C8E
326ADEA3AC1F8FAC3B522E6B47941263DA110A42
3E023A83EAA85A77B935B2D3A00AEB5B1ADCD9CC
129B852E62CB7BF487D5F37E17F6E3CC9A838DB8
F030559F81B8DC3CC0DED6C46C6D1BBB67A2CA65
3C904AFB938EFCF210F388E5AA46379AEADBCD50
D8921385ADAFF131C9D452A4D9BBA2C7D755880E
915F7F5471A94A6E095EE8D90FCFE84E7A5FE1D5
0DB71AA8B51FAACEA7D4C5819EC6AF9C342D02FD
A4847B06E603E90640051FCDD5D1515F007F7BD5
7C9E4CC3F5B260439D69E93376AA668BF32123D0
3246B5F43756DC8DC4438933005DF66A3C8CE25F
E97B383E3CF55D0792F22D57273C18848B849C6E
7C6FA82657B291FAFE423B7B45D0ED732F4D5352
4595EAB593594860985F5FB501B85386F1F1A5B8
45F1F06C3A27CE8329E2BDCDEEA3C530711B5B72
476DCA86DE7AF1F15327084021A3BB7F42818248
70A362985D5237ACD6282E16A238B0FDB1002A1F
73596D1587549DC234588FCB5666BEEFD7C90D81
97958B3124EC5DCAB64DD88A1E97E6B585B04628
B47640C4952ACC2705F7EAD9E8EAA163059FD659
596F945AB52AE0E780905E150ACD2017AB2ECDFC
5CEFFF9C7D016364D40F841CB74D65BB478BA0C6
424DD485FA8572DB84CF6845C27C1F8679A61AEC
099C5611F3BDBB8D453DFBF7967F30891906FF2C
7C2587B85178AD89389D957F11AF1065C46F66DB
840AFB728FDA57195E53F225CB3F6E788B96A579
12ACC64605D4FE2F3CEEEFBD0A7C4FD655E6AEAA
----

=== Prikormka *DOCS_STEALER* modules
----
BA434FB6169E8A1785E353EEBF9B907505759A07
A34BD2A059F57FB1FE281A2BD7247A9A72A467B8
04DEB60B6A1D53448EFFB34EA7C55E6916FE32B1
C75D8850273431A41F0EFCF8F74E86BCFE1DFA5A
7C9CB1619FFCF36B32273E1A78A58D817D2B7C8C
A580856FA6AC3159F0A7E91D5992810B953A36A1
5C82CA8B2E8320E6B6C071CCB0D4EF9B03001CAA
7275A6ED8EE314600A9B93038876F853B957B316
9286B96452C519D5E1E74D1CDDBDD76B51F4FBAA
FAB3B3371AA5878B6508DA487735E3A674A9F61B
0D4839F99C30AD76E082851A214A32116CE932A7
652B012E0ACACB78221CAA7A3C3EE461F07264EA
----

=== Prikormka *KEYLOGGER* modules

----
BFDCD0A3F7495C43D8D42B4272BDC90695DC44D7
CC42C6BEEB70D3A9BC7E1159C644E54DE2BE5CBC
6A4F24665569DD61FD29AF8FDCB3E2C90961DFF0
D1DA3076830813EC6FFF0B0DE3462BB5B713A090
E6D92C025CF726B08288B6798AEEFCF550D51C31
0B81BA761C6BA88C0AFC682693D99355E55F5A76
0CDC66ACBB5B7D6FAA85F7DF8D747A96CED7A9BD
194316ADC74AEDED98EE2696B4AB54900A6EDF15
45959818DBA4924E129E22CF1B0BDF02C2DD7B49
820EAC424FC27296FE725E1C5DAA8F6C53E104A7
25D6F1EFD758AACE399C6D62A89BE039281CFF69
722E1CDA3C516D43F17A6D4F5F1390D16113BC30
DE966273DD5AD4DAA01562109932EBD39A13A5A2
----

=== Prikormka *SCREENSHOTS* modules

----
645DFA35E41F6442793CF7647A75956E05563DE8
AD74ABEA34A20D0196A152E6668E3C29135B22D4
----

=== Prikormka *MICROPHONE* modules

----
FCE83DF7018A49072F9A28A8E135EB00C011D9EB
2C76974722287C7CDB0FCA2BC6CCEDEE62E77D24
----

=== Prikormka *SKYPE* modules

----
C3AA3DBD33751F85002F2F65562098F516737435
2A0EA9E0F3F8E6507D212640594ACF52910275E9
1BB3BBCA79BA45E4215DFC2A6960E03BA60A2B71
0CB528C69706A6513A0E70D3A07A75822F79E6EC
423BCEFC82A14258BDC2CD9740454D28F894DC06
FEAB6E92B905114980B5633F8742E4A7DCD0B4FA
BB6CE0957F7E8430007FA4DE1E47C190E1C97AC5
658DF9B4BB13459A9507466BB7D22B723C85D1C5
6C24E244A0DDA2CADED4D1B5CC8B820A46DC19F4
----

=== Prikormka *LOGS_ENCRYPTER* modules

----
D5C2C7C3D670D63AD6998848747A0418665EA2CB
352C36ED1BF7EB74C9649615F9A40C13D80EE55D
6740A385AB33B9CC3EC22FB7971F93538BE44997
22F10F17AB9F18D9BF1FE9EEEA413A9787B29D4C
E95458CA9663E4FAB94DD232121D5E994A76015D
2BD3FE012486BD89C87858CC4C3DC9D86742738C
----

=== Prikormka *GEOLOCATION* modules

----
50CCCD576A815AC8EFFB160A628646C876DF8CB0
----

=== Prikormka *OS_INFO* modules

----
4B8EE967F44ECA2EEB3B8420A858CECFE0231208
72C17994336FE4E1B3CF0D7A6CBC45AA43A8DDF0
824F0E198A8A6E08FB95920AEF06870A6305FE3F
6C902496AC1FEF60D343B03822F49DB5F66BE038
----

=== Prikormka *PASSWORDS* modules

----
B986114C5173052FCB9583A55D5099D99B709352
17F5E1FC52D6C617CD81B0983B70FAC7A60F528C
----

=== Prikormka *FILE_TREE* modules

----
3EDD14E6FA0297ED3162D7F119D8D126662ED28B
2A5AF8E43887051C1F1B488756AAC204B95561CE
4E40286676FCBAC48070BA86B72761A21AC2466C
3E4BE58421DBAEA7651DA13B16CB900DB82A7DEF
D1396938E981DD807103B7B9F9442B99952C21AA
74CDA4D4C776CA2A661AC49B6D0E0F0560380A04
8EFDC716FDFD704EC0296860E61AFF9C952946D4
93E196B59771647828BBC3C3B61831150FE1FE02
8384ED4EA9E299306F15A1082231C427A8742271
6E70BE32954E41FAFFC496EAF890B279832B4530
8EA98A8D3D8F62C4543B3DD36E6D6F79F1ACB9E7
----
",12478,True,4437.825150898154,median
"// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2018 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <script/interpreter.h>

#include <crypto/ripemd160.h>
#include <crypto/sha1.h>
#include <crypto/sha256.h>
#include <pubkey.h>
#include <script/script.h>
#include <uint256.h>

typedef std::vector<unsigned char> valtype;

namespace {

inline bool set_success(ScriptError* ret)
{
    if (ret)
        *ret = SCRIPT_ERR_OK;
    return true;
}

inline bool set_error(ScriptError* ret, const ScriptError serror)
{
    if (ret)
        *ret = serror;
    return false;
}

} // namespace

bool CastToBool(const valtype& vch)
{
    for (unsigned int i = 0; i < vch.size(); i++)
    {
        if (vch[i] != 0)
        {
            // Can be negative zero
            if (i == vch.size()-1 && vch[i] == 0x80)
                return false;
            return true;
        }
    }
    return false;
}

/**
 * Script is a stack machine (like Forth) that evaluates a predicate
 * returning a bool indicating valid or not.  There are no loops.
 */
#define stacktop(i)  (stack.at(stack.size()+(i)))
#define altstacktop(i)  (altstack.at(altstack.size()+(i)))
static inline void popstack(std::vector<valtype>& stack)
{
    if (stack.empty())
        throw std::runtime_error(""popstack(): stack empty"");
    stack.pop_back();
}

bool static IsCompressedOrUncompressedPubKey(const valtype &vchPubKey) {
    if (vchPubKey.size() < CPubKey::COMPRESSED_PUBLIC_KEY_SIZE) {
        //  Non-canonical public key: too short
        return false;
    }
    if (vchPubKey[0] == 0x04) {
        if (vchPubKey.size() != CPubKey::PUBLIC_KEY_SIZE) {
            //  Non-canonical public key: invalid length for uncompressed key
            return false;
        }
    } else if (vchPubKey[0] == 0x02 || vchPubKey[0] == 0x03) {
        if (vchPubKey.size() != CPubKey::COMPRESSED_PUBLIC_KEY_SIZE) {
            //  Non-canonical public key: invalid length for compressed key
            return false;
        }
    } else {
        //  Non-canonical public key: neither compressed nor uncompressed
        return false;
    }
    return true;
}

bool static IsCompressedPubKey(const valtype &vchPubKey) {
    if (vchPubKey.size() != CPubKey::COMPRESSED_PUBLIC_KEY_SIZE) {
        //  Non-canonical public key: invalid length for compressed key
        return false;
    }
    if (vchPubKey[0] != 0x02 && vchPubKey[0] != 0x03) {
        //  Non-canonical public key: invalid prefix for compressed key
        return false;
    }
    return true;
}

/**
 * A canonical signature exists of: <30> <total len> <02> <len R> <R> <02> <len S> <S> <hashtype>
 * Where R and S are not negative (their first byte has its highest bit not set), and not
 * excessively padded (do not start with a 0 byte, unless an otherwise negative number follows,
 * in which case a single 0 byte is necessary and even required).
 *
 * See https://bitcointalk.org/index.php?topic=8392.msg127623#msg127623
 *
 * This function is consensus-critical since BIP66.
 */
bool static IsValidSignatureEncoding(const std::vector<unsigned char> &sig) {
    // Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S] [sighash]
    // * total-length: 1-byte length descriptor of everything that follows,
    //   excluding the sighash byte.
    // * R-length: 1-byte length descriptor of the R value that follows.
    // * R: arbitrary-length big-endian encoded R value. It must use the shortest
    //   possible encoding for a positive integer (which means no null bytes at
    //   the start, except a single one when the next byte has its highest bit set).
    // * S-length: 1-byte length descriptor of the S value that follows.
    // * S: arbitrary-length big-endian encoded S value. The same rules apply.
    // * sighash: 1-byte value indicating what data is hashed (not part of the DER
    //   signature)

    // Minimum and maximum size constraints.
    if (sig.size() < 9) return false;
    if (sig.size() > 73) return false;

    // A signature is of type 0x30 (compound).
    if (sig[0] != 0x30) return false;

    // Make sure the length covers the entire signature.
    if (sig[1] != sig.size() - 3) return false;

    // Extract the length of the R element.
    unsigned int lenR = sig[3];

    // Make sure the length of the S element is still inside the signature.
    if (5 + lenR >= sig.size()) return false;

    // Extract the length of the S element.
    unsigned int lenS = sig[5 + lenR];

    // Verify that the length of the signature matches the sum of the length
    // of the elements.
    if ((size_t)(lenR + lenS + 7) != sig.size()) return false;

    // Check whether the R element is an integer.
    if (sig[2] != 0x02) return false;

    // Zero-length integers are not allowed for R.
    if (lenR == 0) return false;

    // Negative numbers are not allowed for R.
    if (sig[4] & 0x80) return false;

    // Null bytes at the start of R are not allowed, unless R would
    // otherwise be interpreted as a negative number.
    if (lenR > 1 && (sig[4] == 0x00) && !(sig[5] & 0x80)) return false;

    // Check whether the S element is an integer.
    if (sig[lenR + 4] != 0x02) return false;

    // Zero-length integers are not allowed for S.
    if (lenS == 0) return false;

    // Negative numbers are not allowed for S.
    if (sig[lenR + 6] & 0x80) return false;

    // Null bytes at the start of S are not allowed, unless S would otherwise be
    // interpreted as a negative number.
    if (lenS > 1 && (sig[lenR + 6] == 0x00) && !(sig[lenR + 7] & 0x80)) return false;

    return true;
}

bool static IsLowDERSignature(const valtype &vchSig, ScriptError* serror) {
    if (!IsValidSignatureEncoding(vchSig)) {
        return set_error(serror, SCRIPT_ERR_SIG_DER);
    }
    // https://bitcoin.stackexchange.com/a/12556:
    //     Also note that inside transaction signatures, an extra hashtype byte
    //     follows the actual signature data.
    std::vector<unsigned char> vchSigCopy(vchSig.begin(), vchSig.begin() + vchSig.size() - 1);
    // If the S value is above the order of the curve divided by two, its
    // complement modulo the order could have been used instead, which is
    // one byte shorter when encoded correctly.
    if (!CPubKey::CheckLowS(vchSigCopy)) {
        return set_error(serror, SCRIPT_ERR_SIG_HIGH_S);
    }
    return true;
}

bool static IsDefinedHashtypeSignature(const valtype &vchSig) {
    if (vchSig.size() == 0) {
        return false;
    }
    unsigned char nHashType = vchSig[vchSig.size() - 1] & (~(SIGHASH_ANYONECANPAY));
    if (nHashType < SIGHASH_ALL || nHashType > SIGHASH_SINGLE)
        return false;

    return true;
}

bool CheckSignatureEncoding(const std::vector<unsigned char> &vchSig, unsigned int flags, ScriptError* serror) {
    // Empty signature. Not strictly DER encoded, but allowed to provide a
    // compact way to provide an invalid signature for use with CHECK(MULTI)SIG
    if (vchSig.size() == 0) {
        return true;
    }
    if ((flags & (SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S | SCRIPT_VERIFY_STRICTENC)) != 0 && !IsValidSignatureEncoding(vchSig)) {
        return set_error(serror, SCRIPT_ERR_SIG_DER);
    } else if ((flags & SCRIPT_VERIFY_LOW_S) != 0 && !IsLowDERSignature(vchSig, serror)) {
        // serror is set
        return false;
    } else if ((flags & SCRIPT_VERIFY_STRICTENC) != 0 && !IsDefinedHashtypeSignature(vchSig)) {
        return set_error(serror, SCRIPT_ERR_SIG_HASHTYPE);
    }
    return true;
}

bool static CheckPubKeyEncoding(const valtype &vchPubKey, unsigned int flags, const SigVersion &sigversion, ScriptError* serror) {
    if ((flags & SCRIPT_VERIFY_STRICTENC) != 0 && !IsCompressedOrUncompressedPubKey(vchPubKey)) {
        return set_error(serror, SCRIPT_ERR_PUBKEYTYPE);
    }
    // Only compressed keys are accepted in segwit
    if ((flags & SCRIPT_VERIFY_WITNESS_PUBKEYTYPE) != 0 && sigversion == SigVersion::WITNESS_V0 && !IsCompressedPubKey(vchPubKey)) {
        return set_error(serror, SCRIPT_ERR_WITNESS_PUBKEYTYPE);
    }
    return true;
}

bool static CheckMinimalPush(const valtype& data, opcodetype opcode) {
    // Excludes OP_1NEGATE, OP_1-16 since they are by definition minimal
    assert(0 <= opcode && opcode <= OP_PUSHDATA4);
    if (data.size() == 0) {
        // Should have used OP_0.
        return opcode == OP_0;
    } else if (data.size() == 1 && data[0] >= 1 && data[0] <= 16) {
        // Should have used OP_1 .. OP_16.
        return false;
    } else if (data.size() == 1 && data[0] == 0x81) {
        // Should have used OP_1NEGATE.
        return false;
    } else if (data.size() <= 75) {
        // Must have used a direct push (opcode indicating number of bytes pushed + those bytes).
        return opcode == data.size();
    } else if (data.size() <= 255) {
        // Must have used OP_PUSHDATA.
        return opcode == OP_PUSHDATA1;
    } else if (data.size() <= 65535) {
        // Must have used OP_PUSHDATA2.
        return opcode == OP_PUSHDATA2;
    }
    return true;
}

int FindAndDelete(CScript& script, const CScript& b)
{
    int nFound = 0;
    if (b.empty())
        return nFound;
    CScript result;
    CScript::const_iterator pc = script.begin(), pc2 = script.begin(), end = script.end();
    opcodetype opcode;
    do
    {
        result.insert(result.end(), pc2, pc);
        while (static_cast<size_t>(end - pc) >= b.size() && std::equal(b.begin(), b.end(), pc))
        {
            pc = pc + b.size();
            ++nFound;
        }
        pc2 = pc;
    }
    while (script.GetOp(pc, opcode));

    if (nFound > 0) {
        result.insert(result.end(), pc2, end);
        script = std::move(result);
    }

    return nFound;
}

bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript& script, unsigned int flags, const BaseSignatureChecker& checker, SigVersion sigversion, ScriptError* serror)
{
    static const CScriptNum bnZero(0);
    static const CScriptNum bnOne(1);
    // static const CScriptNum bnFalse(0);
    // static const CScriptNum bnTrue(1);
    static const valtype vchFalse(0);
    // static const valtype vchZero(0);
    static const valtype vchTrue(1, 1);

    CScript::const_iterator pc = script.begin();
    CScript::const_iterator pend = script.end();
    CScript::const_iterator pbegincodehash = script.begin();
    opcodetype opcode;
    valtype vchPushValue;
    std::vector<bool> vfExec;
    std::vector<valtype> altstack;
    set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR);
    if (script.size() > MAX_SCRIPT_SIZE)
        return set_error(serror, SCRIPT_ERR_SCRIPT_SIZE);
    int nOpCount = 0;
    bool fRequireMinimal = (flags & SCRIPT_VERIFY_MINIMALDATA) != 0;

    try
    {
        while (pc < pend)
        {
            bool fExec = !count(vfExec.begin(), vfExec.end(), false);
            //
            // Read instruction
            //
            if (!script.GetOp(pc, opcode, vchPushValue))
                return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
            if (vchPushValue.size() > MAX_SCRIPT_ELEMENT_SIZE)
                return set_error(serror, SCRIPT_ERR_PUSH_SIZE);

            // Note how OP_RESERVED does not count towards the opcode limit.
            if (opcode > OP_16 && ++nOpCount > MAX_OPS_PER_SCRIPT)
                return set_error(serror, SCRIPT_ERR_OP_COUNT);

            if (opcode == OP_CAT ||
                opcode == OP_SUBSTR ||
                opcode == OP_LEFT ||
                opcode == OP_RIGHT ||
                opcode == OP_INVERT ||
                opcode == OP_AND ||
                opcode == OP_OR ||
                opcode == OP_XOR ||
                opcode == OP_2MUL ||
                opcode == OP_2DIV ||
                opcode == OP_MUL ||
                opcode == OP_DIV ||
                opcode == OP_MOD ||
                opcode == OP_LSHIFT ||
                opcode == OP_RSHIFT)
                return set_error(serror, SCRIPT_ERR_DISABLED_OPCODE); // Disabled opcodes.

            // With SCRIPT_VERIFY_CONST_SCRIPTCODE, OP_CODESEPARATOR in non-segwit script is rejected even in an unexecuted branch
            if (opcode == OP_CODESEPARATOR && sigversion == SigVersion::BASE && (flags & SCRIPT_VERIFY_CONST_SCRIPTCODE))
                return set_error(serror, SCRIPT_ERR_OP_CODESEPARATOR);

            if (fExec && 0 <= opcode && opcode <= OP_PUSHDATA4) {
                if (fRequireMinimal && !CheckMinimalPush(vchPushValue, opcode)) {
                    return set_error(serror, SCRIPT_ERR_MINIMALDATA);
                }
                stack.push_back(vchPushValue);
            } else if (fExec || (OP_IF <= opcode && opcode <= OP_ENDIF))
            switch (opcode)
            {
                //
                // Push value
                //
                case OP_1NEGATE:
                case OP_1:
                case OP_2:
                case OP_3:
                case OP_4:
                case OP_5:
                case OP_6:
                case OP_7:
                case OP_8:
                case OP_9:
                case OP_10:
                case OP_11:
                case OP_12:
                case OP_13:
                case OP_14:
                case OP_15:
                case OP_16:
                {
                    // ( -- value)
                    CScriptNum bn((int)opcode - (int)(OP_1 - 1));
                    stack.push_back(bn.getvch());
                    // The result of these opcodes should always be the minimal way to push the data
                    // they push, so no need for a CheckMinimalPush here.
                }
                break;


                //
                // Control
                //
                case OP_NOP:
                    break;

                case OP_CHECKLOCKTIMEVERIFY:
                {
                    if (!(flags & SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY)) {
                        // not enabled; treat as a NOP2
                        break;
                    }

                    if (stack.size() < 1)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);

                    // Note that elsewhere numeric opcodes are limited to
                    // operands in the range -2**31+1 to 2**31-1, however it is
                    // legal for opcodes to produce results exceeding that
                    // range. This limitation is implemented by CScriptNum's
                    // default 4-byte limit.
                    //
                    // If we kept to that limit we'd have a year 2038 problem,
                    // even though the nLockTime field in transactions
                    // themselves is uint32 which only becomes meaningless
                    // after the year 2106.
                    //
                    // Thus as a special case we tell CScriptNum to accept up
                    // to 5-byte bignums, which are good until 2**39-1, well
                    // beyond the 2**32-1 limit of the nLockTime field itself.
                    const CScriptNum nLockTime(stacktop(-1), fRequireMinimal, 5);

                    // In the rare event that the argument may be < 0 due to
                    // some arithmetic being done first, you can always use
                    // 0 MAX CHECKLOCKTIMEVERIFY.
                    if (nLockTime < 0)
                        return set_error(serror, SCRIPT_ERR_NEGATIVE_LOCKTIME);

                    // Actually compare the specified lock time with the transaction.
                    if (!checker.CheckLockTime(nLockTime))
                        return set_error(serror, SCRIPT_ERR_UNSATISFIED_LOCKTIME);

                    break;
                }

                case OP_CHECKSEQUENCEVERIFY:
                {
                    if (!(flags & SCRIPT_VERIFY_CHECKSEQUENCEVERIFY)) {
                        // not enabled; treat as a NOP3
                        break;
                    }

                    if (stack.size() < 1)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);

                    // nSequence, like nLockTime, is a 32-bit unsigned integer
                    // field. See the comment in CHECKLOCKTIMEVERIFY regarding
                    // 5-byte numeric operands.
                    const CScriptNum nSequence(stacktop(-1), fRequireMinimal, 5);

                    // In the rare event that the argument may be < 0 due to
                    // some arithmetic being done first, you can always use
                    // 0 MAX CHECKSEQUENCEVERIFY.
                    if (nSequence < 0)
                        return set_error(serror, SCRIPT_ERR_NEGATIVE_LOCKTIME);

                    // To provide for future soft-fork extensibility, if the
                    // operand has the disabled lock-time flag set,
                    // CHECKSEQUENCEVERIFY behaves as a NOP.
                    if ((nSequence & CTxIn::SEQUENCE_LOCKTIME_DISABLE_FLAG) != 0)
                        break;

                    // Compare the specified sequence number with the input.
                    if (!checker.CheckSequence(nSequence))
                        return set_error(serror, SCRIPT_ERR_UNSATISFIED_LOCKTIME);

                    break;
                }

                case OP_ISCOINSTAKE:
                {
                    //if (flags & SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS)
                    //    return set_error(serror, SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS);
                    opcodetype opbool = checker.IsCoinStake() ? OP_TRUE : OP_FALSE;
                    CScriptNum bn(opbool);
                    stack.push_back(bn.getvch());
                    break;
                }

                case OP_NOP1: case OP_NOP4: case OP_NOP5:
                case OP_NOP6: case OP_NOP7: case OP_NOP8:
                //case OP_NOP9:
                case OP_NOP10:
                {
                    if (flags & SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS)
                        return set_error(serror, SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS);
                }
                break;

                case OP_IF:
                case OP_NOTIF:
                {
                    // <expression> if [statements] [else [statements]] endif
                    bool fValue = false;
                    if (fExec)
                    {
                        if (stack.size() < 1)
                            return set_error(serror, SCRIPT_ERR_UNBALANCED_CONDITIONAL);
                        valtype& vch = stacktop(-1);
                        if (sigversion == SigVersion::WITNESS_V0 && (flags & SCRIPT_VERIFY_MINIMALIF)) {
                            if (vch.size() > 1)
                                return set_error(serror, SCRIPT_ERR_MINIMALIF);
                            if (vch.size() == 1 && vch[0] != 1)
                                return set_error(serror, SCRIPT_ERR_MINIMALIF);
                        }
                        fValue = CastToBool(vch);
                        if (opcode == OP_NOTIF)
                            fValue = !fValue;
                        popstack(stack);
                    }
                    vfExec.push_back(fValue);
                }
                break;

                case OP_ELSE:
                {
                    if (vfExec.empty())
                        return set_error(serror, SCRIPT_ERR_UNBALANCED_CONDITIONAL);
                    vfExec.back() = !vfExec.back();
                }
                break;

                case OP_ENDIF:
                {
                    if (vfExec.empty())
                        return set_error(serror, SCRIPT_ERR_UNBALANCED_CONDITIONAL);
                    vfExec.pop_back();
                }
                break;

                case OP_VERIFY:
                {
                    // (true -- ) or
                    // (false -- false) and return
                    if (stack.size() < 1)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    bool fValue = CastToBool(stacktop(-1));
                    if (fValue)
                        popstack(stack);
                    else
                        return set_error(serror, SCRIPT_ERR_VERIFY);
                }
                break;

                case OP_RETURN:
                {
                    return set_error(serror, SCRIPT_ERR_OP_RETURN);
                }
                break;

                //
                // Stack ops
                //
                case OP_TOALTSTACK:
                {
                    if (stack.size() < 1)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    altstack.push_back(stacktop(-1));
                    popstack(stack);
                }
                break;

                case OP_FROMALTSTACK:
                {
                    if (altstack.size() < 1)
                        return set_error(serror, SCRIPT_ERR_INVALID_ALTSTACK_OPERATION);
                    stack.push_back(altstacktop(-1));
                    popstack(altstack);
                }
                break;

                case OP_2DROP:
                {
                    // (x1 x2 -- )
                    if (stack.size() < 2)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    popstack(stack);
                    popstack(stack);
                }
                break;

                case OP_2DUP:
                {
                    // (x1 x2 -- x1 x2 x1 x2)
                    if (stack.size() < 2)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    valtype vch1 = stacktop(-2);
                    valtype vch2 = stacktop(-1);
                    stack.push_back(vch1);
                    stack.push_back(vch2);
                }
                break;

                case OP_3DUP:
                {
                    // (x1 x2 x3 -- x1 x2 x3 x1 x2 x3)
                    if (stack.size() < 3)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    valtype vch1 = stacktop(-3);
                    valtype vch2 = stacktop(-2);
                    valtype vch3 = stacktop(-1);
                    stack.push_back(vch1);
                    stack.push_back(vch2);
                    stack.push_back(vch3);
                }
                break;

                case OP_2OVER:
                {
                    // (x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2)
                    if (stack.size() < 4)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    valtype vch1 = stacktop(-4);
                    valtype vch2 = stacktop(-3);
                    stack.push_back(vch1);
                    stack.push_back(vch2);
                }
                break;

                case OP_2ROT:
                {
                    // (x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2)
                    if (stack.size() < 6)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    valtype vch1 = stacktop(-6);
                    valtype vch2 = stacktop(-5);
                    stack.erase(stack.end()-6, stack.end()-4);
                    stack.push_back(vch1);
                    stack.push_back(vch2);
                }
                break;

                case OP_2SWAP:
                {
                    // (x1 x2 x3 x4 -- x3 x4 x1 x2)
                    if (stack.size() < 4)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    swap(stacktop(-4), stacktop(-2));
                    swap(stacktop(-3), stacktop(-1));
                }
                break;

                case OP_IFDUP:
                {
                    // (x - 0 | x x)
                    if (stack.size() < 1)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    valtype vch = stacktop(-1);
                    if (CastToBool(vch))
                        stack.push_back(vch);
                }
                break;

                case OP_DEPTH:
                {
                    // -- stacksize
                    CScriptNum bn(stack.size());
                    stack.push_back(bn.getvch());
                }
                break;

                case OP_DROP:
                {
                    // (x -- )
                    if (stack.size() < 1)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    popstack(stack);
                }
                break;

                case OP_DUP:
                {
                    // (x -- x x)
                    if (stack.size() < 1)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    valtype vch = stacktop(-1);
                    stack.push_back(vch);
                }
                break;

                case OP_NIP:
                {
                    // (x1 x2 -- x2)
                    if (stack.size() < 2)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    stack.erase(stack.end() - 2);
                }
                break;

                case OP_OVER:
                {
                    // (x1 x2 -- x1 x2 x1)
                    if (stack.size() < 2)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    valtype vch = stacktop(-2);
                    stack.push_back(vch);
                }
                break;

                case OP_PICK:
                case OP_ROLL:
                {
                    // (xn ... x2 x1 x0 n - xn ... x2 x1 x0 xn)
                    // (xn ... x2 x1 x0 n - ... x2 x1 x0 xn)
                    if (stack.size() < 2)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    int n = CScriptNum(stacktop(-1), fRequireMinimal).getint();
                    popstack(stack);
                    if (n < 0 || n >= (int)stack.size())
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    valtype vch = stacktop(-n-1);
                    if (opcode == OP_ROLL)
                        stack.erase(stack.end()-n-1);
                    stack.push_back(vch);
                }
                break;

                case OP_ROT:
                {
                    // (x1 x2 x3 -- x2 x3 x1)
                    //  x2 x1 x3  after first swap
                    //  x2 x3 x1  after second swap
                    if (stack.size() < 3)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    swap(stacktop(-3), stacktop(-2));
                    swap(stacktop(-2), stacktop(-1));
                }
                break;

                case OP_SWAP:
                {
                    // (x1 x2 -- x2 x1)
                    if (stack.size() < 2)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    swap(stacktop(-2), stacktop(-1));
                }
                break;

                case OP_TUCK:
                {
                    // (x1 x2 -- x2 x1 x2)
                    if (stack.size() < 2)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    valtype vch = stacktop(-1);
                    stack.insert(stack.end()-2, vch);
                }
                break;


                case OP_SIZE:
                {
                    // (in -- in size)
                    if (stack.size() < 1)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    CScriptNum bn(stacktop(-1).size());
                    stack.push_back(bn.getvch());
                }
                break;


                //
                // Bitwise logic
                //
                case OP_EQUAL:
                case OP_EQUALVERIFY:
                //case OP_NOTEQUAL: // use OP_NUMNOTEQUAL
                {
                    // (x1 x2 - bool)
                    if (stack.size() < 2)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    valtype& vch1 = stacktop(-2);
                    valtype& vch2 = stacktop(-1);

                    bool fEqual = (vch1 == vch2);
                    // OP_NOTEQUAL is disabled because it would be too easy to say
                    // something like n != 1 and have some wiseguy pass in 1 with extra
                    // zero bytes after it (numerically, 0x01 == 0x0001 == 0x000001)
                    //if (opcode == OP_NOTEQUAL)
                    //    fEqual = !fEqual;
                    popstack(stack);
                    popstack(stack);
                    stack.push_back(fEqual ? vchTrue : vchFalse);
                    if (opcode == OP_EQUALVERIFY)
                    {
                        if (fEqual)
                            popstack(stack);
                        else
                            return set_error(serror, SCRIPT_ERR_EQUALVERIFY);
                    }
                }
                break;

                //
                // Numeric
                //
                case OP_1ADD:
                case OP_1SUB:
                case OP_NEGATE:
                case OP_ABS:
                case OP_NOT:
                case OP_0NOTEQUAL:
                {
                    // (in -- out)
                    if (stack.size() < 1)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    CScriptNum bn(stacktop(-1), fRequireMinimal);
                    switch (opcode)
                    {
                    case OP_1ADD:       bn += bnOne; break;
                    case OP_1SUB:       bn -= bnOne; break;
                    case OP_NEGATE:     bn = -bn; break;
                    case OP_ABS:        if (bn < bnZero) bn = -bn; break;
                    case OP_NOT:        bn = (bn == bnZero); break;
                    case OP_0NOTEQUAL:  bn = (bn != bnZero); break;
                    default:            assert(!""invalid opcode""); break;
                    }
                    popstack(stack);
                    stack.push_back(bn.getvch());
                }
                break;

                case OP_ADD:
                case OP_SUB:
                case OP_BOOLAND:
                case OP_BOOLOR:
                case OP_NUMEQUAL:
                case OP_NUMEQUALVERIFY:
                case OP_NUMNOTEQUAL:
                case OP_LESSTHAN:
                case OP_GREATERTHAN:
                case OP_LESSTHANOREQUAL:
                case OP_GREATERTHANOREQUAL:
                case OP_MIN:
                case OP_MAX:
                {
                    // (x1 x2 -- out)
                    if (stack.size() < 2)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    CScriptNum bn1(stacktop(-2), fRequireMinimal);
                    CScriptNum bn2(stacktop(-1), fRequireMinimal);
                    CScriptNum bn(0);
                    switch (opcode)
                    {
                    case OP_ADD:
                        bn = bn1 + bn2;
                        break;

                    case OP_SUB:
                        bn = bn1 - bn2;
                        break;

                    case OP_BOOLAND:             bn = (bn1 != bnZero && bn2 != bnZero); break;
                    case OP_BOOLOR:              bn = (bn1 != bnZero || bn2 != bnZero); break;
                    case OP_NUMEQUAL:            bn = (bn1 == bn2); break;
                    case OP_NUMEQUALVERIFY:      bn = (bn1 == bn2); break;
                    case OP_NUMNOTEQUAL:         bn = (bn1 != bn2); break;
                    case OP_LESSTHAN:            bn = (bn1 < bn2); break;
                    case OP_GREATERTHAN:         bn = (bn1 > bn2); break;
                    case OP_LESSTHANOREQUAL:     bn = (bn1 <= bn2); break;
                    case OP_GREATERTHANOREQUAL:  bn = (bn1 >= bn2); break;
                    case OP_MIN:                 bn = (bn1 < bn2 ? bn1 : bn2); break;
                    case OP_MAX:                 bn = (bn1 > bn2 ? bn1 : bn2); break;
                    default:                     assert(!""invalid opcode""); break;
                    }
                    popstack(stack);
                    popstack(stack);
                    stack.push_back(bn.getvch());

                    if (opcode == OP_NUMEQUALVERIFY)
                    {
                        if (CastToBool(stacktop(-1)))
                            popstack(stack);
                        else
                            return set_error(serror, SCRIPT_ERR_NUMEQUALVERIFY);
                    }
                }
                break;

                case OP_WITHIN:
                {
                    // (x min max -- out)
                    if (stack.size() < 3)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    CScriptNum bn1(stacktop(-3), fRequireMinimal);
                    CScriptNum bn2(stacktop(-2), fRequireMinimal);
                    CScriptNum bn3(stacktop(-1), fRequireMinimal);
                    bool fValue = (bn2 <= bn1 && bn1 < bn3);
                    popstack(stack);
                    popstack(stack);
                    popstack(stack);
                    stack.push_back(fValue ? vchTrue : vchFalse);
                }
                break;


                //
                // Crypto
                //
                case OP_RIPEMD160:
                case OP_SHA1:
                case OP_SHA256:
                case OP_HASH160:
                case OP_HASH256:
                {
                    // (in -- hash)
                    if (stack.size() < 1)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    valtype& vch = stacktop(-1);
                    valtype vchHash((opcode == OP_RIPEMD160 || opcode == OP_SHA1 || opcode == OP_HASH160) ? 20 : 32);
                    if (opcode == OP_RIPEMD160)
                        CRIPEMD160().Write(vch.data(), vch.size()).Finalize(vchHash.data());
                    else if (opcode == OP_SHA1)
                        CSHA1().Write(vch.data(), vch.size()).Finalize(vchHash.data());
                    else if (opcode == OP_SHA256)
                        CSHA256().Write(vch.data(), vch.size()).Finalize(vchHash.data());
                    else if (opcode == OP_HASH160)
                        CHash160().Write(vch.data(), vch.size()).Finalize(vchHash.data());
                    else if (opcode == OP_HASH256)
                        CHash256().Write(vch.data(), vch.size()).Finalize(vchHash.data());
                    popstack(stack);
                    stack.push_back(vchHash);
                }
                break;

                case OP_CODESEPARATOR:
                {
                    // If SCRIPT_VERIFY_CONST_SCRIPTCODE flag is set, use of OP_CODESEPARATOR is rejected in pre-segwit
                    // script, even in an unexecuted branch (this is checked above the opcode case statement).

                    // Hash starts after the code separator
                    pbegincodehash = pc;
                }
                break;

                case OP_CHECKSIG:
                case OP_CHECKSIGVERIFY:
                {
                    // (sig pubkey -- bool)
                    if (stack.size() < 2)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);

                    valtype& vchSig    = stacktop(-2);
                    valtype& vchPubKey = stacktop(-1);

                    // Subset of script starting at the most recent codeseparator
                    CScript scriptCode(pbegincodehash, pend);

                    // Drop the signature in pre-segwit scripts but not segwit scripts
                    if (sigversion == SigVersion::BASE) {
                        int found = FindAndDelete(scriptCode, CScript(vchSig));
                        if (found > 0 && (flags & SCRIPT_VERIFY_CONST_SCRIPTCODE))
                            return set_error(serror, SCRIPT_ERR_SIG_FINDANDDELETE);
                    }

                    if (!CheckSignatureEncoding(vchSig, flags, serror) || !CheckPubKeyEncoding(vchPubKey, flags, sigversion, serror)) {
                        //serror is set
                        return false;
                    }

                    bool fSuccess = checker.CheckSig(vchSig, vchPubKey, scriptCode, sigversion);

                    if (!fSuccess && (flags & SCRIPT_VERIFY_NULLFAIL) && vchSig.size())
                        return set_error(serror, SCRIPT_ERR_SIG_NULLFAIL);

                    popstack(stack);
                    popstack(stack);
                    stack.push_back(fSuccess ? vchTrue : vchFalse);
                    if (opcode == OP_CHECKSIGVERIFY)
                    {
                        if (fSuccess)
                            popstack(stack);
                        else
                            return set_error(serror, SCRIPT_ERR_CHECKSIGVERIFY);
                    }
                }
                break;

                case OP_CHECKMULTISIG:
                case OP_CHECKMULTISIGVERIFY:
                {
                    // ([sig ...] num_of_signatures [pubkey ...] num_of_pubkeys -- bool)

                    int i = 1;
                    if ((int)stack.size() < i)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);

                    int nKeysCount = CScriptNum(stacktop(-i), fRequireMinimal).getint();
                    if (nKeysCount < 0 || nKeysCount > MAX_PUBKEYS_PER_MULTISIG)
                        return set_error(serror, SCRIPT_ERR_PUBKEY_COUNT);
                    nOpCount += nKeysCount;
                    if (nOpCount > MAX_OPS_PER_SCRIPT)
                        return set_error(serror, SCRIPT_ERR_OP_COUNT);
                    int ikey = ++i;
                    // ikey2 is the position of last non-signature item in the stack. Top stack item = 1.
                    // With SCRIPT_VERIFY_NULLFAIL, this is used for cleanup if operation fails.
                    int ikey2 = nKeysCount + 2;
                    i += nKeysCount;
                    if ((int)stack.size() < i)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);

                    int nSigsCount = CScriptNum(stacktop(-i), fRequireMinimal).getint();
                    if (nSigsCount < 0 || nSigsCount > nKeysCount)
                        return set_error(serror, SCRIPT_ERR_SIG_COUNT);
                    int isig = ++i;
                    i += nSigsCount;
                    if ((int)stack.size() < i)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);

                    // Subset of script starting at the most recent codeseparator
                    CScript scriptCode(pbegincodehash, pend);

                    // Drop the signature in pre-segwit scripts but not segwit scripts
                    for (int k = 0; k < nSigsCount; k++)
                    {
                        valtype& vchSig = stacktop(-isig-k);
                        if (sigversion == SigVersion::BASE) {
                            int found = FindAndDelete(scriptCode, CScript(vchSig));
                            if (found > 0 && (flags & SCRIPT_VERIFY_CONST_SCRIPTCODE))
                                return set_error(serror, SCRIPT_ERR_SIG_FINDANDDELETE);
                        }
                    }

                    bool fSuccess = true;
                    while (fSuccess && nSigsCount > 0)
                    {
                        valtype& vchSig    = stacktop(-isig);
                        valtype& vchPubKey = stacktop(-ikey);

                        // Note how this makes the exact order of pubkey/signature evaluation
                        // distinguishable by CHECKMULTISIG NOT if the STRICTENC flag is set.
                        // See the script_(in)valid tests for details.
                        if (!CheckSignatureEncoding(vchSig, flags, serror) || !CheckPubKeyEncoding(vchPubKey, flags, sigversion, serror)) {
                            // serror is set
                            return false;
                        }

                        // Check signature
                        bool fOk = checker.CheckSig(vchSig, vchPubKey, scriptCode, sigversion);

                        if (fOk) {
                            isig++;
                            nSigsCount--;
                        }
                        ikey++;
                        nKeysCount--;

                        // If there are more signatures left than keys left,
                        // then too many signatures have failed. Exit early,
                        // without checking any further signatures.
                        if (nSigsCount > nKeysCount)
                            fSuccess = false;
                    }

                    // Clean up stack of actual arguments
                    while (i-- > 1) {
                        // If the operation failed, we require that all signatures must be empty vector
                        if (!fSuccess && (flags & SCRIPT_VERIFY_NULLFAIL) && !ikey2 && stacktop(-1).size())
                            return set_error(serror, SCRIPT_ERR_SIG_NULLFAIL);
                        if (ikey2 > 0)
                            ikey2--;
                        popstack(stack);
                    }

                    // A bug causes CHECKMULTISIG to consume one extra argument
                    // whose contents were not checked in any way.
                    //
                    // Unfortunately this is a potential source of mutability,
                    // so optionally verify it is exactly equal to zero prior
                    // to removing it from the stack.
                    if (stack.size() < 1)
                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
                    if ((flags & SCRIPT_VERIFY_NULLDUMMY) && stacktop(-1).size())
                        return set_error(serror, SCRIPT_ERR_SIG_NULLDUMMY);
                    popstack(stack);

                    stack.push_back(fSuccess ? vchTrue : vchFalse);

                    if (opcode == OP_CHECKMULTISIGVERIFY)
                    {
                        if (fSuccess)
                            popstack(stack);
                        else
                            return set_error(serror, SCRIPT_ERR_CHECKMULTISIGVERIFY);
                    }
                }
                break;

                default:
                    return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
            }

            // Size limits
            if (stack.size() + altstack.size() > MAX_STACK_SIZE)
                return set_error(serror, SCRIPT_ERR_STACK_SIZE);
        }
    }
    catch (...)
    {
        return set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR);
    }

    if (!vfExec.empty())
        return set_error(serror, SCRIPT_ERR_UNBALANCED_CONDITIONAL);

    return set_success(serror);
}

namespace {

/**
 * Wrapper that serializes like CTransaction, but with the modifications
 *  required for the signature hash done in-place
 */
template <class T>
class CTransactionSignatureSerializer
{
private:
    const T& txTo;             //!< reference to the spending transaction (the one being serialized)
    const CScript& scriptCode; //!< output script being consumed
    const unsigned int nIn;    //!< input index of txTo being signed
    const bool fAnyoneCanPay;  //!< whether the hashtype has the SIGHASH_ANYONECANPAY flag set
    const bool fHashSingle;    //!< whether the hashtype is SIGHASH_SINGLE
    const bool fHashNone;      //!< whether the hashtype is SIGHASH_NONE

public:
    CTransactionSignatureSerializer(const T& txToIn, const CScript& scriptCodeIn, unsigned int nInIn, int nHashTypeIn) :
        txTo(txToIn), scriptCode(scriptCodeIn), nIn(nInIn),
        fAnyoneCanPay(!!(nHashTypeIn & SIGHASH_ANYONECANPAY)),
        fHashSingle((nHashTypeIn & 0x1f) == SIGHASH_SINGLE),
        fHashNone((nHashTypeIn & 0x1f) == SIGHASH_NONE) {}

    /** Serialize the passed scriptCode, skipping OP_CODESEPARATORs */
    template<typename S>
    void SerializeScriptCode(S &s) const {
        CScript::const_iterator it = scriptCode.begin();
        CScript::const_iterator itBegin = it;
        opcodetype opcode;
        unsigned int nCodeSeparators = 0;
        while (scriptCode.GetOp(it, opcode)) {
            if (opcode == OP_CODESEPARATOR)
                nCodeSeparators++;
        }
        ::WriteCompactSize(s, scriptCode.size() - nCodeSeparators);
        it = itBegin;
        while (scriptCode.GetOp(it, opcode)) {
            if (opcode == OP_CODESEPARATOR) {
                s.write((char*)&itBegin[0], it-itBegin-1);
                itBegin = it;
            }
        }
        if (itBegin != scriptCode.end())
            s.write((char*)&itBegin[0], it-itBegin);
    }

    /** Serialize an input of txTo */
    template<typename S>
    void SerializeInput(S &s, unsigned int nInput) const {
        // In case of SIGHASH_ANYONECANPAY, only the input being signed is serialized
        if (fAnyoneCanPay)
            nInput = nIn;
        // Serialize the prevout
        ::Serialize(s, txTo.vin[nInput].prevout);
        // Serialize the script
        if (nInput != nIn)
            // Blank out other inputs' signatures
            ::Serialize(s, CScript());
        else
            SerializeScriptCode(s);
        // Serialize the nSequence
        if (nInput != nIn && (fHashSingle || fHashNone))
            // let the others update at will
            ::Serialize(s, (int)0);
        else
            ::Serialize(s, txTo.vin[nInput].nSequence);
    }

    /** Serialize an output of txTo */
    template<typename S>
    void SerializeOutput(S &s, unsigned int nOutput) const {
        if (fHashSingle && nOutput != nIn)
            // Do not lock-in the txout payee at other indices as txin
            ::Serialize(s, CTxOut());
        else
        {
            if (txTo.IsRubixVersion())
                ::Serialize(s, *(txTo.vpout[nOutput].get()));
            else
                ::Serialize(s, txTo.vout[nOutput]);
        }
    }

    /** Serialize txTo */
    template<typename S>
    void Serialize(S &s) const {
        // Serialize nVersion
        ::Serialize(s, txTo.nVersion);
        // Serialize vin
        unsigned int nInputs = fAnyoneCanPay ? 1 : txTo.vin.size();
        ::WriteCompactSize(s, nInputs);
        for (unsigned int nInput = 0; nInput < nInputs; nInput++)
             SerializeInput(s, nInput);

        // Serialize vpout
        unsigned int nOutputs = fHashNone ? 0 : (fHashSingle ? nIn+1 : txTo.GetNumVOuts());
        ::WriteCompactSize(s, nOutputs);
        for (unsigned int nOutput = 0; nOutput < nOutputs; nOutput++)
             SerializeOutput(s, nOutput);
        // Serialize nLockTime
        ::Serialize(s, txTo.nLockTime);
    }
};

template <class T>
uint256 GetPrevoutHash(const T& txTo)
{
    CHashWriter ss(SER_GETHASH, 0);
    for (const auto& txin : txTo.vin) {
        ss << txin.prevout;
    }
    return ss.GetHash();
}

template <class T>
uint256 GetSequenceHash(const T& txTo)
{
    CHashWriter ss(SER_GETHASH, 0);
    for (const auto& txin : txTo.vin) {
        ss << txin.nSequence;
    }
    return ss.GetHash();
}

template <class T>
uint256 GetOutputsHash(const T& txTo)
{
    CHashWriter ss(SER_GETHASH, 0);

    if (txTo.IsRubixVersion())
    {
        for (unsigned int n = 0; n < txTo.vpout.size(); n++)
            ss << *txTo.vpout[n];
    } else
    {
        for (const auto& txout : txTo.vout) {
            ss << txout;
        }
    }
    return ss.GetHash();
}

} // namespace

template <class T>
PrecomputedTransactionData::PrecomputedTransactionData(const T& txTo)
{
    // Cache is calculated only for transactions with witness
    if (txTo.HasWitness()) {
        hashPrevouts = GetPrevoutHash(txTo);
        hashSequence = GetSequenceHash(txTo);
        hashOutputs = GetOutputsHash(txTo);
        ready = true;
    }
}

// explicit instantiation
template PrecomputedTransactionData::PrecomputedTransactionData(const CTransaction& txTo);
template PrecomputedTransactionData::PrecomputedTransactionData(const CMutableTransaction& txTo);

template <class T>
uint256 SignatureHash(const CScript& scriptCode, const T& txTo, unsigned int nIn, int nHashType, const std::vector<uint8_t>& amount, SigVersion sigversion, const PrecomputedTransactionData* cache)
{
    assert(nIn < txTo.vin.size());

    if (sigversion == SigVersion::WITNESS_V0
        || txTo.IsRubixVersion()) {
        uint256 hashPrevouts;
        uint256 hashSequence;
        uint256 hashOutputs;
        const bool cacheready = cache && cache->ready;

        if (!(nHashType & SIGHASH_ANYONECANPAY)) {
            hashPrevouts = cacheready ? cache->hashPrevouts : GetPrevoutHash(txTo);
        }

        if (!(nHashType & SIGHASH_ANYONECANPAY) && (nHashType & 0x1f) != SIGHASH_SINGLE && (nHashType & 0x1f) != SIGHASH_NONE) {
            hashSequence = cacheready ? cache->hashSequence : GetSequenceHash(txTo);
        }

        if ((nHashType & 0x1f) != SIGHASH_SINGLE && (nHashType & 0x1f) != SIGHASH_NONE) {
            hashOutputs = cacheready ? cache->hashOutputs : GetOutputsHash(txTo);
        } else if ((nHashType & 0x1f) == SIGHASH_SINGLE && nIn < txTo.GetNumVOuts()) {
            CHashWriter ss(SER_GETHASH, 0);

            if (txTo.IsRubixVersion())
                ss << *(txTo.vpout[nIn].get());
            else
                ss << txTo.vout[nIn];
            hashOutputs = ss.GetHash();
        }

        CHashWriter ss(SER_GETHASH, 0);
        // Version
        ss << txTo.nVersion;
        // Input prevouts/nSequence (none/all, depending on flags)
        ss << hashPrevouts;
        ss << hashSequence;
        // The input being signed (replacing the scriptSig with scriptCode + amount)
        // The prevout may already be contained in hashPrevout, and the nSequence
        // may already be contain in hashSequence.
        ss << txTo.vin[nIn].prevout;
        ss << scriptCode;

        //ss << amount;
        if (amount.size() > 0)
            ss.write((const char*)&amount[0], amount.size()); // Make unit tests still pass, same as << CAmount when amount.size() == 8

        ss << txTo.vin[nIn].nSequence;
        // Outputs (none/one/all, depending on flags)
        ss << hashOutputs;
        // Locktime
        ss << txTo.nLockTime;
        // Sighash type
        ss << nHashType;

        return ss.GetHash();
    }

    static const uint256 one(uint256S(""0000000000000000000000000000000000000000000000000000000000000001""));

    // Check for invalid use of SIGHASH_SINGLE
    if ((nHashType & 0x1f) == SIGHASH_SINGLE) {
        if (nIn >= txTo.GetNumVOuts()) {
            //  nOut out of range
            return one;
        }
    }

    // Wrapper to serialize only the necessary parts of the transaction being signed
    CTransactionSignatureSerializer<T> txTmp(txTo, scriptCode, nIn, nHashType);

    // Serialize and hash
    CHashWriter ss(SER_GETHASH, 0);
    ss << txTmp << nHashType;
    return ss.GetHash();
}

template <class T>
bool GenericTransactionSignatureChecker<T>::VerifySignature(const std::vector<unsigned char>& vchSig, const CPubKey& pubkey, const uint256& sighash) const
{
    return pubkey.Verify(sighash, vchSig);
}

template <class T>
bool GenericTransactionSignatureChecker<T>::CheckSig(const std::vector<unsigned char>& vchSigIn, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const
{
    CPubKey pubkey(vchPubKey);
    if (!pubkey.IsValid())
        return false;

    // Hash type is one byte tacked on to the end of the signature
    std::vector<unsigned char> vchSig(vchSigIn);
    if (vchSig.empty())
        return false;
    int nHashType = vchSig.back();
    vchSig.pop_back();

    uint256 sighash = SignatureHash(scriptCode, *txTo, nIn, nHashType, amount, sigversion, this->txdata);

    if (!VerifySignature(vchSig, pubkey, sighash))
        return false;

    return true;
}

template <class T>
bool GenericTransactionSignatureChecker<T>::CheckLockTime(const CScriptNum& nLockTime) const
{
    // There are two kinds of nLockTime: lock-by-blockheight
    // and lock-by-blocktime, distinguished by whether
    // nLockTime < LOCKTIME_THRESHOLD.
    //
    // We want to compare apples to apples, so fail the script
    // unless the type of nLockTime being tested is the same as
    // the nLockTime in the transaction.
    if (!(
        (txTo->nLockTime <  LOCKTIME_THRESHOLD && nLockTime <  LOCKTIME_THRESHOLD) ||
        (txTo->nLockTime >= LOCKTIME_THRESHOLD && nLockTime >= LOCKTIME_THRESHOLD)
    ))
        return false;

    // Now that we know we're comparing apples-to-apples, the
    // comparison is a simple numeric one.
    if (nLockTime > (int64_t)txTo->nLockTime)
        return false;

    // Finally the nLockTime feature can be disabled and thus
    // CHECKLOCKTIMEVERIFY bypassed if every txin has been
    // finalized by setting nSequence to maxint. The
    // transaction would be allowed into the blockchain, making
    // the opcode ineffective.
    //
    // Testing if this vin is not final is sufficient to
    // prevent this condition. Alternatively we could test all
    // inputs, but testing just this input minimizes the data
    // required to prove correct CHECKLOCKTIMEVERIFY execution.
    if (CTxIn::SEQUENCE_FINAL == txTo->vin[nIn].nSequence)
        return false;

    return true;
}

template <class T>
bool GenericTransactionSignatureChecker<T>::CheckSequence(const CScriptNum& nSequence) const
{
    // Relative lock times are supported by comparing the passed
    // in operand to the sequence number of the input.
    const int64_t txToSequence = (int64_t)txTo->vin[nIn].nSequence;

    // Fail if the transaction's version number is not set high
    // enough to trigger BIP 68 rules.
    if (static_cast<uint32_t>(txTo->nVersion) < 2)
        return false;

    // Sequence numbers with their most significant bit set are not
    // consensus constrained. Testing that the transaction's sequence
    // number do not have this bit set prevents using this property
    // to get around a CHECKSEQUENCEVERIFY check.
    if (txToSequence & CTxIn::SEQUENCE_LOCKTIME_DISABLE_FLAG)
        return false;

    // Mask off any bits that do not have consensus-enforced meaning
    // before doing the integer comparisons
    const uint32_t nLockTimeMask = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | CTxIn::SEQUENCE_LOCKTIME_MASK;
    const int64_t txToSequenceMasked = txToSequence & nLockTimeMask;
    const CScriptNum nSequenceMasked = nSequence & nLockTimeMask;

    // There are two kinds of nSequence: lock-by-blockheight
    // and lock-by-blocktime, distinguished by whether
    // nSequenceMasked < CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG.
    //
    // We want to compare apples to apples, so fail the script
    // unless the type of nSequenceMasked being tested is the same as
    // the nSequenceMasked in the transaction.
    if (!(
        (txToSequenceMasked <  CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG && nSequenceMasked <  CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG) ||
        (txToSequenceMasked >= CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG && nSequenceMasked >= CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG)
    )) {
        return false;
    }

    // Now that we know we're comparing apples-to-apples, the
    // comparison is a simple numeric one.
    if (nSequenceMasked > txToSequenceMasked)
        return false;

    return true;
}

// explicit instantiation
template class GenericTransactionSignatureChecker<CTransaction>;
template class GenericTransactionSignatureChecker<CMutableTransaction>;

static bool VerifyWitnessProgram(const CScriptWitness& witness, int witversion, const std::vector<unsigned char>& program, unsigned int flags, const BaseSignatureChecker& checker, ScriptError* serror)
{
    std::vector<std::vector<unsigned char> > stack;
    CScript scriptPubKey;

    if (witversion == 0) {
        if (program.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
            // Version 0 segregated witness program: SHA256(CScript) inside the program, CScript + inputs in witness
            if (witness.stack.size() == 0) {
                return set_error(serror, SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY);
            }
            scriptPubKey = CScript(witness.stack.back().begin(), witness.stack.back().end());
            stack = std::vector<std::vector<unsigned char> >(witness.stack.begin(), witness.stack.end() - 1);
            uint256 hashScriptPubKey;
            CSHA256().Write(&scriptPubKey[0], scriptPubKey.size()).Finalize(hashScriptPubKey.begin());
            if (memcmp(hashScriptPubKey.begin(), program.data(), 32)) {
                return set_error(serror, SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH);
            }
        } else if (program.size() == WITNESS_V0_KEYHASH_SIZE) {
            // Special case for pay-to-pubkeyhash; signature + pubkey in witness
            if (witness.stack.size() != 2) {
                return set_error(serror, SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH); // 2 items in witness
            }
            scriptPubKey << OP_DUP << OP_HASH160 << program << OP_EQUALVERIFY << OP_CHECKSIG;
            stack = witness.stack;
        } else {
            return set_error(serror, SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH);
        }
    } else if (flags & SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM) {
        return set_error(serror, SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM);
    } else {
        // Higher version witness scripts return true for future softfork compatibility
        return set_success(serror);
    }

    // Disallow stack item size > MAX_SCRIPT_ELEMENT_SIZE in witness stack
    for (unsigned int i = 0; i < stack.size(); i++) {
        if (stack.at(i).size() > MAX_SCRIPT_ELEMENT_SIZE)
            return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
    }

    if (!EvalScript(stack, scriptPubKey, flags, checker, SigVersion::WITNESS_V0, serror)) {
        return false;
    }

    // Scripts inside witness implicitly require cleanstack behaviour
    if (stack.size() != 1)
        return set_error(serror, SCRIPT_ERR_CLEANSTACK);
    if (!CastToBool(stack.back()))
        return set_error(serror, SCRIPT_ERR_EVAL_FALSE);
    return true;
}

bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, const CScriptWitness* witness, unsigned int flags, const BaseSignatureChecker& checker, ScriptError* serror)
{
    static const CScriptWitness emptyWitness;
    if (witness == nullptr) {
        witness = &emptyWitness;
    }
    bool hadWitness = false;

    set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR);

    if ((flags & SCRIPT_VERIFY_SIGPUSHONLY) != 0 && !scriptSig.IsPushOnly()) {
        return set_error(serror, SCRIPT_ERR_SIG_PUSHONLY);
    }

    std::vector<std::vector<unsigned char> > stack, stackCopy;
    if (checker.IsRubixVersion())
    {
        assert(witness);
        if (scriptSig.size() != 0) {
            // The scriptSig must be _exactly_ CScript(), otherwise we reintroduce malleability.
            return set_error(serror, SCRIPT_ERR_WITNESS_MALLEATED);
        }
        stack = witness->stack;
    } else
    {
        if (!EvalScript(stack, scriptSig, flags, checker, SigVersion::BASE, serror))
            // serror is set
            return false;
    };

    if (flags & SCRIPT_VERIFY_P2SH)
        stackCopy = stack;

    if (!EvalScript(stack, scriptPubKey, flags, checker, SigVersion::BASE, serror))
        // serror is set
        return false;

    if (stack.empty())
        return set_error(serror, SCRIPT_ERR_EVAL_FALSE);
    if (CastToBool(stack.back()) == false)
        return set_error(serror, SCRIPT_ERR_EVAL_FALSE);

    // Bare witness programs
    int witnessversion;
    std::vector<unsigned char> witnessprogram;
    if (flags & SCRIPT_VERIFY_WITNESS) {
        if (scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
            hadWitness = true;
            if (scriptSig.size() != 0) {
                // The scriptSig must be _exactly_ CScript(), otherwise we reintroduce malleability.
                return set_error(serror, SCRIPT_ERR_WITNESS_MALLEATED);
            }
            if (!VerifyWitnessProgram(*witness, witnessversion, witnessprogram, flags, checker, serror)) {
                return false;
            }
            // Bypass the cleanstack check at the end. The actual stack is obviously not clean
            // for witness programs.
            stack.resize(1);
        }
    }

    bool fIsP2SH = checker.IsRubixVersion() ? scriptPubKey.IsPayToScriptHashAny(checker.IsCoinStake()) : scriptPubKey.IsPayToScriptHash();
    if (fIsP2SH && flags & SCRIPT_VERIFY_NO_CSP2SH)
        fIsP2SH = scriptPubKey.IsPayToScriptHashAny(true); // will match only plain p2sh scripts

    // Additional validation for spend-to-script-hash transactions:
    if ((flags & SCRIPT_VERIFY_P2SH)
        && fIsP2SH)
    {
        // scriptSig must be literals-only or validation fails
        if (!scriptSig.IsPushOnly())
            return set_error(serror, SCRIPT_ERR_SIG_PUSHONLY);

        // Restore stack.
        swap(stack, stackCopy);

        // stack cannot be empty here, because if it was the
        // P2SH  HASH <> EQUAL  scriptPubKey would be evaluated with
        // an empty stack and the EvalScript above would return false.
        assert(!stack.empty());

        const valtype& pubKeySerialized = stack.back();
        CScript pubKey2(pubKeySerialized.begin(), pubKeySerialized.end());
        popstack(stack);

        if (!EvalScript(stack, pubKey2, flags, checker, SigVersion::BASE, serror))
            // serror is set
            return false;
        if (stack.empty())
            return set_error(serror, SCRIPT_ERR_EVAL_FALSE);
        if (!CastToBool(stack.back()))
            return set_error(serror, SCRIPT_ERR_EVAL_FALSE);

        // P2SH witness program
        if (flags & SCRIPT_VERIFY_WITNESS) {
            if (pubKey2.IsWitnessProgram(witnessversion, witnessprogram)) {
                hadWitness = true;
                if (scriptSig != CScript() << std::vector<unsigned char>(pubKey2.begin(), pubKey2.end())) {
                    // The scriptSig must be _exactly_ a single push of the redeemScript. Otherwise we
                    // reintroduce malleability.
                    return set_error(serror, SCRIPT_ERR_WITNESS_MALLEATED_P2SH);
                }
                if (!VerifyWitnessProgram(*witness, witnessversion, witnessprogram, flags, checker, serror)) {
                    return false;
                }
                // Bypass the cleanstack check at the end. The actual stack is obviously not clean
                // for witness programs.
                stack.resize(1);
            }
        }
    }

    // The CLEANSTACK check is only performed after potential P2SH evaluation,
    // as the non-P2SH evaluation of a P2SH script will obviously not result in
    // a clean stack (the P2SH inputs remain). The same holds for witness evaluation.
    if ((flags & SCRIPT_VERIFY_CLEANSTACK) != 0) {
        // Disallow CLEANSTACK without P2SH, as otherwise a switch CLEANSTACK->P2SH+CLEANSTACK
        // would be possible, which is not a softfork (and P2SH should be one).
        assert((flags & SCRIPT_VERIFY_P2SH) != 0);
        assert((flags & SCRIPT_VERIFY_WITNESS) != 0);
        if (stack.size() != 1) {
            return set_error(serror, SCRIPT_ERR_CLEANSTACK);
        }
    }

    if (flags & SCRIPT_VERIFY_WITNESS) {
        // We can't check for correct unexpected witness data if P2SH was off, so require
        // that WITNESS implies P2SH. Otherwise, going from WITNESS->P2SH+WITNESS would be
        // possible, which is not a softfork.
        assert((flags & SCRIPT_VERIFY_P2SH) != 0);

        if (!checker.IsRubixVersion())
        if (!hadWitness && !witness->IsNull()) {
            return set_error(serror, SCRIPT_ERR_WITNESS_UNEXPECTED);
        }
    }

    return set_success(serror);
}

size_t static WitnessSigOps(int witversion, const std::vector<unsigned char>& witprogram, const CScriptWitness& witness)
{
    if (witversion == 0) {
        if (witprogram.size() == WITNESS_V0_KEYHASH_SIZE)
            return 1;

        if (witprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE && witness.stack.size() > 0) {
            CScript subscript(witness.stack.back().begin(), witness.stack.back().end());
            return subscript.GetSigOpCount(true);
        }
    }

    // Future flags may be implemented here.
    return 0;
}

size_t CountWitnessSigOps(const CScript& scriptSig, const CScript& scriptPubKey, const CScriptWitness* witness, unsigned int flags)
{
    static const CScriptWitness witnessEmpty;

    if ((flags & SCRIPT_VERIFY_WITNESS) == 0) {
        return 0;
    }
    assert((flags & SCRIPT_VERIFY_P2SH) != 0);

    int witnessversion;
    std::vector<unsigned char> witnessprogram;
    if (scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
        return WitnessSigOps(witnessversion, witnessprogram, witness ? *witness : witnessEmpty);
    }

    if (scriptPubKey.IsPayToScriptHash() && scriptSig.IsPushOnly()) {
        CScript::const_iterator pc = scriptSig.begin();
        std::vector<unsigned char> data;
        while (pc < scriptSig.end()) {
            opcodetype opcode;
            scriptSig.GetOp(pc, opcode, data);
        }
        CScript subscript(data.begin(), data.end());
        if (subscript.IsWitnessProgram(witnessversion, witnessprogram)) {
            return WitnessSigOps(witnessversion, witnessprogram, witness ? *witness : witnessEmpty);
        }
    }

    return 0;
}


bool HasIsCoinstakeOp(const CScript &script)
{
    CScript::const_iterator pc = script.begin();

    if (pc == script.end())
        return false;

    opcodetype opcode;
    valtype vchPushValue;

    if (!script.GetOp(pc, opcode, vchPushValue))
        return false;

    if (opcode == OP_ISCOINSTAKE)
        return true;

    return false;
};

bool IsSpendScriptP2PKH(const CScript &script)
{
    CScript::const_iterator pc = script.begin();
    CScript::const_iterator pend = script.end();

    opcodetype opcode;
    valtype vchPushValue;

    bool fFoundOp = false;
    while (pc < pend)
    {
        if (!script.GetOp(pc, opcode, vchPushValue))
            break;

        if (!fFoundOp
            && opcode == OP_ELSE)
        {
            size_t ofs = pc - script.begin();
            return script.MatchPayToPublicKeyHash(ofs);
        };
    };

    return false;
};

bool GetCoinstakeScriptPath(const CScript &scriptIn, CScript &scriptOut)
{
    CScript::const_iterator pc = scriptIn.begin();
    CScript::const_iterator pend = scriptIn.end();
    CScript::const_iterator pcStart = pc;

    opcodetype opcode;
    valtype vchPushValue;

    bool fFoundOp = false;
    while (pc < pend)
    {
        if (!scriptIn.GetOp(pc, opcode, vchPushValue))
            break;

        if (!fFoundOp
            && opcode == OP_ISCOINSTAKE)
        {
            pc++; // skip over if

            pcStart = pc;
            fFoundOp = true;
            continue;
        };

        if (fFoundOp && opcode == OP_ELSE)
        {
            pc--;
            scriptOut = CScript(pcStart, pc);
            return true;
        };
    };

    return false;
};

bool GetNonCoinstakeScriptPath(const CScript &scriptIn, CScript &scriptOut)
{
    CScript::const_iterator pc = scriptIn.begin();
    CScript::const_iterator pend = scriptIn.end();
    CScript::const_iterator pcStart = pc;

    opcodetype opcode;
    valtype vchPushValue;

    bool fFoundOp = false;
    while (pc < pend)
    {
        if (!scriptIn.GetOp(pc, opcode, vchPushValue))
            break;

        if (!fFoundOp
            && opcode == OP_ELSE)
        {
            pcStart = pc;
            fFoundOp = true;
            continue;
        };

        if (fFoundOp && opcode == OP_ENDIF)
        {
            pc--;
            scriptOut = CScript(pcStart, pc);
            return true;
        };
    };

    return false;
};

bool SplitConditionalCoinstakeScript(const CScript &scriptIn, CScript &scriptOutA, CScript &scriptOutB)
{
    CScript::const_iterator pc = scriptIn.begin();
    CScript::const_iterator pend = scriptIn.end();
    CScript::const_iterator pcStart = pc;

    opcodetype opcode;
    valtype vchPushValue;

    bool fFoundOp = false, fFoundElse = false;
    while (pc < pend)
    {
        if (!scriptIn.GetOp(pc, opcode, vchPushValue))
            break;

        if (!fFoundOp
            && opcode == OP_ISCOINSTAKE)
        {
            pc++; // skip over if

            pcStart = pc;
            fFoundOp = true;
            continue;
        };

        if (fFoundElse && opcode == OP_ENDIF)
        {
            pc--;
            scriptOutB = CScript(pcStart, pc);
            return true;
        };

        if (fFoundOp && opcode == OP_ELSE)
        {
            scriptOutA = CScript(pcStart, pc-1);
            pcStart = pc;
            fFoundElse = true;
        };
    };

    return false;
};

bool GetColdStakeScriptPath(bool for_coinstake, const CScript &script_in, CScript &script_out)
{
    if (for_coinstake) {
        return GetCoinstakeScriptPath(script_in, script_out);
    }
    return GetNonCoinstakeScriptPath(script_in, script_out);
}
",16158,True,2660.9804092770396,median
"// Copyright 2015 Emilie Gillet.
//
// Author: Emilie Gillet (emilie.o.gillet@gmail.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the ""Software""), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
// See http://creativecommons.org/licenses/MIT/ for more information.
//
// -----------------------------------------------------------------------------
//
// Resources definitions.
//
// Automatically generated with:
// make resources

// This is the only thing we'd need DaisySP for, so I'll just define it here
#define PI_F 3.1415927410125732421875f
#define TWOPI_F (2.0f * PI_F)

#include ""resources.h""

namespace torus
{
void InitResources()
{
    // lut_sine
    for(int i = 0; i < LUT_SINE_SIZE; i++)
    {
        float t     = (float)i / 4096.f * TWOPI_F;
        lut_sine[i] = sin(t);
    }
}

const int16_t* lookup_table_int16_table[] = {};


const uint32_t* lookup_table_uint32_table[] = {};

float lut_sine[LUT_SINE_SIZE];

const float lut_4_decades[] = {
    1.000000000e+00, 1.036632928e+00, 1.074607828e+00, 1.113973860e+00,
    1.154781985e+00, 1.197085030e+00, 1.240937761e+00, 1.286396945e+00,
    1.333521432e+00, 1.382372227e+00, 1.433012570e+00, 1.485508017e+00,
    1.539926526e+00, 1.596338544e+00, 1.654817100e+00, 1.715437896e+00,
    1.778279410e+00, 1.843422992e+00, 1.910952975e+00, 1.980956779e+00,
    2.053525026e+00, 2.128751662e+00, 2.206734069e+00, 2.287573200e+00,
    2.371373706e+00, 2.458244069e+00, 2.548296748e+00, 2.641648320e+00,
    2.738419634e+00, 2.838735965e+00, 2.942727176e+00, 3.050527890e+00,
    3.162277660e+00, 3.278121151e+00, 3.398208329e+00, 3.522694651e+00,
    3.651741273e+00, 3.785515249e+00, 3.924189758e+00, 4.067944321e+00,
    4.216965034e+00, 4.371444813e+00, 4.531583638e+00, 4.697588817e+00,
    4.869675252e+00, 5.048065717e+00, 5.232991147e+00, 5.424690937e+00,
    5.623413252e+00, 5.829415347e+00, 6.042963902e+00, 6.264335367e+00,
    6.493816316e+00, 6.731703824e+00, 6.978305849e+00, 7.233941627e+00,
    7.498942093e+00, 7.773650302e+00, 8.058421878e+00, 8.353625470e+00,
    8.659643234e+00, 8.976871324e+00, 9.305720409e+00, 9.646616199e+00,
    1.000000000e+01, 1.036632928e+01, 1.074607828e+01, 1.113973860e+01,
    1.154781985e+01, 1.197085030e+01, 1.240937761e+01, 1.286396945e+01,
    1.333521432e+01, 1.382372227e+01, 1.433012570e+01, 1.485508017e+01,
    1.539926526e+01, 1.596338544e+01, 1.654817100e+01, 1.715437896e+01,
    1.778279410e+01, 1.843422992e+01, 1.910952975e+01, 1.980956779e+01,
    2.053525026e+01, 2.128751662e+01, 2.206734069e+01, 2.287573200e+01,
    2.371373706e+01, 2.458244069e+01, 2.548296748e+01, 2.641648320e+01,
    2.738419634e+01, 2.838735965e+01, 2.942727176e+01, 3.050527890e+01,
    3.162277660e+01, 3.278121151e+01, 3.398208329e+01, 3.522694651e+01,
    3.651741273e+01, 3.785515249e+01, 3.924189758e+01, 4.067944321e+01,
    4.216965034e+01, 4.371444813e+01, 4.531583638e+01, 4.697588817e+01,
    4.869675252e+01, 5.048065717e+01, 5.232991147e+01, 5.424690937e+01,
    5.623413252e+01, 5.829415347e+01, 6.042963902e+01, 6.264335367e+01,
    6.493816316e+01, 6.731703824e+01, 6.978305849e+01, 7.233941627e+01,
    7.498942093e+01, 7.773650302e+01, 8.058421878e+01, 8.353625470e+01,
    8.659643234e+01, 8.976871324e+01, 9.305720409e+01, 9.646616199e+01,
    1.000000000e+02, 1.036632928e+02, 1.074607828e+02, 1.113973860e+02,
    1.154781985e+02, 1.197085030e+02, 1.240937761e+02, 1.286396945e+02,
    1.333521432e+02, 1.382372227e+02, 1.433012570e+02, 1.485508017e+02,
    1.539926526e+02, 1.596338544e+02, 1.654817100e+02, 1.715437896e+02,
    1.778279410e+02, 1.843422992e+02, 1.910952975e+02, 1.980956779e+02,
    2.053525026e+02, 2.128751662e+02, 2.206734069e+02, 2.287573200e+02,
    2.371373706e+02, 2.458244069e+02, 2.548296748e+02, 2.641648320e+02,
    2.738419634e+02, 2.838735965e+02, 2.942727176e+02, 3.050527890e+02,
    3.162277660e+02, 3.278121151e+02, 3.398208329e+02, 3.522694651e+02,
    3.651741273e+02, 3.785515249e+02, 3.924189758e+02, 4.067944321e+02,
    4.216965034e+02, 4.371444813e+02, 4.531583638e+02, 4.697588817e+02,
    4.869675252e+02, 5.048065717e+02, 5.232991147e+02, 5.424690937e+02,
    5.623413252e+02, 5.829415347e+02, 6.042963902e+02, 6.264335367e+02,
    6.493816316e+02, 6.731703824e+02, 6.978305849e+02, 7.233941627e+02,
    7.498942093e+02, 7.773650302e+02, 8.058421878e+02, 8.353625470e+02,
    8.659643234e+02, 8.976871324e+02, 9.305720409e+02, 9.646616199e+02,
    1.000000000e+03, 1.036632928e+03, 1.074607828e+03, 1.113973860e+03,
    1.154781985e+03, 1.197085030e+03, 1.240937761e+03, 1.286396945e+03,
    1.333521432e+03, 1.382372227e+03, 1.433012570e+03, 1.485508017e+03,
    1.539926526e+03, 1.596338544e+03, 1.654817100e+03, 1.715437896e+03,
    1.778279410e+03, 1.843422992e+03, 1.910952975e+03, 1.980956779e+03,
    2.053525026e+03, 2.128751662e+03, 2.206734069e+03, 2.287573200e+03,
    2.371373706e+03, 2.458244069e+03, 2.548296748e+03, 2.641648320e+03,
    2.738419634e+03, 2.838735965e+03, 2.942727176e+03, 3.050527890e+03,
    3.162277660e+03, 3.278121151e+03, 3.398208329e+03, 3.522694651e+03,
    3.651741273e+03, 3.785515249e+03, 3.924189758e+03, 4.067944321e+03,
    4.216965034e+03, 4.371444813e+03, 4.531583638e+03, 4.697588817e+03,
    4.869675252e+03, 5.048065717e+03, 5.232991147e+03, 5.424690937e+03,
    5.623413252e+03, 5.829415347e+03, 6.042963902e+03, 6.264335367e+03,
    6.493816316e+03, 6.731703824e+03, 6.978305849e+03, 7.233941627e+03,
    7.498942093e+03, 7.773650302e+03, 8.058421878e+03, 8.353625470e+03,
    8.659643234e+03, 8.976871324e+03, 9.305720409e+03, 9.646616199e+03,
    1.000000000e+04,
};
const float lut_svf_shift[] = {
    2.500000000e-01, 2.408119579e-01, 2.316544611e-01, 2.225575501e-01,
    2.135502761e-01, 2.046602549e-01, 1.959132760e-01, 1.873329789e-01,
    1.789406032e-01, 1.707548172e-01, 1.627916233e-01, 1.550643347e-01,
    1.475836177e-01, 1.403575876e-01, 1.333919506e-01, 1.266901772e-01,
    1.202537001e-01, 1.140821254e-01, 1.081734480e-01, 1.025242668e-01,
    9.712999179e-02, 9.198504051e-02, 8.708302003e-02, 8.241689360e-02,
    7.797913038e-02, 7.376183852e-02, 6.975688172e-02, 6.595598018e-02,
    6.235079694e-02, 5.893301078e-02, 5.569437701e-02, 5.262677742e-02,
    4.972226058e-02, 4.697307381e-02, 4.437168789e-02, 4.191081545e-02,
    3.958342416e-02, 3.738274529e-02, 3.530227864e-02, 3.333579426e-02,
    3.147733169e-02, 2.972119704e-02, 2.806195849e-02, 2.649444041e-02,
    2.501371653e-02, 2.361510230e-02, 2.229414676e-02, 2.104662398e-02,
    1.986852431e-02, 1.875604550e-02, 1.770558386e-02, 1.671372543e-02,
    1.577723728e-02, 1.489305906e-02, 1.405829467e-02, 1.327020425e-02,
    1.252619642e-02, 1.182382076e-02, 1.116076060e-02, 1.053482614e-02,
    9.943947824e-03, 9.386169992e-03, 8.859644866e-03, 8.362626781e-03,
    7.893466717e-03, 7.450607078e-03, 7.032576744e-03, 6.637986365e-03,
    6.265523903e-03, 5.913950392e-03, 5.582095932e-03, 5.268855886e-03,
    4.973187279e-03, 4.694105394e-03, 4.430680542e-03, 4.182035018e-03,
    3.947340207e-03, 3.725813861e-03, 3.516717519e-03, 3.319354065e-03,
    3.133065427e-03, 2.957230396e-03, 2.791262569e-03, 2.634608406e-03,
    2.486745394e-03, 2.347180309e-03, 2.215447582e-03, 2.091107747e-03,
    1.973745986e-03, 1.862970740e-03, 1.758412418e-03, 1.659722154e-03,
    1.566570656e-03, 1.478647104e-03, 1.395658114e-03, 1.317326764e-03,
    1.243391669e-03, 1.173606108e-03, 1.107737206e-03, 1.045565155e-03,
    9.868824789e-04, 9.314933471e-04, 8.792129165e-04, 8.298667176e-04,
    7.832900713e-04, 7.393275405e-04, 6.978324110e-04, 6.586662024e-04,
    6.216982059e-04, 5.868050482e-04, 5.538702800e-04, 5.227839874e-04,
    4.934424252e-04, 4.657476707e-04, 4.396072968e-04, 4.149340639e-04,
    3.916456285e-04, 3.696642688e-04, 3.489166247e-04, 3.293334538e-04,
    3.108493994e-04, 2.934027734e-04, 2.769353496e-04, 2.613921700e-04,
    2.467213608e-04, 2.328739600e-04, 2.198037532e-04, 2.074671201e-04,
    1.958228884e-04, 1.848321967e-04, 1.744583648e-04, 1.646667709e-04,
    1.554247368e-04, 1.467014179e-04, 1.384677010e-04, 1.306961070e-04,
    1.233606989e-04, 1.164369956e-04, 1.099018897e-04, 1.037335710e-04,
    9.791145345e-05, 9.241610615e-05, 8.722918894e-05, 8.233339098e-05,
    7.771237301e-05, 7.335071282e-05, 6.923385378e-05, 6.534805627e-05,
    6.168035179e-05, 5.821849973e-05, 5.495094649e-05, 5.186678690e-05,
    4.895572788e-05, 4.620805405e-05, 4.361459529e-05, 4.116669618e-05,
    3.885618709e-05, 3.667535690e-05, 3.461692730e-05, 3.267402848e-05,
    3.084017618e-05, 2.910925011e-05, 2.747547345e-05, 2.593339362e-05,
    2.447786409e-05, 2.310402715e-05, 2.180729775e-05, 2.058334818e-05,
    1.942809362e-05, 1.833767851e-05, 1.730846370e-05, 1.633701428e-05,
    1.542008813e-05, 1.455462508e-05, 1.373773675e-05, 1.296669683e-05,
    1.223893206e-05, 1.155201359e-05, 1.090364889e-05, 1.029167410e-05,
    9.714046817e-06, 9.168839263e-06, 8.654231857e-06, 8.168507146e-06,
    7.710044069e-06, 7.277312546e-06, 6.868868378e-06, 6.483348419e-06,
    6.119466033e-06, 5.776006796e-06, 5.451824445e-06, 5.145837051e-06,
    4.857023409e-06, 4.584419632e-06, 4.327115929e-06, 4.084253574e-06,
    3.855022035e-06, 3.638656274e-06, 3.434434189e-06, 3.241674210e-06,
    3.059733017e-06, 2.888003398e-06, 2.725912223e-06, 2.572918525e-06,
    2.428511705e-06, 2.292209816e-06, 2.163557965e-06, 2.042126787e-06,
    1.927511018e-06, 1.819328137e-06, 1.717217095e-06, 1.620837105e-06,
    1.529866508e-06, 1.444001699e-06, 1.362956111e-06, 1.286459263e-06,
    1.214255852e-06, 1.146104908e-06, 1.081778982e-06, 1.021063394e-06,
    9.637555088e-07, 9.096640684e-07, 8.586085474e-07, 8.104185525e-07,
    7.649332542e-07, 7.220008496e-07, 6.814780557e-07, 6.432296314e-07,
    6.071279262e-07, 5.730524541e-07, 5.408894912e-07, 5.105316968e-07,
    4.818777544e-07, 4.548320342e-07, 4.293042737e-07, 4.052092763e-07,
    3.824666271e-07, 3.610004248e-07, 3.407390278e-07, 3.216148157e-07,
    3.035639631e-07, 2.865262270e-07, 2.704447456e-07, 2.552658484e-07,
    2.409388772e-07, 2.274160171e-07, 2.146521368e-07, 2.026046381e-07,
    1.912333136e-07, 1.805002124e-07, 1.703695139e-07, 1.608074078e-07,
    1.517819816e-07, 1.432631135e-07, 1.352223728e-07, 1.276329242e-07,
    1.204694386e-07,
};
const float lut_stiffness[] = {
    -6.250000000e-02, -6.152343750e-02, -6.054687500e-02, -5.957031250e-02,
    -5.859375000e-02, -5.761718750e-02, -5.664062500e-02, -5.566406250e-02,
    -5.468750000e-02, -5.371093750e-02, -5.273437500e-02, -5.175781250e-02,
    -5.078125000e-02, -4.980468750e-02, -4.882812500e-02, -4.785156250e-02,
    -4.687500000e-02, -4.589843750e-02, -4.492187500e-02, -4.394531250e-02,
    -4.296875000e-02, -4.199218750e-02, -4.101562500e-02, -4.003906250e-02,
    -3.906250000e-02, -3.808593750e-02, -3.710937500e-02, -3.613281250e-02,
    -3.515625000e-02, -3.417968750e-02, -3.320312500e-02, -3.222656250e-02,
    -3.125000000e-02, -3.027343750e-02, -2.929687500e-02, -2.832031250e-02,
    -2.734375000e-02, -2.636718750e-02, -2.539062500e-02, -2.441406250e-02,
    -2.343750000e-02, -2.246093750e-02, -2.148437500e-02, -2.050781250e-02,
    -1.953125000e-02, -1.855468750e-02, -1.757812500e-02, -1.660156250e-02,
    -1.562500000e-02, -1.464843750e-02, -1.367187500e-02, -1.269531250e-02,
    -1.171875000e-02, -1.074218750e-02, -9.765625000e-03, -8.789062500e-03,
    -7.812500000e-03, -6.835937500e-03, -5.859375000e-03, -4.882812500e-03,
    -3.906250000e-03, -2.929687500e-03, -1.953125000e-03, -9.765625000e-04,
    0.000000000e+00,  0.000000000e+00,  0.000000000e+00,  0.000000000e+00,
    0.000000000e+00,  0.000000000e+00,  0.000000000e+00,  0.000000000e+00,
    0.000000000e+00,  0.000000000e+00,  0.000000000e+00,  0.000000000e+00,
    0.000000000e+00,  6.029410294e-05,  3.672617230e-04,  6.835957809e-04,
    1.009582073e-03,  1.345515115e-03,  1.691698412e-03,  2.048444725e-03,
    2.416076364e-03,  2.794925468e-03,  3.185334315e-03,  3.587655624e-03,
    4.002252878e-03,  4.429500650e-03,  4.869784943e-03,  5.323503537e-03,
    5.791066350e-03,  6.272895808e-03,  6.769427226e-03,  7.281109202e-03,
    7.808404022e-03,  8.351788076e-03,  8.911752293e-03,  9.488802580e-03,
    1.008346028e-02,  1.069626264e-02,  1.132776331e-02,  1.197853283e-02,
    1.264915914e-02,  1.334024813e-02,  1.405242417e-02,  1.478633069e-02,
    1.554263074e-02,  1.632200761e-02,  1.712516545e-02,  1.795282987e-02,
    1.880574864e-02,  1.968469234e-02,  2.059045506e-02,  2.152385512e-02,
    2.248573583e-02,  2.347696619e-02,  2.449844176e-02,  2.555108540e-02,
    2.663584813e-02,  2.775370999e-02,  2.890568094e-02,  3.009280173e-02,
    3.131614488e-02,  3.257681565e-02,  3.387595299e-02,  3.521473064e-02,
    3.659435812e-02,  3.801608189e-02,  3.948118641e-02,  4.099099536e-02,
    4.254687278e-02,  4.415022437e-02,  4.580249868e-02,  4.750518848e-02,
    4.925983210e-02,  5.106801479e-02,  5.293137017e-02,  5.485158172e-02,
    5.683038428e-02,  5.886956562e-02,  6.097096806e-02,  6.313649016e-02,
    6.536808837e-02,  6.766777886e-02,  7.003763933e-02,  7.247981084e-02,
    7.499649981e-02,  7.758997998e-02,  8.026259446e-02,  8.301675786e-02,
    8.585495846e-02,  8.877976048e-02,  9.179380636e-02,  9.489981918e-02,
    9.810060511e-02,  1.013990559e-01,  1.047981517e-01,  1.083009634e-01,
    1.119106556e-01,  1.156304895e-01,  1.194638260e-01,  1.234141283e-01,
    1.274849653e-01,  1.316800149e-01,  1.360030671e-01,  1.404580277e-01,
    1.450489216e-01,  1.497798965e-01,  1.546552266e-01,  1.596793166e-01,
    1.648567056e-01,  1.701920711e-01,  1.756902336e-01,  1.813561603e-01,
    1.871949702e-01,  1.932119385e-01,  1.994125013e-01,  2.058022605e-01,
    2.123869891e-01,  2.191726361e-01,  2.261653322e-01,  2.333713949e-01,
    2.407973346e-01,  2.484498605e-01,  2.563358863e-01,  2.644625367e-01,
    2.728371538e-01,  2.814673039e-01,  2.903607839e-01,  2.995256288e-01,
    3.089701187e-01,  3.187027863e-01,  3.287324247e-01,  3.390680953e-01,
    3.497191360e-01,  3.606951697e-01,  3.720061128e-01,  3.836621843e-01,
    3.956739150e-01,  4.080521572e-01,  4.208080940e-01,  4.339532500e-01,
    4.474995013e-01,  4.614590865e-01,  4.758446177e-01,  4.906690914e-01,
    5.059459012e-01,  5.216888491e-01,  5.379121581e-01,  5.546304856e-01,
    5.718589358e-01,  5.896130741e-01,  6.079089407e-01,  6.267630651e-01,
    6.461924814e-01,  6.662147434e-01,  6.868479405e-01,  7.081107139e-01,
    7.300222738e-01,  7.526024164e-01,  7.758715422e-01,  7.998506739e-01,
    8.245614757e-01,  8.500262730e-01,  8.762680723e-01,  9.033105820e-01,
    9.311782340e-01,  9.598962059e-01,  9.894904431e-01,  1.000000745e+00,
    1.000037649e+00,  1.000262504e+00,  1.000964607e+00,  1.002570034e+00,
    1.005639154e+00,  1.010861180e+00,  1.019043988e+00,  1.031097087e+00,
    1.048005353e+00,  1.070791059e+00,  1.100461817e+00,  1.137942574e+00,
    1.183990632e+00,  1.239094135e+00,  1.303356514e+00,  1.376372085e+00,
    1.457101344e+00,  1.543758274e+00,  1.633725943e+00,  1.723520185e+00,
    1.808823654e+00,  1.884612937e+00,  1.945398753e+00,  2.000000000e+00,
    2.000000000e+00,
};
const float lut_fm_frequency_quantizer[] = {
    -1.200000000e+01, -1.200000000e+01, -1.200000000e+01, -1.184000000e+01,
    -1.184000000e+01, -1.184000000e+01, -1.111000000e+01, -1.038000000e+01,
    -9.650000000e+00, -8.920000000e+00, -8.190000000e+00, -7.460000000e+00,
    -6.730000000e+00, -6.000000000e+00, -6.000000000e+00, -6.000000000e+00,
    -5.545511612e+00, -5.091023223e+00, -4.636534835e+00, -4.182046446e+00,
    -4.182046446e+00, -4.182046446e+00, -3.659290641e+00, -3.136534835e+00,
    -2.613779029e+00, -2.091023223e+00, -1.568267417e+00, -1.045511612e+00,
    -5.227558058e-01, 0.000000000e+00,  0.000000000e+00,  0.000000000e+00,
    1.600000000e-01,  1.600000000e-01,  1.600000000e-01,  8.900000000e-01,
    1.620000000e+00,  2.350000000e+00,  3.080000000e+00,  3.810000000e+00,
    4.540000000e+00,  5.270000000e+00,  6.000000000e+00,  6.000000000e+00,
    6.000000000e+00,  6.454488388e+00,  6.908976777e+00,  7.363465165e+00,
    7.817953554e+00,  7.817953554e+00,  7.817953554e+00,  8.285529931e+00,
    8.753106309e+00,  9.220682687e+00,  9.688259065e+00,  9.688259065e+00,
    9.688259065e+00,  1.026619430e+01,  1.084412953e+01,  1.142206477e+01,
    1.200000000e+01,  1.200000000e+01,  1.200000000e+01,  1.216000000e+01,
    1.216000000e+01,  1.216000000e+01,  1.262977500e+01,  1.309955001e+01,
    1.356932501e+01,  1.403910002e+01,  1.403910002e+01,  1.403910002e+01,
    1.490761987e+01,  1.577613972e+01,  1.664465957e+01,  1.751317942e+01,
    1.751317942e+01,  1.751317942e+01,  1.800000000e+01,  1.800000000e+01,
    1.800000000e+01,  1.850977500e+01,  1.901955001e+01,  1.901955001e+01,
    1.901955001e+01,  1.981795355e+01,  1.981795355e+01,  1.981795355e+01,
    2.066386428e+01,  2.150977500e+01,  2.150977500e+01,  2.150977500e+01,
    2.213233125e+01,  2.275488750e+01,  2.337744375e+01,  2.400000000e+01,
    2.400000000e+01,  2.400000000e+01,  2.450977500e+01,  2.501955001e+01,
    2.501955001e+01,  2.501955001e+01,  2.547403840e+01,  2.592852679e+01,
    2.638301517e+01,  2.683750356e+01,  2.683750356e+01,  2.683750356e+01,
    2.735032035e+01,  2.786313714e+01,  2.786313714e+01,  2.786313714e+01,
    2.839735285e+01,  2.893156857e+01,  2.946578428e+01,  3.000000000e+01,
    3.000000000e+01,  3.000000000e+01,  3.075000000e+01,  3.150000000e+01,
    3.225000000e+01,  3.300000000e+01,  3.375000000e+01,  3.450000000e+01,
    3.525000000e+01,  3.600000000e+01,  3.600000000e+01,  3.600000000e+01,
    3.600000000e+01,
};


const float* lookup_table_table[] = {
    lut_sine,
    lut_4_decades,
    lut_svf_shift,
    lut_stiffness,
    lut_fm_frequency_quantizer,
};


} // namespace torus
",16296,True,5004.435030801396,median
":spring-data-commons-ref: https://docs.spring.io/spring-data/data-commons/docs/current/reference/html

== Spring Data Cloud Spanner

https://projects.spring.io/spring-data/[Spring Data] is an abstraction for storing and retrieving POJOs in numerous storage technologies.
Spring Cloud GCP adds Spring Data support for https://cloud.google.com/spanner/[Google Cloud Spanner].

Maven coordinates for this module only, using <<getting-started.adoc#_bill_of_materials, Spring Cloud GCP BOM>>:

[source,xml]
----
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-gcp-data-spanner</artifactId>
</dependency>
----

Gradle coordinates:

[source]
----
dependencies {
    implementation(""org.springframework.cloud:spring-cloud-gcp-data-spanner"")
}
----

We provide a link:../spring-cloud-gcp-starters/spring-cloud-gcp-starter-data-spanner[Spring Boot Starter for Spring Data Spanner], with which you can leverage our recommended auto-configuration setup.
To use the starter, see the coordinates see below.


Maven:

[source,xml]
----
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-gcp-starter-data-spanner</artifactId>
</dependency>
----

Gradle:

[source,subs=""normal""]
----
dependencies {
    implementation(""org.springframework.cloud:spring-cloud-gcp-starter-data-spanner"")
}
----

This setup takes care of bringing in the latest compatible version of Cloud Java Cloud Spanner libraries as well.

=== Configuration

To setup Spring Data Cloud Spanner, you have to configure the following:

* Setup the connection details to Google Cloud Spanner.
* Enable Spring Data Repositories (optional).

==== Cloud Spanner settings

You can the use link:../spring-cloud-gcp-starters/spring-cloud-gcp-starter-data-spanner[Spring Boot Starter for Spring Data Spanner] to autoconfigure Google Cloud Spanner in your Spring application.
It contains all the necessary setup that makes it easy to authenticate with your Google Cloud project.
The following configuration options are available:

|===
| Name | Description | Required | Default value
| `spring.cloud.gcp.spanner.instance-id` | Cloud Spanner instance to use | Yes |
| `spring.cloud.gcp.spanner.database` |
Cloud Spanner database to use | Yes |
| `spring.cloud.gcp.spanner.project-id` | GCP project ID where the Google Cloud Spanner API is hosted, if different from the one in the <<spring-cloud-gcp-core,Spring Cloud GCP Core Module>>
| No |
| `spring.cloud.gcp.spanner.credentials.location` | OAuth2 credentials for authenticating with the
Google Cloud Spanner API, if different from the ones in the
<<spring-cloud-gcp-core,Spring Cloud GCP Core Module>> | No |
| `spring.cloud.gcp.spanner.credentials.encoded-key` | Base64-encoded OAuth2 credentials for authenticating with the
Google Cloud Spanner API, if different from the ones in the
<<spring-cloud-gcp-core,Spring Cloud GCP Core Module>> | No |
| `spring.cloud.gcp.spanner.credentials.scopes` |
https://developers.google.com/identity/protocols/googlescopes[OAuth2 scope] for Spring Cloud GCP
Cloud Spanner credentials | No | https://www.googleapis.com/auth/spanner.data
| `spring.cloud.gcp.spanner.createInterleavedTableDdlOnDeleteCascade` | If `true`, then schema statements generated by `SpannerSchemaUtils` for tables with interleaved parent-child relationships will be ""ON DELETE CASCADE"".
The schema for the tables will be ""ON DELETE NO ACTION"" if `false`. | No | `true`
| `spring.cloud.gcp.spanner.numRpcChannels` | Number of gRPC channels used to connect to Cloud Spanner | No | 4 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.prefetchChunks` | Number of chunks prefetched by Cloud Spanner for read and query | No | 4 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.minSessions` | Minimum number of sessions maintained in the session pool | No | 0 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.maxSessions` | Maximum number of sessions session pool can have | No | 400 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.maxIdleSessions` | Maximum number of idle sessions session pool will maintain | No | 0 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.writeSessionsFraction` | Fraction of sessions to be kept prepared for write transactions | No | 0.2 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.keepAliveIntervalMinutes` | How long to keep idle sessions alive | No | 30 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.failIfPoolExhausted` |  If all sessions are in use, fail the request by throwing an exception. Otherwise, by default, block until a session becomes available. | No | `false`
| `spring.cloud.gcp.spanner.emulator.enabled` |  Enables the usage of an emulator. If this is set to true, then you should set the `spring.cloud.gcp.spanner.emulator-host` to the host:port of your locally running emulator instance. | No | `false`
| `spring.cloud.gcp.spanner.emulator-host` |  The host and port of the Spanner emulator; can be overridden to specify connecting to an already-running https://cloud.google.com/spanner/docs/emulator#installing_and_running_the_emulator[Spanner emulator] instance. | No | `localhost:9010`
|===

==== Repository settings

Spring Data Repositories can be configured via the `@EnableSpannerRepositories` annotation on your main `@Configuration` class.
With our Spring Boot Starter for Spring Data Cloud Spanner, `@EnableSpannerRepositories` is automatically added.
It is not required to add it to any other class, unless there is a need to override finer grain configuration parameters provided by https://github.com/spring-cloud/spring-cloud-gcp/blob/main/spring-cloud-gcp-data-spanner/src/main/java/org/springframework/cloud/gcp/data/spanner/repository/config/EnableSpannerRepositories.java[`@EnableSpannerRepositories`].

==== Autoconfiguration

Our Spring Boot autoconfiguration creates the following beans available in the Spring application context:

- an instance of `SpannerTemplate`
- an instance of `SpannerDatabaseAdminTemplate` for generating table schemas from object hierarchies and creating and deleting tables and databases
- an instance of all user-defined repositories extending `SpannerRepository`, `CrudRepository`, `PagingAndSortingRepository`, when repositories are enabled
- an instance of `DatabaseClient` from the Google Cloud Java Client for Spanner, for convenience and lower level API access


=== Object Mapping

Spring Data Cloud Spanner allows you to map domain POJOs to Cloud Spanner tables via annotations:

[source,java]
----
@Table(name = ""traders"")
public class Trader {

	@PrimaryKey
	@Column(name = ""trader_id"")
	String traderId;

	String firstName;

	String lastName;

	@NotMapped
	Double temporaryNumber;
}
----

Spring Data Cloud Spanner will ignore any property annotated with `@NotMapped`.
These properties will not be written to or read from Spanner.

==== Constructors

Simple constructors are supported on POJOs.
The constructor arguments can be a subset of the persistent properties.
Every constructor argument needs to have the same name and type as a persistent property on the entity and the constructor should set the property from the given argument.
Arguments that are not directly set to properties are not supported.

[source,java]
----
@Table(name = ""traders"")
public class Trader {
	@PrimaryKey
	@Column(name = ""trader_id"")
	String traderId;

	String firstName;

	String lastName;

	@NotMapped
	Double temporaryNumber;

	public Trader(String traderId, String firstName) {
	    this.traderId = traderId;
	    this.firstName = firstName;
	}
}
----


==== Table

The `@Table` annotation can provide the name of the Cloud Spanner table that stores instances of the annotated class, one per row.
This annotation is optional, and if not given, the name of the table is inferred from the class name with the first character uncapitalized.

===== SpEL expressions for table names

In some cases, you might want the `@Table` table name to be determined dynamically.
To do that, you can use https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#expressions[Spring Expression Language].

For example:

[source, java]
----

@Table(name = ""trades_#{tableNameSuffix}"")
public class Trade {
	// ...
}
----

The table name will be resolved only if the `tableNameSuffix` value/bean in the Spring application context is defined.
For example, if `tableNameSuffix` has the value ""123"", the table name will resolve to `trades_123`.

==== Primary Keys

For a simple table, you may only have a primary key consisting of a single column.
Even in that case, the `@PrimaryKey` annotation is required.
`@PrimaryKey` identifies the one or more ID properties corresponding to the primary key.

Spanner has first class support for composite primary keys of multiple columns.
You have to annotate all of your POJO's fields that the primary key consists of with `@PrimaryKey` as below:

[source,java]
----
@Table(name = ""trades"")
public class Trade {
	@PrimaryKey(keyOrder = 2)
	@Column(name = ""trade_id"")
	private String tradeId;

	@PrimaryKey(keyOrder = 1)
	@Column(name = ""trader_id"")
	private String traderId;

	private String action;

	private BigDecimal price;

	private Double shares;

	private String symbol;
}
----

The `keyOrder` parameter of `@PrimaryKey` identifies the properties corresponding to the primary key columns in order, starting with 1 and increasing consecutively.
Order is important and must reflect the order defined in the Cloud Spanner schema.
In our example the DDL to create the table and its primary key is as follows:

[source,sql]
----
CREATE TABLE trades (
    trader_id STRING(MAX),
    trade_id STRING(MAX),
    action STRING(15),
    symbol STRING(10),
    price NUMERIC,
    shares FLOAT64
) PRIMARY KEY (trader_id, trade_id)
----

Spanner does not have automatic ID generation.
For most use-cases, sequential IDs should be used with caution to avoid creating data hotspots in the system.
Read https://cloud.google.com/spanner/docs/schema-and-data-model#primary_keys[Spanner Primary Keys documentation] for a better understanding of primary keys and recommended practices.


==== Columns

All accessible properties on POJOs are automatically recognized as a Cloud Spanner column.
Column naming is generated by the `PropertyNameFieldNamingStrategy` by default defined on the `SpannerMappingContext` bean.
The `@Column` annotation optionally provides a different column name than that of the property and some other settings:

- `name` is the optional name of the column
- `spannerTypeMaxLength` specifies for `STRING` and `BYTES` columns the maximum length.
This setting is only used when generating DDL schema statements based on domain types.
- `nullable` specifies if the column is created as `NOT NULL`.
This setting is only used when generating DDL schema statements based on domain types.
- `spannerType` is the Cloud Spanner column type you can optionally specify.
If this is not specified then a compatible column type is inferred from the Java property type.
- `spannerCommitTimestamp` is a boolean specifying if this property corresponds to an auto-populated commit timestamp column.
Any value set in this property will be ignored when writing to Cloud Spanner.


==== Embedded Objects

If an object of type `B` is embedded as a property of `A`, then the columns of `B` will be saved in the same Cloud Spanner table as those of `A`.

If `B` has primary key columns, those columns will be included in the primary key of `A`. `B` can also have embedded properties.
Embedding allows reuse of columns between multiple entities, and can be useful for implementing parent-child situations, because Cloud Spanner requires child tables to include the key columns of their parents.

For example:

[source,java]
----
class X {
  @PrimaryKey
  String grandParentId;

  long age;
}

class A {
  @PrimaryKey
  @Embedded
  X grandParent;

  @PrimaryKey(keyOrder = 2)
  String parentId;

  String value;
}

@Table(name = ""items"")
class B {
  @PrimaryKey
  @Embedded
  A parent;

  @PrimaryKey(keyOrder = 2)
  String id;

  @Column(name = ""child_value"")
  String value;
}
----

Entities of `B` can be stored in a table defined as:

[source,sql]
----
CREATE TABLE items (
    grandParentId STRING(MAX),
    parentId STRING(MAX),
    id STRING(MAX),
    value STRING(MAX),
    child_value STRING(MAX),
    age INT64
) PRIMARY KEY (grandParentId, parentId, id)
----

Note that embedded properties' column names must all be unique.


==== Relationships

Spring Data Cloud Spanner supports parent-child relationships using the Cloud Spanner https://cloud.google.com/spanner/docs/schema-and-data-model#creating-interleaved-tables[parent-child interleaved table mechanism].
Cloud Spanner interleaved tables enforce the one-to-many relationship and provide efficient queries and operations on entities of a single domain parent entity.
These relationships can be up to 7 levels deep.
Cloud Spanner also provides automatic cascading delete or enforces the deletion of child entities before parents.

While one-to-one and many-to-many relationships can be implemented in Cloud Spanner and Spring Data Cloud Spanner using constructs of interleaved parent-child tables, only the parent-child relationship is natively supported.
Cloud Spanner does not support the foreign key constraint, though the parent-child key constraint enforces a similar requirement when used with interleaved tables.

For example, the following Java entities:

[source,java]
----
@Table(name = ""Singers"")
class Singer {
  @PrimaryKey
  long SingerId;

  String FirstName;

  String LastName;

  byte[] SingerInfo;

  @Interleaved
  List<Album> albums;
}

@Table(name = ""Albums"")
class Album {
  @PrimaryKey
  long SingerId;

  @PrimaryKey(keyOrder = 2)
  long AlbumId;

  String AlbumTitle;
}
----

These classes can correspond to an existing pair of interleaved tables.
The `@Interleaved` annotation may be applied to `Collection` properties and the inner type is resolved as the child entity type.
The schema needed to create them can also be generated using the `SpannerSchemaUtils` and run by using the `SpannerDatabaseAdminTemplate`:

[source,java]
----

@Autowired
SpannerSchemaUtils schemaUtils;

@Autowired
SpannerDatabaseAdminTemplate databaseAdmin;
...

// Get the create statmenets for all tables in the table structure rooted at Singer
List<String> createStrings = this.schemaUtils.getCreateTableDdlStringsForInterleavedHierarchy(Singer.class);

// Create the tables and also create the database if necessary
this.databaseAdmin.executeDdlStrings(createStrings, true);
----

The `createStrings` list contains table schema statements using column names and types compatible with the provided Java type and any resolved child relationship types contained within based on the configured custom converters.

[source,sql]
----
CREATE TABLE Singers (
  SingerId   INT64 NOT NULL,
  FirstName  STRING(1024),
  LastName   STRING(1024),
  SingerInfo BYTES(MAX),
) PRIMARY KEY (SingerId);

CREATE TABLE Albums (
  SingerId     INT64 NOT NULL,
  AlbumId      INT64 NOT NULL,
  AlbumTitle   STRING(MAX),
) PRIMARY KEY (SingerId, AlbumId),
  INTERLEAVE IN PARENT Singers ON DELETE CASCADE;
----

The `ON DELETE CASCADE` clause indicates that Cloud Spanner will delete all Albums of a singer if the Singer is deleted.
The alternative is `ON DELETE NO ACTION`, where a Singer cannot be deleted until all of its Albums have already been deleted.
When using `SpannerSchemaUtils` to generate the schema strings, the `spring.cloud.gcp.spanner.createInterleavedTableDdlOnDeleteCascade` boolean setting determines if these schema are generated as `ON DELETE CASCADE` for `true` and `ON DELETE NO ACTION` for `false`.

Cloud Spanner restricts these relationships to 7 child layers.
A table may have multiple child tables.

On updating or inserting an object to Cloud Spanner, all of its referenced children objects are also updated or inserted in the same request, respectively.
On read, all of the interleaved child rows are also all read.

===== Lazy Fetch

`@Interleaved` properties are retrieved eagerly by default, but can be fetched lazily for performance in both read and write:

[source,java]
----
@Interleaved(lazy = true)
List<Album> albums;
----

Lazily-fetched interleaved properties are retrieved upon the first interaction with the property.
If a property marked for lazy fetching is never retrieved, then it is also skipped when saving the parent entity.

If used inside a transaction, subsequent operations on lazily-fetched properties use the same transaction context as that of the original parent entity.

===== Declarative Filtering with `@Where`
The `@Where` annotation could be applied to an entity class or to an interleaved property.
This annotation provides an SQL where clause that will be applied at the fetching of interleaved collections or the entity itself.

Let's say we have an `Agreement` with a list of `Participants` which could be assigned to it.
We would like to fetch a list of currently active participants.
For security reasons, all records should remain in the database forever, even if participants become inactive.
That can be easily achieved with the `@Where` annotation, which is demonstrated by this example:

[source, java]
----
@Table(name = ""participants"")
public class Participant {
  //...
  boolean active;
  //...
}

@Table(name = ""agreements"")
public class Agreement {
  //...
  @Interleaved
  @Where(""active = true"")
  List<Participant> participants;
  Person person;
  //...
}
----

==== Supported Types

Spring Data Cloud Spanner natively supports the following types for regular fields but also utilizes custom converters (detailed in following sections) and dozens of pre-defined Spring Data custom converters to handle other common Java types.

Natively supported types:

* `com.google.cloud.ByteArray`
* `com.google.cloud.Date`
* `com.google.cloud.Timestamp`
* `java.lang.Boolean`, `boolean`
* `java.lang.Double`, `double`
* `java.lang.Long`, `long`
* `java.lang.Integer`, `int`
* `java.lang.String`
* `double[]`
* `long[]`
* `boolean[]`
* `java.util.Date`
* `java.time.Instant`
* `java.sql.Date`
* `java.time.LocalDate`
* `java.time.LocalDateTime`


==== Lists

Spanner supports `ARRAY` types for columns.
`ARRAY` columns are mapped to `List` fields in POJOS.

Example:

[source,java]
----
List<Double> curve;
----

The types inside the lists can be any singular property type.

==== Lists of Structs

Cloud Spanner queries can https://cloud.google.com/spanner/docs/query-syntax#using-structs-with-select[construct STRUCT values] that appear as columns in the result.
Cloud Spanner requires STRUCT values appear in ARRAYs at the root level: `SELECT ARRAY(SELECT STRUCT(1 as val1, 2 as val2)) as pair FROM Users`.

Spring Data Cloud Spanner will attempt to read the column STRUCT values into a property that is an `Iterable` of an entity type compatible with the schema of the column STRUCT value.


For the previous array-select example, the following property can be mapped with the constructed `ARRAY<STRUCT>` column: `List<TwoInts> pair;` where the `TwoInts` type is defined:

[source, java]
----
class TwoInts {

  int val1;

  int val2;
}
----

==== Custom types

Custom converters can be used to extend the type support for user defined types.

. Converters need to implement the `org.springframework.core.convert.converter.Converter` interface in both directions.
. The user defined type needs to be mapped to one of the basic types supported by Spanner:

* `com.google.cloud.ByteArray`
* `com.google.cloud.Date`
* `com.google.cloud.Timestamp`
* `java.lang.Boolean`, `boolean`
* `java.lang.Double`, `double`
* `java.lang.Long`, `long`
* `java.lang.String`
* `double[]`
* `long[]`
* `boolean[]`
* `enum` types

. An instance of both Converters needs to be passed to a `ConverterAwareMappingSpannerEntityProcessor`, which then has to be made available as a `@Bean` for `SpannerEntityProcessor`.

For example:

We would like to have a field of type `Person` on our `Trade` POJO:
[source, java]
----

@Table(name = ""trades"")
public class Trade {
  //...
  Person person;
  //...
}
----

Where Person is a simple class:

[source, java]
----
public class Person {

  public String firstName;
  public String lastName;

}
----

We have to define the two converters:

[source, java]
----
  public class PersonWriteConverter implements Converter<Person, String> {

    @Override
    public String convert(Person person) {
      return person.firstName + "" "" + person.lastName;
    }
  }

  public class PersonReadConverter implements Converter<String, Person> {

    @Override
    public Person convert(String s) {
      Person person = new Person();
      person.firstName = s.split("" "")[0];
      person.lastName = s.split("" "")[1];
      return person;
    }
  }
----

That will be configured in our `@Configuration` file:

[source, java]
----
@Configuration
public class ConverterConfiguration {

	@Bean
	public SpannerEntityProcessor spannerEntityProcessor(SpannerMappingContext spannerMappingContext) {
		return new ConverterAwareMappingSpannerEntityProcessor(spannerMappingContext,
				Arrays.asList(new PersonWriteConverter()),
				Arrays.asList(new PersonReadConverter()));
	}
}
----

==== Custom Converter for Struct Array Columns
If a `Converter<Struct, A>` is provided, then properties of type `List<A>` can be used in your entity types.


=== Spanner Operations & Template

`SpannerOperations` and its implementation, `SpannerTemplate`, provides the Template pattern familiar to Spring developers.
It provides:

 - Resource management
 - One-stop-shop to Spanner operations with the Spring Data POJO mapping and conversion features
 - Exception conversion

Using the `autoconfigure` provided by our Spring Boot Starter for Spanner, your Spring application context will contain a fully configured `SpannerTemplate` object that you can easily autowire in your application:

[source,java]
----
@SpringBootApplication
public class SpannerTemplateExample {

	@Autowired
	SpannerTemplate spannerTemplate;

	public void doSomething() {
		this.spannerTemplate.delete(Trade.class, KeySet.all());
		//...
		Trade t = new Trade();
		//...
		this.spannerTemplate.insert(t);
		//...
		List<Trade> tradesByAction = spannerTemplate.findAll(Trade.class);
		//...
	}
}
----

The Template API provides convenience methods for:

- https://cloud.google.com/spanner/docs/reads[Reads], and by providing SpannerReadOptions and
SpannerQueryOptions
   ** Stale read
   ** Read with secondary indices
   ** Read with limits and offsets
   ** Read with sorting
- https://cloud.google.com/spanner/docs/reads#execute_a_query[Queries]
- DML operations (delete, insert, update, upsert)
- Partial reads
   ** You can define a set of columns to be read into your entity
- Partial writes
   ** Persist only a few properties from your entity
- Read-only transactions
- Locking read-write transactions

==== SQL Query

Cloud Spanner has SQL support for running read-only queries.
All the query related methods start with `query` on `SpannerTemplate`.
By using `SpannerTemplate`, you can run SQL queries that map to POJOs:

[source,java]
----
List<Trade> trades = this.spannerTemplate.query(Trade.class, Statement.of(""SELECT * FROM trades""));
----

==== Read

Spanner exposes a https://cloud.google.com/spanner/docs/reads[Read API] for reading single row or multiple rows in a table or in a secondary index.

Using `SpannerTemplate` you can run reads, as the following example shows:

[source,java]
----
List<Trade> trades = this.spannerTemplate.readAll(Trade.class);
----

Main benefit of reads over queries is reading multiple rows of a certain pattern of keys is much easier using the features of the https://github.com/GoogleCloudPlatform/google-cloud-java/blob/main/google-cloud-spanner/src/main/java/com/google/cloud/spanner/KeySet.java[`KeySet`] class.


==== Advanced reads

===== Stale read

All reads and queries are *strong reads* by default.
A *strong read* is a read at a current time and is guaranteed to see all data that has been committed up until the start of this read.
An *exact staleness read* is read at a timestamp in the past.
Cloud Spanner allows you to determine how current the data should be when you read data.
With `SpannerTemplate` you can specify the `Timestamp` by setting it on `SpannerQueryOptions` or `SpannerReadOptions` to the appropriate read or query methods:

Reads:

[source,java]
----
// a read with options:
SpannerReadOptions spannerReadOptions = new SpannerReadOptions().setTimestamp(myTimestamp);
List<Trade> trades = this.spannerTemplate.readAll(Trade.class, spannerReadOptions);
----

Queries:

[source,java]
----
// a query with options:
SpannerQueryOptions spannerQueryOptions = new SpannerQueryOptions().setTimestamp(myTimestamp);
List<Trade> trades = this.spannerTemplate.query(Trade.class, Statement.of(""SELECT * FROM trades""), spannerQueryOptions);
----

You can also read with https://cloud.google.com/spanner/docs/timestamp-bounds[*bounded staleness*] by setting `.setTimestampBound(TimestampBound.ofMinReadTimestamp(myTimestamp))` on the query and read options objects.
Bounded staleness lets Cloud Spanner choose any point in time later than or equal to the given timestampBound, but it cannot be used inside transactions.


===== Read from a secondary index

Using a https://cloud.google.com/spanner/docs/secondary-indexes[secondary index] is available for Reads via the Template API and it is also implicitly available via SQL for Queries.

The following shows how to read rows from a table using a https://cloud.google.com/spanner/docs/secondary-indexes[secondary index] simply by setting `index` on `SpannerReadOptions`:

[source,java]
----
SpannerReadOptions spannerReadOptions = new SpannerReadOptions().setIndex(""TradesByTrader"");
List<Trade> trades = this.spannerTemplate.readAll(Trade.class, spannerReadOptions);
----


===== Read with offsets and limits

Limits and offsets are only supported by Queries.
The following will get only the first two rows of the query:

[source,java]
----
SpannerQueryOptions spannerQueryOptions = new SpannerQueryOptions().setLimit(2).setOffset(3);
List<Trade> trades = this.spannerTemplate.query(Trade.class, Statement.of(""SELECT * FROM trades""), spannerQueryOptions);
----

Note that the above is equivalent of running `SELECT * FROM trades LIMIT 2 OFFSET 3`.

===== Sorting

Reads by keys do not support sorting.
However, queries on the Template API support sorting through standard SQL and also via Spring Data Sort API:

[source,java]
----
List<Trade> trades = this.spannerTemplate.queryAll(Trade.class, Sort.by(""action""));
----

If the provided sorted field name is that of a property of the domain type, then the column name corresponding to that property will be used in the query.
Otherwise, the given field name is assumed to be the name of the column in the Cloud Spanner table.
Sorting on columns of Cloud Spanner types STRING and BYTES can be done while ignoring case:

[source,java]
----
Sort.by(Order.desc(""action"").ignoreCase())
----

===== Partial read

Partial read is only possible when using Queries.
In case the rows returned by the query have fewer columns than the entity that it will be mapped to, Spring Data will map the returned columns only.
This setting also applies to nested structs and their corresponding nested POJO properties.

[source,java]
----
List<Trade> trades = this.spannerTemplate.query(Trade.class, Statement.of(""SELECT action, symbol FROM trades""),
    new SpannerQueryOptions().setAllowMissingResultSetColumns(true));
----

If the setting is set to `false`, then an exception will be thrown if there are missing columns in the query result.

===== Summary of options for Query vs Read

|===
| Feature | Query supports it | Read supports it
| SQL  | yes | no
| Partial read | yes | no
| Limits | yes | no
| Offsets | yes | no
| Secondary index | yes | yes
| Read using index range | no | yes
| Sorting | yes | no
|===

==== Write / Update

The write methods of `SpannerOperations` accept a POJO and writes all of its properties to Spanner.
The corresponding Spanner table and entity metadata is obtained from the given object's actual type.

If a POJO was retrieved from Spanner and its primary key properties values were changed and then written or updated, the operation will occur as if against a row with the new primary key values.
The row with the original primary key values will not be affected.

===== Insert

The `insert` method of `SpannerOperations` accepts a POJO and writes all of its properties to Spanner, which means the operation will fail if a row with the POJO's primary key already exists in the table.

[source, java]
----
Trade t = new Trade();
this.spannerTemplate.insert(t);
----

===== Update

The `update` method of `SpannerOperations` accepts a POJO and writes all of its properties to Spanner, which means the operation will fail if the POJO's primary key does not already exist in the table.

[source, java]
----
// t was retrieved from a previous operation
this.spannerTemplate.update(t);
----

===== Upsert

The `upsert` method of `SpannerOperations` accepts a POJO and writes all of its properties to Spanner using update-or-insert.

[source, java]
----
// t was retrieved from a previous operation or it's new
this.spannerTemplate.upsert(t);
----

===== Partial Update

The update methods of `SpannerOperations` operate by default on all properties within the given object, but also accept `String[]` and `Optional<Set<String>>` of column names.
If the `Optional` of set of column names is empty, then all columns are written to Spanner.
However, if the Optional is occupied by an empty set, then no columns will be written.


[source, java]
----
// t was retrieved from a previous operation or it's new
this.spannerTemplate.update(t, ""symbol"", ""action"");
----

==== DML

DML statements can be run by using `SpannerOperations.executeDmlStatement`.
Inserts, updates, and deletions can affect any number of rows and entities.

You can run https://cloud.google.com/spanner/docs/dml-partitioned[partitioned DML] updates by using the `executePartitionedDmlStatement` method.
Partitioned DML queries have performance benefits but also have restrictions and cannot be used inside transactions.

==== Transactions

`SpannerOperations` provides methods to run `java.util.Function` objects within a single transaction while making available the read and write methods from `SpannerOperations`.

===== Read/Write Transaction

Read and write transactions are provided by `SpannerOperations` via the `performReadWriteTransaction` method:

[source,java]
----

@Autowired
SpannerOperations mySpannerOperations;

public String doWorkInsideTransaction() {
  return mySpannerOperations.performReadWriteTransaction(
    transActionSpannerOperations -> {
      // Work with transActionSpannerOperations here.
      // It is also a SpannerOperations object.

      return ""transaction completed"";
    }
  );
}
----

The `performReadWriteTransaction` method accepts a `Function` that is provided an instance of a `SpannerOperations` object.
The final returned value and type of the function is determined by the user.
You can use this object just as you would a regular `SpannerOperations` with a few exceptions:

- Its read functionality cannot perform stale reads, because all reads and writes happen at the single point in time of the transaction.
- It cannot perform sub-transactions via `performReadWriteTransaction` or `performReadOnlyTransaction`.

As these read-write transactions are locking, it is recommended that you use the `performReadOnlyTransaction` if your function does not perform any writes.

===== Read-only Transaction

The `performReadOnlyTransaction` method is used to perform read-only transactions using a `SpannerOperations`:

[source,java]
----

@Autowired
SpannerOperations mySpannerOperations;

public String doWorkInsideTransaction() {
  return mySpannerOperations.performReadOnlyTransaction(
    transActionSpannerOperations -> {
      // Work with transActionSpannerOperations here.
      // It is also a SpannerOperations object.

      return ""transaction completed"";
    }
  );
}
----

The `performReadOnlyTransaction` method accepts a `Function` that is provided an instance of a
`SpannerOperations` object.
This method also accepts a `ReadOptions` object, but the only attribute used is the timestamp used to determine the snapshot in time to perform the reads in the transaction.
If the timestamp is not set in the read options the transaction is run against the current state of the database.
The final returned value and type of the function is determined by the user.
You can use this object just as you would a regular `SpannerOperations` with
a few exceptions:

- Its read functionality cannot perform stale reads (other than the staleness set on the entire transaction), because all reads happen at the single point in time of the transaction.
- It cannot perform sub-transactions via `performReadWriteTransaction` or `performReadOnlyTransaction`
- It cannot perform any write operations.

Because read-only transactions are non-locking and can be performed on points in time in the past, these are recommended for functions that do not perform write operations.

===== Declarative Transactions with @Transactional Annotation

This feature requires a bean of `SpannerTransactionManager`, which is provided when using `spring-cloud-gcp-starter-data-spanner`.

`SpannerTemplate` and `SpannerRepository` support running methods with the `@Transactional` https://docs.spring.io/spring/docs/current/spring-framework-reference/data-access.html#transaction-declarative[annotation] as transactions.
If a method annotated with `@Transactional` calls another method also annotated, then both methods will work within the same transaction.
`performReadOnlyTransaction` and `performReadWriteTransaction` cannot be used in `@Transactional` annotated methods because Cloud Spanner does not support transactions within transactions.

==== DML Statements

`SpannerTemplate` supports https://cloud.google.com/spanner/docs/dml-tasks:[DML] `Statements`.
DML statements can also be run in transactions by using `performReadWriteTransaction` or by using the `@Transactional` annotation.

=== Repositories

{spring-data-commons-ref}/#repositories[Spring Data Repositories] are a powerful abstraction that can save you a lot of boilerplate code.

For example:

[source,java]
----
public interface TraderRepository extends SpannerRepository<Trader, String> {
}
----

Spring Data generates a working implementation of the specified interface, which can be conveniently autowired into an application.

The `Trader` type parameter to `SpannerRepository` refers to the underlying domain type.
The second type parameter, `String` in this case, refers to the type of the key of the domain type.


For POJOs with a composite primary key, this ID type parameter can be any descendant of `Object[]` compatible with all primary key properties, any descendant of `Iterable`, or `com.google.cloud.spanner.Key`.
If the domain POJO type only has a single primary key column, then the primary key property type can be used or the `Key` type.

For example in case of Trades, that belong to a Trader, `TradeRepository` would look like this:

[source,java]
----
public interface TradeRepository extends SpannerRepository<Trade, String[]> {

}
----

[source,java]
----
public class MyApplication {

	@Autowired
	SpannerTemplate spannerTemplate;

	@Autowired
	StudentRepository studentRepository;

	public void demo() {

		this.tradeRepository.deleteAll();
		String traderId = ""demo_trader"";
		Trade t = new Trade();
		t.symbol = stock;
		t.action = action;
		t.traderId = traderId;
		t.price = new BigDecimal(""100.0"");
		t.shares = 12345.6;
		this.spannerTemplate.insert(t);

		Iterable<Trade> allTrades = this.tradeRepository.findAll();

		int count = this.tradeRepository.countByAction(""BUY"");

	}
}

----

==== CRUD Repository

`CrudRepository` methods work as expected, with one thing Spanner specific: the `save` and `saveAll` methods work as update-or-insert.

==== Paging and Sorting Repository

You can also use `PagingAndSortingRepository` with Spanner Spring Data.
The sorting and pageable `findAll` methods available from this interface operate on the current state of the Spanner database.
As a result, beware that the state of the database (and the results) might change when moving page to page.

==== Spanner Repository

The `SpannerRepository` extends the `PagingAndSortingRepository`, but adds the read-only and the read-write transaction functionality provided by Spanner.
These transactions work very similarly to those of `SpannerOperations`, but is specific to the repository's domain type and provides repository functions instead of template functions.

For example, this is a read-only transaction:

[source,java]
----

@Autowired
SpannerRepository myRepo;

public String doWorkInsideTransaction() {
  return myRepo.performReadOnlyTransaction(
    transactionSpannerRepo -> {
      // Work with the single-transaction transactionSpannerRepo here.
      // This is a SpannerRepository object.

      return ""transaction completed"";
    }
  );
}
----

When creating custom repositories for your own domain types and query methods, you can extend `SpannerRepository` to access Cloud Spanner-specific features as well as all features from `PagingAndSortingRepository` and `CrudRepository`.

=== Query Methods

`SpannerRepository` supports Query Methods.
Described in the following sections, these are methods residing in your custom repository interfaces of which implementations are generated based on their names and annotations.
Query Methods can read, write, and delete entities in Cloud Spanner.
Parameters to these methods can be any Cloud Spanner data type supported directly or via custom configured converters.
Parameters can also be of type `Struct` or POJOs.
If a POJO is given as a parameter, it will be converted to a `Struct` with the same type-conversion logic as used to create write mutations.
Comparisons using Struct parameters are limited to https://cloud.google.com/spanner/docs/data-types#limited-comparisons-for-struct[what is available with Cloud Spanner].


==== Query methods by convention

[source, java]
----
public interface TradeRepository extends SpannerRepository<Trade, String[]> {
    List<Trade> findByAction(String action);

	int countByAction(String action);

	// Named methods are powerful, but can get unwieldy
	List<Trade> findTop3DistinctByActionAndSymbolIgnoreCaseOrTraderIdOrderBySymbolDesc(
  			String action, String symbol, String traderId);
}
----

In the example above, the {spring-data-commons-ref}/#repositories.query-methods[query methods] in `TradeRepository` are generated based on the name of the methods, using the {spring-data-commons-ref}#repositories.query-methods.query-creation[Spring Data Query creation naming convention].

`List<Trade> findByAction(String action)` would translate to a `SELECT * FROM trades WHERE action = ?`.

The function `List<Trade> findTop3DistinctByActionAndSymbolIgnoreCaseOrTraderIdOrderBySymbolDesc(String action, String symbol, String traderId);` will be translated as the equivalent of this SQL query:

[source, sql]
----
SELECT DISTINCT * FROM trades
WHERE ACTION = ? AND LOWER(SYMBOL) = LOWER(?) AND TRADER_ID = ?
ORDER BY SYMBOL DESC
LIMIT 3
----

The following filter options are supported:

* Equality
* Greater than or equals
* Greater than
* Less than or equals
* Less than
* Is null
* Is not null
* Is true
* Is false
* Like a string
* Not like a string
* Contains a string
* Not contains a string
* In
* Not in

Note that the phrase `SymbolIgnoreCase` is translated to `LOWER(SYMBOL) = LOWER(?)` indicating a non-case-sensitive matching.
The `IgnoreCase` phrase may only be appended to fields that correspond to columns of type STRING or BYTES.
The Spring Data ""AllIgnoreCase"" phrase appended at the end of the method name is not supported.

The `Like` or `NotLike` naming conventions:
[source, java]
----
List<Trade> findBySymbolLike(String symbolFragment);
----
The param `symbolFragment` can contain https://cloud.google.com/spanner/docs/functions-and-operators#comparison-operators[wildcard characters] for string matching such as `_` and `%`.

The `Contains` and `NotContains` naming conventions:
[source, java]
----
List<Trade> findBySymbolContains(String symbolFragment);
----
The param `symbolFragment` is a https://cloud.google.com/spanner/docs/functions-and-operators#regexp_contains[regular expression] that is checked for occurrences.

The `In` and `NotIn` keywords must be used with `Iterable` corresponding parameters.

Delete queries are also supported.
For example, query methods such as `deleteByAction` or `removeByAction` delete entities found by `findByAction`.
The delete operation happens in a single transaction.

Delete queries can have the following return types:
* An integer type that is the number of entities deleted
* A collection of entities that were deleted
* `void`

==== Custom SQL/DML query methods

The example above for `List<Trade> fetchByActionNamedQuery(String action)` does not match the {spring-data-commons-ref}#repositories.query-methods.query-creation[Spring Data Query creation naming convention], so we have to map a parametrized Spanner SQL query to it.

The SQL query for the method can be mapped to repository methods in one of two ways:

 * `namedQueries` properties file
 * using the `@Query` annotation

The names of the tags of the SQL correspond to the `@Param` annotated names of the method parameters.

Interleaved properties are loaded eagerly, unless they are annotated with `@Interleaved(lazy = true)`.

Custom SQL query methods can accept a single `Sort` or `Pageable` parameter that is applied on top of the specified custom query.
It is the recommended way to control the sort order of the results, which is not guaranteed by the `ORDER BY` clause in the SQL query.
This is due to the fact that the user-provided query is used as a sub-query, and Cloud Spanner doesn't preserve order in subquery results.

You might want to use `ORDER BY` with `LIMIT` to obtain the top records, according to a specified order.
However, to ensure the correct sort order of the final result set, sort options have to be passed in with a `Pageable`.

[source, java]
----
	@Query(""SELECT * FROM trades"")
	List<Trade> fetchTrades(Pageable pageable);

	@Query(""SELECT * FROM trades ORDER BY price DESC LIMIT 1"")
 	Trade topTrade(Pageable pageable);

----

This can be used:

[source, java]
----
	List<Trade> customSortedTrades = tradeRepository.fetchTrades(PageRequest
  				.of(2, 2, org.springframework.data.domain.Sort.by(Order.asc(""id""))));
----

The results would be sorted by ""id"" in ascending order.

Your query method can also return non-entity types:
[source, java]
----
  	@Query(""SELECT COUNT(1) FROM trades WHERE action = @action"")
  	int countByActionQuery(String action);

  	@Query(""SELECT EXISTS(SELECT COUNT(1) FROM trades WHERE action = @action)"")
  	boolean existsByActionQuery(String action);

  	@Query(""SELECT action FROM trades WHERE action = @action LIMIT 1"")
  	String getFirstString(@Param(""action"") String action);

  	@Query(""SELECT action FROM trades WHERE action = @action"")
  	List<String> getFirstStringList(@Param(""action"") String action);
----

DML statements can also be run by query methods, but the only possible return value is a `long` representing the number of affected rows.
The `dmlStatement` boolean setting must be set on `@Query` to indicate that the query method is run as a DML statement.

[source, java]
----
  	@Query(value = ""DELETE FROM trades WHERE action = @action"", dmlStatement = true)
  	long deleteByActionQuery(String action);
----

===== Query methods with named queries properties

By default, the `namedQueriesLocation` attribute on `@EnableSpannerRepositories` points to the `META-INF/spanner-named-queries.properties` file.
You can specify the query for a method in the properties file by providing the SQL as the value for the ""interface.method"" property:

[source, properties]
----
Trade.fetchByActionNamedQuery=SELECT * FROM trades WHERE trades.action = @tag0
----

[source, java]
----
public interface TradeRepository extends SpannerRepository<Trade, String[]> {
	// This method uses the query from the properties file instead of one generated based on name.
	List<Trade> fetchByActionNamedQuery(@Param(""tag0"") String action);
}
----
===== Query methods with annotation

Using the `@Query` annotation:

[source, java]
----
public interface TradeRepository extends SpannerRepository<Trade, String[]> {
    @Query(""SELECT * FROM trades WHERE trades.action = @tag0"")
    List<Trade> fetchByActionNamedQuery(@Param(""tag0"") String action);
}
----

Table names can be used directly.
For example, ""trades"" in the above example.
Alternatively, table names can be resolved from the `@Table` annotation on domain classes as well.
In this case, the query should refer to table names with fully qualified class names between `:`
characters: `:fully.qualified.ClassName:`.
A full example would look like:

[source, java]
----
@Query(""SELECT * FROM :com.example.Trade: WHERE trades.action = @tag0"")
List<Trade> fetchByActionNamedQuery(String action);
----

This allows table names evaluated with SpEL to be used in custom queries.

SpEL can also be used to provide SQL parameters:

[source, java]
----
@Query(""SELECT * FROM :com.example.Trade: WHERE trades.action = @tag0
  AND price > #{#priceRadius * -1} AND price < #{#priceRadius * 2}"")
List<Trade> fetchByActionNamedQuery(String action, Double priceRadius);
----

When using the `IN` SQL clause, remember to use `IN UNNEST(@iterableParam)` to specify a single `Iterable` parameter.
You can also use a fixed number of singular parameters such as `IN (@stringParam1, @stringParam2)`.

==== Projections
Spring Data Spanner supports {spring-data-commons-ref}/#projections[projections].
You can define projection interfaces based on domain types and add query methods that return them in your repository:

[source, java]
----
public interface TradeProjection {

	String getAction();

	@Value(""#{target.symbol + ' ' + target.action}"")
	String getSymbolAndAction();
}

public interface TradeRepository extends SpannerRepository<Trade, Key> {

	List<Trade> findByTraderId(String traderId);

	List<TradeProjection> findByAction(String action);

	@Query(""SELECT action, symbol FROM trades WHERE action = @action"")
	List<TradeProjection> findByQuery(String action);
}
----

Projections can be provided by name-convention-based query methods as well as by custom SQL queries.
If using custom SQL queries, you can further restrict the columns retrieved from Spanner to just those required by the projection to improve performance.

Properties of projection types defined using SpEL use the fixed name `target` for the underlying domain object.
As a result accessing underlying properties take the form `target.<property-name>`.

==== Empty result handling in repository methods
Java `java.util.Optional` can be used to indicate the potential absence of a return value.

Alternatively, query methods can return the result without a wrapper.
In that case the absence of a query result is indicated by returning `null`.
Repository methods returning collections are guaranteed never to return `null` but rather the corresponding empty collection.

NOTE: You can enable nullability checks. For more details please see https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#null-safety[Spring Framework’s nullability docs].

==== REST Repositories

When running with Spring Boot, repositories can be exposed as REST services by simply adding this dependency to your pom file:
[source,xml]
----
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>
----

If you prefer to configure parameters (such as path), you can use `@RepositoryRestResource` annotation:
[source,java]
----
@RepositoryRestResource(collectionResourceRel = ""trades"", path = ""trades"")
public interface TradeRepository extends SpannerRepository<Trade, Key> {
}
----

NOTE: For classes that have composite keys (multiple `@PrimaryKey` fields), only the `Key` type is supported for the repository ID type.

For example, you can retrieve all `Trade` objects in the repository by using `curl \\http://<server>:<port>/trades`, or any specific trade via `curl \\http://<server>:<port>/trades/<trader_id>,<trade_id>`.

The separator between your primary key components, `id` and `trader_id` in this case, is a comma by default, but can be configured to any string not found in your key values by extending the `SpannerKeyIdConverter` class:

[source,java]
----
@Component
class MySpecialIdConverter extends SpannerKeyIdConverter {

    @Override
    protected String getUrlIdSeparator() {
        return "":"";
    }
}
----

You can also write trades using `curl -XPOST -H""Content-Type: application/json"" -d@test.json \\http://<server>:<port>/trades/` where the file `test.json` holds the JSON representation of a `Trade` object.

=== Database and Schema Admin

Databases and tables inside Spanner instances can be created automatically from `SpannerPersistentEntity` objects:

[source,java]
----
@Autowired
private SpannerSchemaUtils spannerSchemaUtils;

@Autowired
private SpannerDatabaseAdminTemplate spannerDatabaseAdminTemplate;

public void createTable(SpannerPersistentEntity entity) {
	if(!spannerDatabaseAdminTemplate.tableExists(entity.tableName()){

	  // The boolean parameter indicates that the database will be created if it does not exist.
	  spannerDatabaseAdminTemplate.executeDdlStrings(Arrays.asList(
            spannerSchemaUtils.getCreateTableDDLString(entity.getType())), true);
	}
}
----

Schemas can be generated for entire object hierarchies with interleaved relationships and composite keys.

=== Events

Spring Data Cloud Spanner publishes events extending the Spring Framework's `ApplicationEvent` to the context that can be received by `ApplicationListener` beans you register.

[options=""header""]
|===
| Type| Description | Contents
| `AfterReadEvent`|Published immediately after entities are read by key from Cloud Spanner by `SpannerTemplate`| The entities loaded. The read options and key-set originally specified for the load operation.
| `AfterQueryEvent`|Published immediately after entities are read by query from Cloud Spanner by `SpannerTemplate`| The entities loaded. The query options and query statement originally specified for the load operation.
| `BeforeExecuteDmlEvent`|Published immediately before DML statements are executed by `SpannerTemplate`| The DML statement to execute.
| `AfterExecuteDmlEvent`|Published immediately after DML statements are executed by `SpannerTemplate`| The DML statement to execute and the number of rows affected by the operation as reported by Cloud Spanner.
| `BeforeSaveEvent`|Published immediately before upsert/update/insert operations are executed by `SpannerTemplate`| The mutations to be sent to Cloud Spanner, the entities to be saved, and optionally the properties in those entities to save.
| `AfterSaveEvent`|Published immediately after upsert/update/insert operations are executed by `SpannerTemplate`| The mutations sent to Cloud Spanner, the entities to be saved, and optionally the properties in those entities to save.
| `BeforeDeleteEvent`|Published immediately before delete operations are executed by `SpannerTemplate`| The mutations to be sent to Cloud Spanner. The target entities, keys, or entity type originally specified for the delete operation.
| `AfterDeleteEvent`|Published immediately after delete operations are executed by `SpannerTemplate`| The mutations sent to Cloud Spanner. The target entities, keys, or entity type originally specified for the delete operation.
|===


=== Auditing

Spring Data Cloud Spanner supports the `@LastModifiedDate` and `@LastModifiedBy` auditing annotations for properties:

[source,java]
----
@Table
public class SimpleEntity {
    @PrimaryKey
    String id;

    @LastModifiedBy
    String lastUser;

    @LastModifiedDate
    DateTime lastTouched;
}
----

Upon insert, update, or save, these properties will be set automatically by the framework before mutations are generated and saved to Cloud Spanner.

To take advantage of these features, add the `@EnableSpannerAuditing` annotation to your configuration class and provide a bean for an `AuditorAware<A>` implementation where the type `A` is the desired property type annotated by `@LastModifiedBy`:

[source,java]
----
@Configuration
@EnableSpannerAuditing
public class Config {

    @Bean
    public AuditorAware<String> auditorProvider() {
        return () -> Optional.of(""YOUR_USERNAME_HERE"");
    }
}
----

The `AuditorAware` interface contains a single method that supplies the value for fields annotated by `@LastModifiedBy` and can be of any type.
One alternative is to use Spring Security's `User` type:

[source,java]
----
class SpringSecurityAuditorAware implements AuditorAware<User> {

  public Optional<User> getCurrentAuditor() {

    return Optional.ofNullable(SecurityContextHolder.getContext())
			  .map(SecurityContext::getAuthentication)
			  .filter(Authentication::isAuthenticated)
			  .map(Authentication::getPrincipal)
			  .map(User.class::cast);
  }
}
----

You can also set a custom provider for properties annotated `@LastModifiedDate` by providing a bean for `DateTimeProvider` and providing the bean name to `@EnableSpannerAuditing(dateTimeProviderRef = ""customDateTimeProviderBean"")`.

=== Multi-Instance Usage

Your application can be configured to use multiple Cloud Spanner instances or databases by providing a custom bean for `DatabaseIdProvider`.
The default bean uses the instance ID, database name, and project ID options you configured in `application.properties`.

[source,java]
----
    @Bean
    public DatabaseIdProvider databaseIdProvider() {
        // return custom connection options provider
    }
----

The `DatabaseId` given by this provider is used as the target database name and instance of each operation Spring Data Cloud Spanner executes.
By providing a custom implementation of this bean (for example, supplying a thread-local `DatabaseId`), you can direct your application to use multiple instances or databases.

Database administrative operations, such as creating tables using `SpannerDatabaseAdminTemplate`, will also utilize the provided `DatabaseId`.

If you would like to configure every aspect of each connection (such as pool size and retry settings), you can supply a bean for `Supplier<DatabaseClient>`.


=== Cloud Spanner Emulator

The https://cloud.google.com/sdk[Cloud SDK] provides a local, in-memory emulator for Cloud Spanner, which you can use to develop and test your application. As the emulator stores data only in memory, it will not persist data across runs. It is intended to help you use Cloud Spanner for local development and testing, not for production deployments.

In order to set up and start the emulator, you can follow https://cloud.google.com/spanner/docs/emulator[these steps].

This command can be used to create Cloud Spanner instances:

----
$ gcloud spanner instances create <instance-name> --config=emulator-config --description=""<description>"" --nodes=1
----

Once the Spanner emulator is running, ensure that the following properties are set in your `application.properties` of your Spring application:

----
spring.cloud.gcp.spanner.emulator.enabled=true
spring.cloud.gcp.spanner.emulator-host=${EMULATOR_HOSTPORT}
----

=== Sample

A https://github.com/spring-cloud/spring-cloud-gcp/tree/main/spring-cloud-gcp-samples/spring-cloud-gcp-data-spanner-sample[sample application] is available.
",12204,False,2036.1850354329174,median
"// Copyright (c) 2018 The Open-Transactions developers
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include ""stdafx.hpp""

#include ""opentxs/api/client/Activity.hpp""
#include ""opentxs/api/client/Contacts.hpp""
#include ""opentxs/api/client/Workflow.hpp""
#include ""opentxs/api/storage/Storage.hpp""
#include ""opentxs/api/Core.hpp""
#include ""opentxs/api/Endpoints.hpp""
#include ""opentxs/api/Factory.hpp""
#include ""opentxs/core/Cheque.hpp""
#include ""opentxs/core/Identifier.hpp""
#include ""opentxs/core/Lockable.hpp""
#include ""opentxs/core/Log.hpp""
#include ""opentxs/core/Message.hpp""
#include ""opentxs/core/OTTransaction.hpp""
#include ""opentxs/network/zeromq/Context.hpp""
#include ""opentxs/network/zeromq/Frame.hpp""
#include ""opentxs/network/zeromq/Message.hpp""
#include ""opentxs/network/zeromq/PublishSocket.hpp""
#include ""opentxs/network/zeromq/PushSocket.hpp""
#include ""opentxs/Proto.hpp""

#include <algorithm>
#include <chrono>
#include <cstdint>
#include <ctime>
#include <memory>

#include ""Workflow.hpp""

#define OUTGOING_CHEQUE_EVENT_VERSION 1
#define OUTGOING_CHEQUE_SOURCE_VERSION 1
#define OUTGOING_CHEQUE_WORKFLOW_VERSION 1
#define INCOMING_CHEQUE_EVENT_VERSION 1
#define INCOMING_CHEQUE_SOURCE_VERSION 1
#define INCOMING_CHEQUE_WORKFLOW_VERSION 1
#define OUTGOING_TRANSFER_EVENT_VERSION 2
#define OUTGOING_TRANSFER_SOURCE_VERSION 1
#define OUTGOING_TRANSFER_WORKFLOW_VERSION 2
#define INCOMING_TRANSFER_EVENT_VERSION 2
#define INCOMING_TRANSFER_SOURCE_VERSION 1
#define INCOMING_TRANSFER_WORKFLOW_VERSION 2
#define INTERNAL_TRANSFER_EVENT_VERSION 2
#define INTERNAL_TRANSFER_SOURCE_VERSION 1
#define INTERNAL_TRANSFER_WORKFLOW_VERSION 2
#define RPC_ACCOUNT_EVENT_VERSION 1
#define RPC_PUSH_VERSION 1

#define OT_METHOD ""opentxs::api::client::implementation::Workflow::""

namespace zmq = opentxs::network::zeromq;

namespace opentxs
{
api::client::Workflow* Factory::Workflow(
    const api::Core& api,
    const api::client::Activity& activity,
    const api::client::Contacts& contact)
{
    return new api::client::implementation::Workflow(api, activity, contact);
}
}  // namespace opentxs

namespace opentxs::api::client
{
bool Workflow::ContainsCheque(const proto::PaymentWorkflow& workflow)
{
    switch (workflow.type()) {
        case proto::PAYMENTWORKFLOWTYPE_OUTGOINGCHEQUE:
        case proto::PAYMENTWORKFLOWTYPE_INCOMINGCHEQUE:
        case proto::PAYMENTWORKFLOWTYPE_OUTGOINGINVOICE:
        case proto::PAYMENTWORKFLOWTYPE_INCOMINGINVOICE: {

            return true;
        } break;
        case proto::PAYMENTWORKFLOWTYPE_ERROR:
        case proto::PAYMENTWORKFLOWTYPE_OUTGOINGTRANSFER:
        case proto::PAYMENTWORKFLOWTYPE_INCOMINGTRANSFER:
        case proto::PAYMENTWORKFLOWTYPE_INTERNALTRANSFER:
        default: {
        }
    }

    return false;
}

bool Workflow::ContainsTransfer(const proto::PaymentWorkflow& workflow)
{
    switch (workflow.type()) {
        case proto::PAYMENTWORKFLOWTYPE_OUTGOINGTRANSFER:
        case proto::PAYMENTWORKFLOWTYPE_INCOMINGTRANSFER:
        case proto::PAYMENTWORKFLOWTYPE_INTERNALTRANSFER: {

            return true;
        } break;
        case proto::PAYMENTWORKFLOWTYPE_ERROR:
        case proto::PAYMENTWORKFLOWTYPE_OUTGOINGCHEQUE:
        case proto::PAYMENTWORKFLOWTYPE_INCOMINGCHEQUE:
        case proto::PAYMENTWORKFLOWTYPE_OUTGOINGINVOICE:
        case proto::PAYMENTWORKFLOWTYPE_INCOMINGINVOICE:
        default: {
        }
    }

    return false;
}

std::string Workflow::ExtractCheque(const proto::PaymentWorkflow& workflow)
{
    if (false == ContainsCheque(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Wrong workflow type"").Flush();

        return {};
    }

    if (1 != workflow.source().size()) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Invalid workflow"").Flush();

        return {};
    }

    return workflow.source(0).item();
}

std::string Workflow::ExtractTransfer(const proto::PaymentWorkflow& workflow)
{
    if (false == ContainsTransfer(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Wrong workflow type"").Flush();

        return {};
    }

    if (1 != workflow.source().size()) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Invalid workflow"").Flush();

        return {};
    }

    return workflow.source(0).item();
}

Workflow::Cheque Workflow::InstantiateCheque(
    const api::Core& core,
    const proto::PaymentWorkflow& workflow)
{
    Cheque output{proto::PAYMENTWORKFLOWSTATE_ERROR, nullptr};
    auto& [state, cheque] = output;

    switch (workflow.type()) {
        case proto::PAYMENTWORKFLOWTYPE_OUTGOINGCHEQUE:
        case proto::PAYMENTWORKFLOWTYPE_INCOMINGCHEQUE:
        case proto::PAYMENTWORKFLOWTYPE_OUTGOINGINVOICE:
        case proto::PAYMENTWORKFLOWTYPE_INCOMINGINVOICE: {
            cheque.reset(core.Factory().Cheque().release());

            OT_ASSERT(cheque)

            const auto serialized = ExtractCheque(workflow);

            if (serialized.empty()) { return output; }

            const auto loaded = cheque->LoadContractFromString(
                String::Factory(serialized.c_str()));

            if (false == loaded) {
                LogOutput(OT_METHOD)(__FUNCTION__)(
                    "": Failed to instantiate cheque"")
                    .Flush();
                cheque.reset();

                return output;
            }

            state = workflow.state();
        } break;
        case proto::PAYMENTWORKFLOWTYPE_ERROR:
        case proto::PAYMENTWORKFLOWTYPE_OUTGOINGTRANSFER:
        case proto::PAYMENTWORKFLOWTYPE_INCOMINGTRANSFER:
        case proto::PAYMENTWORKFLOWTYPE_INTERNALTRANSFER:
        default: {
            LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect workflow type"")
                .Flush();
        }
    }

    return output;
}

Workflow::Transfer Workflow::InstantiateTransfer(
    const api::Core& core,
    const proto::PaymentWorkflow& workflow)
{
    Transfer output{proto::PAYMENTWORKFLOWSTATE_ERROR, nullptr};
    auto& [state, transfer] = output;

    switch (workflow.type()) {
        case proto::PAYMENTWORKFLOWTYPE_OUTGOINGTRANSFER:
        case proto::PAYMENTWORKFLOWTYPE_INCOMINGTRANSFER:
        case proto::PAYMENTWORKFLOWTYPE_INTERNALTRANSFER: {
            const auto serialized = ExtractTransfer(workflow);

            if (serialized.empty()) { return output; }

            transfer.reset(core.Factory().Item(serialized).release());

            if (false == bool(transfer)) {
                LogOutput(OT_METHOD)(__FUNCTION__)(
                    "": Failed to instantiate transfer"")
                    .Flush();
                transfer.reset();

                return output;
            }

            state = workflow.state();
        } break;

        case proto::PAYMENTWORKFLOWTYPE_ERROR:
        case proto::PAYMENTWORKFLOWTYPE_OUTGOINGCHEQUE:
        case proto::PAYMENTWORKFLOWTYPE_INCOMINGCHEQUE:
        case proto::PAYMENTWORKFLOWTYPE_OUTGOINGINVOICE:
        case proto::PAYMENTWORKFLOWTYPE_INCOMINGINVOICE:
        default: {
            LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect workflow type"")
                .Flush();
        }
    }

    return output;
}

namespace implementation
{
Workflow::Workflow(
    const api::Core& api,
    const api::client::Activity& activity,
    const api::client::Contacts& contact)
    : api_(api)
    , activity_(activity)
    , contact_(contact)
    , account_publisher_(api_.ZeroMQ().PublishSocket())
    , rpc_publisher_(api_.ZeroMQ().PushSocket(zmq::Socket::Direction::Connect))
{
    // WARNING: do not access api_.Wallet() during construction
    const auto endpoint = api_.Endpoints().WorkflowAccountUpdate();
    LogDetail(OT_METHOD)(__FUNCTION__)("": Binding to "")(endpoint).Flush();
    auto bound = account_publisher_->Start(endpoint);

    OT_ASSERT(bound)

    bound = rpc_publisher_->Start(
        api_.ZeroMQ().BuildEndpoint(""rpc/push/internal"", -1, 1));

    OT_ASSERT(bound)
}

bool Workflow::AbortTransfer(
    const Identifier& nymID,
    const Item& transfer,
    const Message& reply) const
{
    if (false == isTransfer(transfer)) { return false; }

    const bool isInternal = isInternalTransfer(
        transfer.GetRealAccountID(), transfer.GetDestinationAcctID());
    const std::set<proto::PaymentWorkflowType> type{
        isInternal ? proto::PAYMENTWORKFLOWTYPE_INTERNALTRANSFER
                   : proto::PAYMENTWORKFLOWTYPE_OUTGOINGTRANSFER};
    Lock global(lock_);
    const auto workflow = get_workflow(global, type, nymID.str(), transfer);

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this transfer does not exist."")
            .Flush();

        return false;
    }

    auto lock = get_workflow_lock(global, workflow->id());

    if (false == can_abort_transfer(*workflow)) { return false; }

    return add_transfer_event(
        lock,
        nymID.str(),
        """",
        *workflow,
        proto::PAYMENTWORKFLOWSTATE_ABORTED,
        proto::PAYMENTEVENTTYPE_ABORT,
        (isInternal ? INTERNAL_TRANSFER_EVENT_VERSION
                    : OUTGOING_TRANSFER_EVENT_VERSION),
        reply,
        transfer.GetRealAccountID().str(),
        true);

    return false;
}

// Works for Incoming and Internal transfer workflows.
bool Workflow::AcceptTransfer(
    const Identifier& nymID,
    const Identifier& notaryID,
    const OTTransaction& pending,
    const Message& reply) const
{
    const auto transfer = extract_transfer_from_pending(pending);

    if (false == bool(transfer)) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Invalid transaction"").Flush();

        return false;
    }

    const auto senderNymID = transfer->GetNymID().str();
    const auto recipientNymID = pending.GetNymID().str();
    const auto& accountID = pending.GetPurportedAccountID();

    if (pending.GetNymID() != nymID) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Invalid recipient"").Flush();

        return false;
    }

    const bool isInternal = (0 == senderNymID.compare(recipientNymID));

    // Ignore this event for internal transfers.
    if (isInternal) { return true; }

    const std::set<proto::PaymentWorkflowType> type{
        proto::PAYMENTWORKFLOWTYPE_INCOMINGTRANSFER};
    Lock global(lock_);
    const auto workflow = get_workflow(global, type, nymID.str(), *transfer);

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this transfer does not exist."")
            .Flush();

        return false;
    }

    auto lock = get_workflow_lock(global, workflow->id());

    if (false == can_accept_transfer(*workflow)) { return false; }

    return add_transfer_event(
        lock,
        nymID.str(),
        senderNymID,
        *workflow,
        proto::PAYMENTWORKFLOWSTATE_COMPLETED,
        proto::PAYMENTEVENTTYPE_ACCEPT,
        OUTGOING_TRANSFER_EVENT_VERSION,
        reply,
        accountID.str(),
        true);
}

bool Workflow::AcknowledgeTransfer(
    const Identifier& nymID,
    const Item& transfer,
    const Message& reply) const
{
    if (false == isTransfer(transfer)) { return false; }

    const bool isInternal = isInternalTransfer(
        transfer.GetRealAccountID(), transfer.GetDestinationAcctID());
    const std::set<proto::PaymentWorkflowType> type{
        isInternal ? proto::PAYMENTWORKFLOWTYPE_INTERNALTRANSFER
                   : proto::PAYMENTWORKFLOWTYPE_OUTGOINGTRANSFER};
    Lock global(lock_);
    const auto workflow = get_workflow(global, type, nymID.str(), transfer);

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this transfer does not exist."")
            .Flush();

        return false;
    }

    auto lock = get_workflow_lock(global, workflow->id());

    if (false == can_acknowledge_transfer(*workflow)) { return false; }

    // For internal transfers it's possible that a push notification already
    // advanced the state to conveyed before the sender received the
    // acknowledgement. The timing of those two events is indeterminate,
    // therefore if the state has already advanced, add the acknowledge event
    // but do not change the state.
    const proto::PaymentWorkflowState state =
        (proto::PAYMENTWORKFLOWSTATE_CONVEYED == workflow->state())
            ? proto::PAYMENTWORKFLOWSTATE_CONVEYED
            : proto::PAYMENTWORKFLOWSTATE_ACKNOWLEDGED;

    return add_transfer_event(
        lock,
        nymID.str(),
        """",
        *workflow,
        state,
        proto::PAYMENTEVENTTYPE_ACKNOWLEDGE,
        (isInternal ? INTERNAL_TRANSFER_EVENT_VERSION
                    : OUTGOING_TRANSFER_EVENT_VERSION),
        reply,
        transfer.GetRealAccountID().str(),
        true);
}

bool Workflow::add_cheque_event(
    const eLock& lock,
    const std::string& nymID,
    const std::string&,
    proto::PaymentWorkflow& workflow,
    const proto::PaymentWorkflowState newState,
    const proto::PaymentEventType newEventType,
    const std::uint32_t version,
    const Message& request,
    const Message* reply,
    const std::string& account) const
{
    const bool haveReply = (nullptr != reply);
    const bool success = cheque_deposit_success(reply);

    if (success) {
        workflow.set_state(newState);

        if ((false == account.empty()) && (0 == workflow.account_size())) {
            workflow.add_account(account);
        }
    }

    auto& event = *(workflow.add_event());
    event.set_version(version);
    event.set_type(newEventType);
    event.add_item(String::Factory(request)->Get());
    event.set_method(proto::TRANSPORTMETHOD_OT);
    event.set_transport(request.m_strNotaryID->Get());

    switch (newEventType) {
        case proto::PAYMENTEVENTTYPE_CANCEL:
        case proto::PAYMENTEVENTTYPE_COMPLETE: {
        } break;
        case proto::PAYMENTEVENTTYPE_CONVEY:
        case proto::PAYMENTEVENTTYPE_ACCEPT: {
            event.set_nym(request.m_strNymID2->Get());
        } break;
        case proto::PAYMENTEVENTTYPE_ERROR:
        case proto::PAYMENTEVENTTYPE_CREATE:
        default: {
            OT_FAIL
        }
    }

    event.set_success(success);

    if (haveReply) {
        event.add_item(String::Factory(*reply)->Get());
        event.set_time(reply->m_lTime);
    } else {
        event.set_time(request.m_lTime);
    }

    if (false == account.empty()) {
        workflow.set_notary(
            api_.Storage().AccountServer(Identifier::Factory(account))->str());
    }

    return save_workflow(nymID, account, workflow);
}

// Only used for ClearCheque
bool Workflow::add_cheque_event(
    const eLock& lock,
    const std::string& nymID,
    const std::string& accountID,
    proto::PaymentWorkflow& workflow,
    const proto::PaymentWorkflowState newState,
    const proto::PaymentEventType newEventType,
    const std::uint32_t version,
    const Identifier& recipientNymID,
    const OTTransaction& receipt,
    const std::chrono::time_point<std::chrono::system_clock> time) const
{
    auto message = String::Factory();
    receipt.SaveContractRaw(message);
    workflow.set_state(newState);
    auto& event = *(workflow.add_event());
    event.set_version(version);
    event.set_type(newEventType);
    event.add_item(message->Get());
    event.set_time(std::chrono::system_clock::to_time_t(time));
    event.set_method(proto::TRANSPORTMETHOD_OT);
    event.set_transport(receipt.GetRealNotaryID().str());
    event.set_nym(recipientNymID.str());
    event.set_success(true);

    if (0 == workflow.party_size()) {
        workflow.add_party(recipientNymID.str());
    }

    return save_workflow(nymID, accountID, workflow);
}

bool Workflow::add_transfer_event(
    const eLock& lock,
    const std::string& nymID,
    const std::string& eventNym,
    proto::PaymentWorkflow& workflow,
    const proto::PaymentWorkflowState newState,
    const proto::PaymentEventType newEventType,
    const std::uint32_t version,
    const Message& message,
    const std::string& account,
    const bool success) const
{
    if (success) { workflow.set_state(newState); }

    auto& event = *(workflow.add_event());
    event.set_version(version);
    event.set_type(newEventType);
    event.add_item(String::Factory(message)->Get());
    event.set_method(proto::TRANSPORTMETHOD_OT);
    event.set_transport(message.m_strNotaryID->Get());

    switch (newEventType) {
        case proto::PAYMENTEVENTTYPE_CONVEY:
        case proto::PAYMENTEVENTTYPE_ACCEPT:
        case proto::PAYMENTEVENTTYPE_COMPLETE:
        case proto::PAYMENTEVENTTYPE_ABORT:
        case proto::PAYMENTEVENTTYPE_ACKNOWLEDGE: {
            // TODO
        } break;
        case proto::PAYMENTEVENTTYPE_ERROR:
        case proto::PAYMENTEVENTTYPE_CREATE:
        case proto::PAYMENTEVENTTYPE_CANCEL:
        default: {
            OT_FAIL
        }
    }

    event.set_success(success);
    event.set_time(message.m_lTime);

    if (0 == workflow.party_size() && (false == eventNym.empty())) {
        workflow.add_party(eventNym);
    }

    return save_workflow(nymID, account, workflow);
}

bool Workflow::add_transfer_event(
    const eLock& lock,
    const std::string& nymID,
    const std::string& notaryID,
    const std::string& eventNym,
    proto::PaymentWorkflow& workflow,
    const proto::PaymentWorkflowState newState,
    const proto::PaymentEventType newEventType,
    const std::uint32_t version,
    const OTTransaction& receipt,
    const std::string& account,
    const bool success) const
{
    if (success) { workflow.set_state(newState); }

    auto& event = *(workflow.add_event());
    event.set_version(version);
    event.set_type(newEventType);
    event.add_item(String::Factory(receipt)->Get());
    event.set_method(proto::TRANSPORTMETHOD_OT);
    event.set_transport(notaryID);

    switch (newEventType) {
        case proto::PAYMENTEVENTTYPE_CONVEY:
        case proto::PAYMENTEVENTTYPE_ACCEPT:
        case proto::PAYMENTEVENTTYPE_COMPLETE:
        case proto::PAYMENTEVENTTYPE_ABORT:
        case proto::PAYMENTEVENTTYPE_ACKNOWLEDGE: {
            // TODO
        } break;
        case proto::PAYMENTEVENTTYPE_ERROR:
        case proto::PAYMENTEVENTTYPE_CREATE:
        case proto::PAYMENTEVENTTYPE_CANCEL:
        default: {
            OT_FAIL
        }
    }

    event.set_success(success);
    event.set_time(now());

    if (0 == workflow.party_size() && (false == eventNym.empty())) {
        workflow.add_party(eventNym);
    }

    return save_workflow(nymID, account, workflow);
}

bool Workflow::can_abort_transfer(const proto::PaymentWorkflow& workflow)
{
    bool correctState{false};

    switch (workflow.state()) {
        case proto::PAYMENTWORKFLOWSTATE_INITIATED: {
            correctState = true;
        } break;
        default: {
        }
    }

    if (false == correctState) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect workflow state."")
            .Flush();

        return false;
    }

    return true;
}

bool Workflow::can_accept_cheque(const proto::PaymentWorkflow& workflow)
{
    bool correctState{false};

    switch (workflow.state()) {
        case proto::PAYMENTWORKFLOWSTATE_EXPIRED:
        case proto::PAYMENTWORKFLOWSTATE_CONVEYED: {
            correctState = true;
        } break;
        default: {
        }
    }

    if (false == correctState) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect workflow state."")
            .Flush();

        return false;
    }

    return true;
}

bool Workflow::can_accept_transfer(const proto::PaymentWorkflow& workflow)
{
    bool correctState{false};

    switch (workflow.state()) {
        case proto::PAYMENTWORKFLOWSTATE_CONVEYED: {
            correctState = true;
        } break;
        default: {
        }
    }

    if (false == correctState) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect workflow state."")
            .Flush();

        return false;
    }

    return true;
}

bool Workflow::can_acknowledge_transfer(const proto::PaymentWorkflow& workflow)
{
    bool correctState{false};

    switch (workflow.state()) {
        case proto::PAYMENTWORKFLOWSTATE_INITIATED:
        case proto::PAYMENTWORKFLOWSTATE_CONVEYED: {
            correctState = true;
        } break;
        default: {
        }
    }

    if (false == correctState) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect workflow state ("")(
            workflow.state())("")"")
            .Flush();

        return false;
    }

    return true;
}

bool Workflow::can_cancel_cheque(const proto::PaymentWorkflow& workflow)
{
    bool correctState{false};

    switch (workflow.state()) {
        case proto::PAYMENTWORKFLOWSTATE_UNSENT:
        case proto::PAYMENTWORKFLOWSTATE_CONVEYED: {
            correctState = true;
        } break;
        default: {
        }
    }

    if (false == correctState) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect workflow state."")
            .Flush();

        return false;
    }

    return true;
}

bool Workflow::can_clear_transfer(const proto::PaymentWorkflow& workflow)
{
    bool correctState{false};

    switch (workflow.type()) {
        case proto::PAYMENTWORKFLOWTYPE_OUTGOINGTRANSFER: {
            correctState =
                (proto::PAYMENTWORKFLOWSTATE_ACKNOWLEDGED == workflow.state());
        } break;
        case proto::PAYMENTWORKFLOWTYPE_INTERNALTRANSFER: {
            correctState =
                (proto::PAYMENTWORKFLOWSTATE_CONVEYED == workflow.state());
        } break;
        default: {
        }
    }

    if (false == correctState) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect workflow state."")
            .Flush();

        return false;
    }

    return true;
}

bool Workflow::can_complete_transfer(const proto::PaymentWorkflow& workflow)
{
    if (proto::PAYMENTWORKFLOWSTATE_ACCEPTED != workflow.state()) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect workflow state ("")(
            workflow.state())("")"")
            .Flush();

        return false;
    }

    return true;
}

bool Workflow::can_convey_cheque(const proto::PaymentWorkflow& workflow)
{
    if (proto::PAYMENTWORKFLOWSTATE_UNSENT != workflow.state()) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect workflow state."")
            .Flush();

        return false;
    }

    return true;
}

bool Workflow::can_convey_transfer(const proto::PaymentWorkflow& workflow)
{
    switch (workflow.state()) {
        case proto::PAYMENTWORKFLOWSTATE_INITIATED:
        case proto::PAYMENTWORKFLOWSTATE_ACKNOWLEDGED: {
            return true;
        } break;
        default: {
            LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect workflow state."")
                .Flush();

            return false;
        }
    }
}

bool Workflow::can_deposit_cheque(const proto::PaymentWorkflow& workflow)
{
    if (proto::PAYMENTWORKFLOWSTATE_CONVEYED != workflow.state()) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect workflow state."")
            .Flush();

        return false;
    }

    return true;
}

bool Workflow::can_expire_cheque(
    const opentxs::Cheque& cheque,
    const proto::PaymentWorkflow& workflow)
{
    bool correctState{false};

    switch (workflow.type()) {
        case proto::PAYMENTWORKFLOWTYPE_OUTGOINGCHEQUE: {
            switch (workflow.state()) {
                case proto::PAYMENTWORKFLOWSTATE_UNSENT:
                case proto::PAYMENTWORKFLOWSTATE_CONVEYED: {
                    correctState = true;
                } break;
                default: {
                }
            }
        } break;
        case proto::PAYMENTWORKFLOWTYPE_INCOMINGCHEQUE: {
            switch (workflow.state()) {
                case proto::PAYMENTWORKFLOWSTATE_CONVEYED: {
                    correctState = true;
                } break;
                default: {
                }
            }
        } break;
        default: {
            OT_FAIL
        }
    }

    if (false == correctState) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect workflow state."")
            .Flush();

        return false;
    }

    if (now() < cheque.GetValidTo()) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Can not expire valid cheque."")
            .Flush();

        return false;
    }

    return true;
}

bool Workflow::can_finish_cheque(const proto::PaymentWorkflow& workflow)
{
    if (proto::PAYMENTWORKFLOWSTATE_ACCEPTED != workflow.state()) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect workflow state."")
            .Flush();

        return false;
    }

    return true;
}

bool Workflow::CancelCheque(
    const opentxs::Cheque& cheque,
    const Message& request,
    const Message* reply) const
{
    if (false == isCheque(cheque)) { return false; }

    const auto nymID = cheque.GetSenderNymID().str();
    Lock global(lock_);
    const auto workflow = get_workflow(
        global, {proto::PAYMENTWORKFLOWTYPE_OUTGOINGCHEQUE}, nymID, cheque);

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this cheque does not exist."")
            .Flush();

        return false;
    }

    auto lock = get_workflow_lock(global, workflow->id());

    if (false == can_cancel_cheque(*workflow)) { return false; }

    return add_cheque_event(
        lock,
        nymID,
        """",
        *workflow,
        proto::PAYMENTWORKFLOWSTATE_CANCELLED,
        proto::PAYMENTEVENTTYPE_CANCEL,
        OUTGOING_CHEQUE_EVENT_VERSION,
        request,
        reply);
}

bool Workflow::cheque_deposit_success(const Message* message)
{
    if (nullptr == message) { return false; }

    // TODO this might not be sufficient

    return message->m_bSuccess;
}

bool Workflow::ClearCheque(
    const Identifier& recipientNymID,
    const OTTransaction& receipt) const
{
    if (recipientNymID.empty()) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Invalid cheque recipient"")
            .Flush();

        return false;
    }

    auto cheque{api_.Factory().Cheque(receipt)};

    if (false == bool(cheque)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Failed to load cheque from receipt."")
            .Flush();

        return false;
    }

    if (false == isCheque(*cheque)) { return false; }

    const auto nymID = cheque->GetSenderNymID().str();
    Lock global(lock_);
    const auto workflow = get_workflow(
        global, {proto::PAYMENTWORKFLOWTYPE_OUTGOINGCHEQUE}, nymID, *cheque);

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this cheque does not exist."")
            .Flush();

        return false;
    }

    auto lock = get_workflow_lock(global, workflow->id());

    if (false == can_accept_cheque(*workflow)) { return false; }

    OT_ASSERT(1 == workflow->account_size())

    const bool needNym = (0 == workflow->party_size());
    const auto time = std::chrono::system_clock::from_time_t(now());
    const auto output = add_cheque_event(
        lock,
        nymID,
        workflow->account(0),
        *workflow,
        proto::PAYMENTWORKFLOWSTATE_ACCEPTED,
        proto::PAYMENTEVENTTYPE_ACCEPT,
        OUTGOING_CHEQUE_EVENT_VERSION,
        recipientNymID,
        receipt,
        time);

    if (needNym) {
        update_activity(
            cheque->GetSenderNymID(),
            recipientNymID,
            Identifier::Factory(*cheque),
            Identifier::Factory(workflow->id()),
            StorageBox::OUTGOINGCHEQUE,
            extract_conveyed_time(*workflow));
    }

    update_rpc(
        nymID,
        cheque->GetRecipientNymID().str(),
        cheque->SourceAccountID().str(),
        proto::ACCOUNTEVENT_OUTGOINGCHEQUE,
        workflow->id(),
        -1 * cheque->GetAmount(),
        0,
        time,
        cheque->GetMemo().Get());

    return output;
}

bool Workflow::ClearTransfer(
    const Identifier& nymID,
    const Identifier& notaryID,
    const OTTransaction& receipt) const
{
    auto depositorNymID = Identifier::Factory();
    const auto transfer =
        extract_transfer_from_receipt(receipt, depositorNymID);

    if (false == bool(transfer)) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Invalid transfer"").Flush();

        return false;
    }

    if (depositorNymID->empty()) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Missing recipient"").Flush();

        return false;
    }

    contact_.NymToContact(depositorNymID);
    const auto& accountID = transfer->GetPurportedAccountID();

    if (accountID.empty()) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Transfer does not contain source account ID"")
            .Flush();

        return false;
    }

    const auto& destinationAccountID = transfer->GetDestinationAcctID();

    if (destinationAccountID.empty()) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Transfer does not contain destination account ID"")
            .Flush();

        return false;
    }

    const bool isInternal = isInternalTransfer(accountID, destinationAccountID);
    const std::set<proto::PaymentWorkflowType> type{
        isInternal ? proto::PAYMENTWORKFLOWTYPE_INTERNALTRANSFER
                   : proto::PAYMENTWORKFLOWTYPE_OUTGOINGTRANSFER};
    Lock global(lock_);
    const auto workflow = get_workflow(global, type, nymID.str(), *transfer);

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this transfer does not exist."")
            .Flush();

        return false;
    }

    auto lock = get_workflow_lock(global, workflow->id());

    if (false == can_clear_transfer(*workflow)) { return false; }

    const auto output = add_transfer_event(
        lock,
        nymID.str(),
        notaryID.str(),
        (isInternal ? std::string{""""} : depositorNymID->str()),
        *workflow,
        proto::PAYMENTWORKFLOWSTATE_ACCEPTED,
        proto::PAYMENTEVENTTYPE_ACCEPT,
        (isInternal ? INTERNAL_TRANSFER_EVENT_VERSION
                    : OUTGOING_TRANSFER_EVENT_VERSION),
        receipt,
        accountID.str(),
        true);

    if (output) {
        const auto time = extract_conveyed_time(*workflow);
        auto note = String::Factory();
        transfer->GetNote(note);
        update_activity(
            nymID,
            depositorNymID,
            Identifier::Factory(*transfer),
            Identifier::Factory(workflow->id()),
            StorageBox::OUTGOINGTRANSFER,
            time);
        update_rpc(
            nymID.str(),
            depositorNymID->str(),
            accountID.str(),
            proto::ACCOUNTEVENT_OUTGOINGTRANSFER,
            workflow->id(),
            transfer->GetAmount(),
            0,
            time,
            note->Get());
    }

    return output;
}

// Works for outgoing and internal transfer workflows.
bool Workflow::CompleteTransfer(
    const Identifier& nymID,
    const Identifier& notaryID,
    const OTTransaction& receipt,
    const Message& reply) const
{
    auto depositorNymID = Identifier::Factory();
    const auto transfer =
        extract_transfer_from_receipt(receipt, depositorNymID);

    if (false == bool(transfer)) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Invalid transfer"").Flush();

        return false;
    }

    const auto& accountID = transfer->GetPurportedAccountID();

    if (accountID.empty()) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Transfer does not contain source account ID"")
            .Flush();

        return false;
    }

    const auto& destinationAccountID = transfer->GetDestinationAcctID();

    if (destinationAccountID.empty()) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Transfer does not contain destination account ID"")
            .Flush();

        return false;
    }

    const bool isInternal = isInternalTransfer(accountID, destinationAccountID);
    const std::set<proto::PaymentWorkflowType> type{
        isInternal ? proto::PAYMENTWORKFLOWTYPE_INTERNALTRANSFER
                   : proto::PAYMENTWORKFLOWTYPE_OUTGOINGTRANSFER};
    Lock global(lock_);
    const auto workflow = get_workflow(global, type, nymID.str(), *transfer);

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this transfer does not exist."")
            .Flush();

        return false;
    }

    auto lock = get_workflow_lock(global, workflow->id());

    if (false == can_complete_transfer(*workflow)) { return false; }

    return add_transfer_event(
        lock,
        nymID.str(),
        notaryID.str(),
        (isInternal ? std::string{""""} : depositorNymID->str()),
        *workflow,
        proto::PAYMENTWORKFLOWSTATE_COMPLETED,
        proto::PAYMENTEVENTTYPE_COMPLETE,
        (isInternal ? INTERNAL_TRANSFER_EVENT_VERSION
                    : OUTGOING_TRANSFER_EVENT_VERSION),
        receipt,
        transfer->GetRealAccountID().str(),
        true);

    return false;
}

// NOTE: Since this is an INCOMING transfer, then we need to CREATE its
// corresponding transfer workflow, since it does not already exist.
//
// (Whereas if this had been an INTERNAL transfer, then it would ALREADY
// have been created, and thus we'd need to GET the existing workflow, and
// then add the new event to it).
OTIdentifier Workflow::convey_incoming_transfer(
    const Identifier& nymID,
    const Identifier& notaryID,
    const OTTransaction& pending,
    const std::string& senderNymID,
    const std::string& recipientNymID,
    const Item& transfer) const
{
    Lock global(lock_);
    const auto existing = get_workflow(
        global,
        {proto::PAYMENTWORKFLOWTYPE_INCOMINGTRANSFER},
        senderNymID,
        transfer);

    if (existing) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this transfer already exist."")
            .Flush();

        return Identifier::Factory(existing->id());
    }

    const auto& accountID = pending.GetPurportedAccountID();
    const auto [workflowID, workflow] = create_transfer(
        global,
        nymID.str(),
        transfer,
        proto::PAYMENTWORKFLOWTYPE_INCOMINGTRANSFER,
        proto::PAYMENTWORKFLOWSTATE_CONVEYED,
        INCOMING_TRANSFER_WORKFLOW_VERSION,
        INCOMING_TRANSFER_SOURCE_VERSION,
        INCOMING_TRANSFER_EVENT_VERSION,
        senderNymID,
        accountID.str(),
        notaryID.str(),
        """");

    if (false == workflowID->empty()) {
        const auto time = extract_conveyed_time(workflow);
        auto note = String::Factory();
        transfer.GetNote(note);
        update_activity(
            nymID,
            transfer.GetNymID(),
            Identifier::Factory(transfer),
            workflowID,
            StorageBox::INCOMINGTRANSFER,
            time);
        update_rpc(
            recipientNymID,
            senderNymID,
            accountID.str(),
            proto::ACCOUNTEVENT_INCOMINGTRANSFER,
            workflowID->str(),
            transfer.GetAmount(),
            0,
            time,
            note->Get());
    }

    return workflowID;
}

// NOTE: Since this is an INTERNAL transfer, then it was already CREATED,
// and thus we need to GET the existing workflow, and then add the new
// event to it.
// Whereas if this is an INCOMING transfer, then we need to CREATE its
// corresponding transfer workflow since it does not already exist.
OTIdentifier Workflow::convey_internal_transfer(
    const Identifier& nymID,
    const Identifier& notaryID,
    const OTTransaction& pending,
    const std::string& senderNymID,
    const Item& transfer) const
{
    Lock global(lock_);
    const auto workflow = get_workflow(
        global,
        {proto::PAYMENTWORKFLOWTYPE_INTERNALTRANSFER},
        nymID.str(),
        transfer);

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this transfer does not exist."")
            .Flush();

        return Identifier::Factory();
    }

    auto lock = get_workflow_lock(global, workflow->id());

    if (false == can_convey_transfer(*workflow)) {
        return Identifier::Factory();
    }

    const auto output = add_transfer_event(
        lock,
        nymID.str(),
        notaryID.str(),
        """",
        *workflow,
        proto::PAYMENTWORKFLOWSTATE_CONVEYED,
        proto::PAYMENTEVENTTYPE_CONVEY,
        INTERNAL_TRANSFER_EVENT_VERSION,
        pending,
        transfer.GetDestinationAcctID().str(),
        true);

    if (output) {

        return Identifier::Factory(workflow->id());
    } else {

        return Identifier::Factory();
    }
}

OTIdentifier Workflow::ConveyTransfer(
    const Identifier& nymID,
    const Identifier& notaryID,
    const OTTransaction& pending) const
{
    const auto transfer = extract_transfer_from_pending(pending);

    if (false == bool(transfer)) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Invalid transaction"").Flush();

        return Identifier::Factory();
    }

    const auto senderNymID = transfer->GetNymID().str();
    contact_.NymToContact(transfer->GetNymID());
    const auto recipientNymID = pending.GetNymID().str();

    if (pending.GetNymID() != nymID) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Invalid recipient"").Flush();

        return Identifier::Factory();
    }

    const bool isInternal = (0 == senderNymID.compare(recipientNymID));

    if (isInternal) {

        return convey_internal_transfer(
            nymID, notaryID, pending, senderNymID, *transfer);
    } else {

        return convey_incoming_transfer(
            nymID, notaryID, pending, senderNymID, recipientNymID, *transfer);
    }
}

std::pair<OTIdentifier, proto::PaymentWorkflow> Workflow::create_cheque(
    const Lock& lock,
    const std::string& nymID,
    const opentxs::Cheque& cheque,
    const proto::PaymentWorkflowType workflowType,
    const proto::PaymentWorkflowState workflowState,
    const std::uint32_t workflowVersion,
    const std::uint32_t sourceVersion,
    const std::uint32_t eventVersion,
    const std::string& party,
    const std::string& account,
    const Message* message) const
{
    OT_ASSERT(verify_lock(lock))

    std::pair<OTIdentifier, proto::PaymentWorkflow> output{
        Identifier::Factory(), {}};
    auto& [workflowID, workflow] = output;
    const auto chequeID = Identifier::Factory(cheque);
    const std::string serialized = String::Factory(cheque)->Get();
    workflowID = Identifier::Random();
    workflow.set_version(workflowVersion);
    workflow.set_id(workflowID->str());
    workflow.set_type(workflowType);
    workflow.set_state(workflowState);
    auto& source = *(workflow.add_source());
    source.set_version(sourceVersion);
    source.set_id(chequeID->str());
    source.set_revision(1);
    source.set_item(serialized);

    // add party if it was passed in and is not already present
    if ((false == party.empty()) && (0 == workflow.party_size())) {
        workflow.add_party(party);
    }

    auto& event = *workflow.add_event();
    event.set_version(eventVersion);

    if (nullptr != message) {
        event.set_type(proto::PAYMENTEVENTTYPE_CONVEY);
        event.add_item(String::Factory(*message)->Get());
        event.set_time(message->m_lTime);
        event.set_method(proto::TRANSPORTMETHOD_OT);
        event.set_transport(message->m_strNotaryID->Get());
    } else {
        event.set_time(now());

        if (proto::PAYMENTWORKFLOWSTATE_UNSENT == workflowState) {
            event.set_type(proto::PAYMENTEVENTTYPE_CREATE);
            event.set_method(proto::TRANSPORTMETHOD_NONE);
        } else if (proto::PAYMENTWORKFLOWSTATE_CONVEYED == workflowState) {
            event.set_type(proto::PAYMENTEVENTTYPE_CONVEY);
            event.set_method(proto::TRANSPORTMETHOD_OOB);
        } else {
            OT_FAIL
        }
    }

    if (false == party.empty()) { event.set_nym(party); }

    event.set_success(true);
    workflow.add_unit(cheque.GetInstrumentDefinitionID().str());

    // add account if it was passed in and is not already present
    if ((false == account.empty()) && (0 == workflow.account_size())) {
        workflow.add_account(account);
    }

    if ((false == account.empty()) && (workflow.notary().empty())) {
        workflow.set_notary(
            api_.Storage().AccountServer(Identifier::Factory(account))->str());
    }

    if (workflow.notary().empty() && (nullptr != message)) {
        workflow.set_notary(message->m_strNotaryID->Get());
    }

    return save_workflow(std::move(output), nymID, account, workflow);
}

std::pair<OTIdentifier, proto::PaymentWorkflow> Workflow::create_transfer(
    const Lock& global,
    const std::string& nymID,
    const Item& transfer,
    const proto::PaymentWorkflowType workflowType,
    const proto::PaymentWorkflowState workflowState,
    const std::uint32_t workflowVersion,
    const std::uint32_t sourceVersion,
    const std::uint32_t eventVersion,
    const std::string& party,
    const std::string& account,
    const std::string& notaryID,
    const std::string& destinationAccountID) const
{
    OT_ASSERT(verify_lock(global))
    OT_ASSERT(false == nymID.empty());
    OT_ASSERT(false == account.empty());
    OT_ASSERT(false == notaryID.empty());

    std::pair<OTIdentifier, proto::PaymentWorkflow> output{
        Identifier::Factory(), {}};
    auto& [workflowID, workflow] = output;
    const auto transferID = Identifier::Factory(transfer);
    LogVerbose(OT_METHOD)(__FUNCTION__)("": Transfer ID: "")(transferID).Flush();
    const std::string serialized = String::Factory(transfer)->Get();
    const auto existing = get_workflow(global, {workflowType}, nymID, transfer);

    if (existing) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this transfer already exists."")
            .Flush();
        workflowID = Identifier::Factory(existing->id());

        return output;
    }

    workflowID = Identifier::Random();
    workflow.set_version(workflowVersion);
    workflow.set_id(workflowID->str());
    workflow.set_type(workflowType);
    workflow.set_state(workflowState);
    auto& source = *(workflow.add_source());
    source.set_version(sourceVersion);
    source.set_id(transferID->str());
    source.set_revision(1);
    source.set_item(serialized);
    workflow.set_notary(notaryID);

    // add party if it was passed in and is not already present
    if ((false == party.empty()) && (0 == workflow.party_size())) {
        workflow.add_party(party);
    }

    auto& event = *workflow.add_event();
    event.set_version(eventVersion);
    event.set_time(now());

    if (proto::PAYMENTWORKFLOWSTATE_INITIATED == workflowState) {
        event.set_type(proto::PAYMENTEVENTTYPE_CREATE);
        event.set_method(proto::TRANSPORTMETHOD_OT);
    } else if (proto::PAYMENTWORKFLOWSTATE_CONVEYED == workflowState) {
        event.set_type(proto::PAYMENTEVENTTYPE_CONVEY);
        event.set_method(proto::TRANSPORTMETHOD_OT);
    } else {
        OT_FAIL
    }

    event.set_transport(notaryID);

    if (false == party.empty()) { event.set_nym(party); }

    event.set_success(true);
    workflow.add_unit(
        api_.Storage().AccountContract(Identifier::Factory(account))->str());

    // add account if it is not already present
    if (0 == workflow.account_size()) {
        workflow.add_account(account);

        if (false == destinationAccountID.empty()) {
            workflow.add_account(destinationAccountID);
        }
    }

    return save_workflow(std::move(output), nymID, account, workflow);
}

// Creates outgoing and internal transfer workflows.
OTIdentifier Workflow::CreateTransfer(
    const Item& transfer,
    const Message& request) const
{
    if (false == isTransfer(transfer)) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Invalid item type on object"")
            .Flush();

        return Identifier::Factory();
    }

    const String& senderNymID = request.m_strNymID;
    const auto& accountID = transfer.GetRealAccountID();
    const bool isInternal =
        isInternalTransfer(accountID, transfer.GetDestinationAcctID());
    Lock global(lock_);
    const auto existing = get_workflow(
        global,
        {isInternal ? proto::PAYMENTWORKFLOWTYPE_INTERNALTRANSFER
                    : proto::PAYMENTWORKFLOWTYPE_OUTGOINGTRANSFER},
        senderNymID.Get(),
        transfer);

    if (existing) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this transfer already exist."")
            .Flush();

        return Identifier::Factory(existing->id());
    }

    const auto [workflowID, workflow] = create_transfer(
        global,
        senderNymID.Get(),
        transfer,
        (isInternal ? proto::PAYMENTWORKFLOWTYPE_INTERNALTRANSFER
                    : proto::PAYMENTWORKFLOWTYPE_OUTGOINGTRANSFER),
        proto::PAYMENTWORKFLOWSTATE_INITIATED,
        (isInternal ? INTERNAL_TRANSFER_WORKFLOW_VERSION
                    : OUTGOING_TRANSFER_WORKFLOW_VERSION),
        (isInternal ? INTERNAL_TRANSFER_SOURCE_VERSION
                    : OUTGOING_TRANSFER_SOURCE_VERSION),
        (isInternal ? INTERNAL_TRANSFER_EVENT_VERSION
                    : OUTGOING_TRANSFER_EVENT_VERSION),
        """",
        accountID.str(),
        request.m_strNotaryID->Get(),
        (isInternal ? transfer.GetDestinationAcctID().str() : """"));

    if (false == workflowID->empty()) {
        const auto time = extract_conveyed_time(workflow);
        auto note = String::Factory();
        transfer.GetNote(note);
        update_rpc(
            senderNymID.Get(),
            """",
            accountID.str(),
            proto::ACCOUNTEVENT_OUTGOINGTRANSFER,
            workflowID->str(),
            transfer.GetAmount(),
            0,
            time,
            note->Get());
    }

    return workflowID;
}

bool Workflow::DepositCheque(
    const Identifier& receiver,
    const Identifier& accountID,
    const opentxs::Cheque& cheque,
    const Message& request,
    const Message* reply) const
{
    if (false == isCheque(cheque)) { return false; }

    const auto nymID = receiver.str();
    Lock global(lock_);
    const auto workflow = get_workflow(
        global, {proto::PAYMENTWORKFLOWTYPE_INCOMINGCHEQUE}, nymID, cheque);

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this cheque does not exist."")
            .Flush();

        return false;
    }

    auto lock = get_workflow_lock(global, workflow->id());

    if (false == can_deposit_cheque(*workflow)) { return false; }

    const auto output = add_cheque_event(
        lock,
        nymID,
        cheque.GetSenderNymID().str(),
        *workflow,
        proto::PAYMENTWORKFLOWSTATE_COMPLETED,
        proto::PAYMENTEVENTTYPE_ACCEPT,
        INCOMING_CHEQUE_EVENT_VERSION,
        request,
        reply,
        accountID.str());

    if (output && cheque_deposit_success(reply)) {
        update_rpc(
            receiver.str(),
            cheque.GetSenderNymID().str(),
            accountID.str(),
            proto::ACCOUNTEVENT_INCOMINGCHEQUE,
            workflow->id(),
            cheque.GetAmount(),
            0,
            std::chrono::system_clock::from_time_t(reply->m_lTime),
            cheque.GetMemo().Get());
    }

    return output;
}

bool Workflow::ExpireCheque(
    const Identifier& nym,
    const opentxs::Cheque& cheque) const
{
    if (false == isCheque(cheque)) { return false; }

    const auto nymID = nym.str();
    Lock global(lock_);
    const auto workflow = get_workflow(
        global,
        {proto::PAYMENTWORKFLOWTYPE_OUTGOINGCHEQUE,
         proto::PAYMENTWORKFLOWTYPE_INCOMINGCHEQUE},
        nymID,
        cheque);

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this cheque does not exist."")
            .Flush();

        return false;
    }

    auto lock = get_workflow_lock(global, workflow->id());

    if (false == can_expire_cheque(cheque, *workflow)) { return false; }

    workflow->set_state(proto::PAYMENTWORKFLOWSTATE_EXPIRED);

    return save_workflow(nymID, cheque.GetSenderAcctID().str(), *workflow);
}

bool Workflow::ExportCheque(const opentxs::Cheque& cheque) const
{
    if (false == isCheque(cheque)) { return false; }

    const auto nymID = cheque.GetSenderNymID().str();
    Lock global(lock_);
    const auto workflow = get_workflow(global, {}, nymID, cheque);

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this cheque does not exist."")
            .Flush();

        return false;
    }

    auto lock = get_workflow_lock(global, workflow->id());

    if (false == can_convey_cheque(*workflow)) { return false; }

    workflow->set_state(proto::PAYMENTWORKFLOWSTATE_CONVEYED);
    auto& event = *(workflow->add_event());
    event.set_version(OUTGOING_CHEQUE_EVENT_VERSION);
    event.set_type(proto::PAYMENTEVENTTYPE_CONVEY);
    event.set_time(now());
    event.set_method(proto::TRANSPORTMETHOD_OOB);
    event.set_success(true);

    return save_workflow(nymID, cheque.GetSenderAcctID().str(), *workflow);
}

std::chrono::time_point<std::chrono::system_clock> Workflow::
    extract_conveyed_time(const proto::PaymentWorkflow& workflow)
{
    for (const auto& event : workflow.event()) {
        if (proto::PAYMENTEVENTTYPE_CONVEY == event.type()) {
            if (event.success()) {

                return std::chrono::system_clock::from_time_t(event.time());
            }
        }
    }

    return {};
}

std::unique_ptr<Item> Workflow::extract_transfer_from_pending(
    const OTTransaction& receipt) const
{
    if (transactionType::pending != receipt.GetType()) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect receipt type: "")(
            receipt.GetTypeString())
            .Flush();

        return nullptr;
    }

    auto serializedTransfer = String::Factory();
    receipt.GetReferenceString(serializedTransfer);

    if (serializedTransfer->empty()) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Missing serialized transfer item"")
            .Flush();

        return nullptr;
    }

    auto transfer = api_.Factory().Item(serializedTransfer);

    if (false == bool(transfer)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Unable to instantiate transfer item"")
            .Flush();

        return nullptr;
    }

    if (itemType::transfer != transfer->GetType()) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Invalid transfer item type."")
            .Flush();

        return nullptr;
    }

    return transfer;
}

std::unique_ptr<Item> Workflow::extract_transfer_from_receipt(
    const OTTransaction& receipt,
    Identifier& depositorNymID) const
{
    if (transactionType::transferReceipt != receipt.GetType()) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect receipt type: "")(
            receipt.GetTypeString())
            .Flush();

        return nullptr;
    }

    auto serializedAcceptPending = String::Factory();
    receipt.GetReferenceString(serializedAcceptPending);

    if (serializedAcceptPending->empty()) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Missing serialized accept pending item"")
            .Flush();

        return nullptr;
    }

    const auto acceptPending = api_.Factory().Item(serializedAcceptPending);

    if (false == bool(acceptPending)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Unable to instantiate accept pending item"")
            .Flush();

        return nullptr;
    }

    if (itemType::acceptPending != acceptPending->GetType()) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Invalid accept pending item type."")
            .Flush();

        return nullptr;
    }

    depositorNymID.Assign(acceptPending->GetNymID());
    auto serializedPending = String::Factory();
    acceptPending->GetAttachment(serializedPending);

    if (serializedPending->empty()) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Missing serialized pending transaction"")
            .Flush();

        return nullptr;
    }

    auto pending = api_.Factory().Transaction(
        receipt.GetNymID(),
        receipt.GetRealAccountID(),
        receipt.GetRealNotaryID());

    if (false == bool(pending)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Unable to instantiate pending transaction"")
            .Flush();

        return nullptr;
    }

    const bool loaded = pending->LoadContractFromString(serializedPending);

    if (false == loaded) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Unable to deserialize pending transaction"")
            .Flush();

        return nullptr;
    }

    if (transactionType::pending != pending->GetType()) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Invalid pending transaction type."")
            .Flush();

        return nullptr;
    }

    auto serializedTransfer = String::Factory();
    pending->GetReferenceString(serializedTransfer);

    if (serializedTransfer->empty()) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Missing serialized transfer item"")
            .Flush();

        return nullptr;
    }

    auto transfer = api_.Factory().Item(serializedTransfer);

    if (false == bool(transfer)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Unable to instantiate transfer item"")
            .Flush();

        return nullptr;
    }

    if (itemType::transfer != transfer->GetType()) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Invalid transfer item type."")
            .Flush();

        return nullptr;
    }

    return transfer;
}

bool Workflow::FinishCheque(
    const opentxs::Cheque& cheque,
    const Message& request,
    const Message* reply) const
{
    if (false == isCheque(cheque)) { return false; }

    const auto nymID = cheque.GetSenderNymID().str();
    Lock global(lock_);
    const auto workflow = get_workflow(
        global, {proto::PAYMENTWORKFLOWTYPE_OUTGOINGCHEQUE}, nymID, cheque);

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this cheque does not exist."")
            .Flush();

        return false;
    }

    auto lock = get_workflow_lock(global, workflow->id());

    if (false == can_finish_cheque(*workflow)) { return false; }

    return add_cheque_event(
        lock,
        nymID,
        """",
        *workflow,
        proto::PAYMENTWORKFLOWSTATE_COMPLETED,
        proto::PAYMENTEVENTTYPE_COMPLETE,
        OUTGOING_CHEQUE_EVENT_VERSION,
        request,
        reply);
}

template <typename T>
std::shared_ptr<proto::PaymentWorkflow> Workflow::get_workflow(
    const Lock& global,
    const std::set<proto::PaymentWorkflowType>& types,
    const std::string& nymID,
    const T& source) const
{
    OT_ASSERT(verify_lock(global));

    const auto itemID = Identifier::Factory(source)->str();
    LogVerbose(OT_METHOD)(__FUNCTION__)("": Item ID: "")(itemID).Flush();

    return get_workflow_by_source(types, nymID, itemID);
}

std::shared_ptr<proto::PaymentWorkflow> Workflow::get_workflow_by_id(
    const std::string& nymID,
    const std::string& workflowID) const
{
    std::shared_ptr<proto::PaymentWorkflow> output{nullptr};
    const auto loaded = api_.Storage().Load(nymID, workflowID, output);

    if (false == loaded) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Workflow "")(workflowID)(
            "" for nym "")(nymID)("" can not be loaded"")
            .Flush();

        return output;
    }

    return output;
}

std::shared_ptr<proto::PaymentWorkflow> Workflow::get_workflow_by_id(
    const std::set<proto::PaymentWorkflowType>& types,
    const std::string& nymID,
    const std::string& workflowID) const
{
    auto output = get_workflow_by_id(nymID, workflowID);

    if (0 == types.count(output->type())) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Incorrect type on workflow "")(
            workflowID)("" for nym "")(nymID)
            .Flush();

        return {nullptr};
    }

    return output;
}

std::shared_ptr<proto::PaymentWorkflow> Workflow::get_workflow_by_source(
    const std::set<proto::PaymentWorkflowType>& types,
    const std::string& nymID,
    const std::string& sourceID) const
{
    const auto workflowID =
        api_.Storage().PaymentWorkflowLookup(nymID, sourceID);

    if (workflowID.empty()) { return {}; }

    return get_workflow_by_id(types, nymID, workflowID);
}

eLock Workflow::get_workflow_lock(Lock& global, const std::string& id) const
{
    OT_ASSERT(verify_lock(global));

    auto output = eLock(workflow_locks_[id]);
    global.unlock();

    return output;
}

OTIdentifier Workflow::ImportCheque(
    const Identifier& nymID,
    const opentxs::Cheque& cheque) const
{
    if (false == isCheque(cheque)) { return Identifier::Factory(); }

    if (false == validate_recipient(nymID, cheque)) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Nym "")(nymID)(
            "" can not deposit this cheque."")
            .Flush();

        return Identifier::Factory();
    }

    Lock global(lock_);
    const auto existing = get_workflow(
        global,
        {proto::PAYMENTWORKFLOWTYPE_INCOMINGCHEQUE},
        nymID.str(),
        cheque);

    if (existing) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this cheque already exist."")
            .Flush();

        return Identifier::Factory(existing->id());
    }

    const std::string party = cheque.GetSenderNymID().str();
    const auto [workflowID, workflow] = create_cheque(
        global,
        nymID.str(),
        cheque,
        proto::PAYMENTWORKFLOWTYPE_INCOMINGCHEQUE,
        proto::PAYMENTWORKFLOWSTATE_CONVEYED,
        INCOMING_CHEQUE_WORKFLOW_VERSION,
        INCOMING_CHEQUE_SOURCE_VERSION,
        INCOMING_CHEQUE_EVENT_VERSION,
        party,
        """");

    if (false == workflowID->empty()) {
        const auto time = extract_conveyed_time(workflow);
        update_activity(
            nymID,
            cheque.GetSenderNymID(),
            Identifier::Factory(cheque),
            workflowID,
            StorageBox::INCOMINGCHEQUE,
            time);
        update_rpc(
            nymID.str(),
            cheque.GetSenderNymID().str(),
            """",
            proto::ACCOUNTEVENT_INCOMINGCHEQUE,
            workflowID->str(),
            0,
            cheque.GetAmount(),
            time,
            cheque.GetMemo().Get());
    }

    return workflowID;
}

bool Workflow::isCheque(const opentxs::Cheque& cheque)
{
    if (cheque.HasRemitter()) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Provided instrument is a voucher"")
            .Flush();

        return false;
    }

    if (0 > cheque.GetAmount()) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Provided instrument is an invoice"")
            .Flush();

        return false;
    }

    if (0 == cheque.GetAmount()) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Provided instrument is a cancellation"")
            .Flush();

        return false;
    }

    return true;
}

bool Workflow::isInternalTransfer(
    const Identifier& sourceAccount,
    const Identifier& destinationAccount) const
{
    const auto ownerNymID = api_.Storage().AccountOwner(sourceAccount);

    OT_ASSERT(false == ownerNymID->empty());

    const auto recipientNymID = api_.Storage().AccountOwner(destinationAccount);

    if (recipientNymID->empty()) { return false; }

    return ownerNymID == recipientNymID;
}

bool Workflow::isTransfer(const Item& item)
{
    return itemType::transfer == item.GetType();
}

std::set<OTIdentifier> Workflow::List(
    const Identifier& nymID,
    const proto::PaymentWorkflowType type,
    const proto::PaymentWorkflowState state) const
{
    const auto input =
        api_.Storage().PaymentWorkflowsByState(nymID.str(), type, state);
    std::set<OTIdentifier> output{};
    std::transform(
        input.begin(),
        input.end(),
        std::inserter(output, output.end()),
        [](const std::string& id) -> OTIdentifier {
            return Identifier::Factory(id);
        });

    return output;
}

Workflow::Cheque Workflow::LoadCheque(
    const Identifier& nymID,
    const Identifier& chequeID) const
{
    auto workflow = get_workflow_by_source(
        {proto::PAYMENTWORKFLOWTYPE_OUTGOINGCHEQUE,
         proto::PAYMENTWORKFLOWTYPE_INCOMINGCHEQUE},
        nymID.str(),
        chequeID.str());

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this cheque does not exist."")
            .Flush();

        return {};
    }

    return InstantiateCheque(api_, *workflow);
}

Workflow::Cheque Workflow::LoadChequeByWorkflow(
    const Identifier& nymID,
    const Identifier& workflowID) const
{
    auto workflow = get_workflow_by_id(
        {proto::PAYMENTWORKFLOWTYPE_OUTGOINGCHEQUE,
         proto::PAYMENTWORKFLOWTYPE_INCOMINGCHEQUE},
        nymID.str(),
        workflowID.str());

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this cheque does not exist."")
            .Flush();

        return {};
    }

    return InstantiateCheque(api_, *workflow);
}

Workflow::Transfer Workflow::LoadTransfer(
    const Identifier& nymID,
    const Identifier& transferID) const
{
    auto workflow = get_workflow_by_source(
        {proto::PAYMENTWORKFLOWTYPE_OUTGOINGTRANSFER,
         proto::PAYMENTWORKFLOWTYPE_INCOMINGTRANSFER,
         proto::PAYMENTWORKFLOWTYPE_INTERNALTRANSFER},
        nymID.str(),
        transferID.str());

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this transfer does not exist."")
            .Flush();

        return {};
    }

    return InstantiateTransfer(api_, *workflow);
}

Workflow::Transfer Workflow::LoadTransferByWorkflow(
    const Identifier& nymID,
    const Identifier& workflowID) const
{
    auto workflow = get_workflow_by_id(
        {proto::PAYMENTWORKFLOWTYPE_OUTGOINGTRANSFER,
         proto::PAYMENTWORKFLOWTYPE_INCOMINGTRANSFER,
         proto::PAYMENTWORKFLOWTYPE_INTERNALTRANSFER},
        nymID.str(),
        workflowID.str());

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this transfer does not exist."")
            .Flush();

        return {};
    }

    return InstantiateTransfer(api_, *workflow);
}

std::shared_ptr<proto::PaymentWorkflow> Workflow::LoadWorkflow(
    const Identifier& nymID,
    const Identifier& workflowID) const
{
    return get_workflow_by_id(nymID.str(), workflowID.str());
}

OTIdentifier Workflow::ReceiveCheque(
    const Identifier& nymID,
    const opentxs::Cheque& cheque,
    const Message& message) const
{
    if (false == isCheque(cheque)) { return Identifier::Factory(); }

    if (false == validate_recipient(nymID, cheque)) {
        LogOutput(OT_METHOD)(__FUNCTION__)("": Nym "")(nymID)(
            "" can not deposit this cheque."")
            .Flush();

        return Identifier::Factory();
    }

    Lock global(lock_);
    const auto existing = get_workflow(
        global,
        {proto::PAYMENTWORKFLOWTYPE_INCOMINGCHEQUE},
        nymID.str(),
        cheque);

    if (existing) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this cheque already exist."")
            .Flush();

        return Identifier::Factory(existing->id());
    }

    const std::string party = cheque.GetSenderNymID().str();
    const auto [workflowID, workflow] = create_cheque(
        global,
        nymID.str(),
        cheque,
        proto::PAYMENTWORKFLOWTYPE_INCOMINGCHEQUE,
        proto::PAYMENTWORKFLOWSTATE_CONVEYED,
        INCOMING_CHEQUE_WORKFLOW_VERSION,
        INCOMING_CHEQUE_SOURCE_VERSION,
        INCOMING_CHEQUE_EVENT_VERSION,
        party,
        """",
        &message);

    if (false == workflowID->empty()) {
        const auto time = extract_conveyed_time(workflow);
        update_activity(
            nymID,
            cheque.GetSenderNymID(),
            Identifier::Factory(cheque),
            workflowID,
            StorageBox::INCOMINGCHEQUE,
            time);
        update_rpc(
            nymID.str(),
            cheque.GetSenderNymID().str(),
            """",
            proto::ACCOUNTEVENT_INCOMINGCHEQUE,
            workflowID->str(),
            0,
            cheque.GetAmount(),
            time,
            cheque.GetMemo().Get());
    }

    return workflowID;
}

bool Workflow::save_workflow(
    const std::string& nymID,
    const std::string& accountID,
    const proto::PaymentWorkflow& workflow) const
{
    const bool valid = proto::Validate(workflow, VERBOSE);

    OT_ASSERT(valid)

    const auto saved = api_.Storage().Store(nymID, workflow);

    OT_ASSERT(saved)

    if (false == accountID.empty()) { account_publisher_->Publish(accountID); }

    return valid && saved;
}

OTIdentifier Workflow::save_workflow(
    OTIdentifier&& output,
    const std::string& nymID,
    const std::string& accountID,
    const proto::PaymentWorkflow& workflow) const
{
    if (save_workflow(nymID, accountID, workflow)) { return std::move(output); }

    return Identifier::Factory();
}

std::pair<OTIdentifier, proto::PaymentWorkflow> Workflow::save_workflow(
    std::pair<OTIdentifier, proto::PaymentWorkflow>&& output,
    const std::string& nymID,
    const std::string& accountID,
    const proto::PaymentWorkflow& workflow) const
{
    if (save_workflow(nymID, accountID, workflow)) { return std::move(output); }

    return {Identifier::Factory(), {}};
}

bool Workflow::SendCheque(
    const opentxs::Cheque& cheque,
    const Message& request,
    const Message* reply) const
{
    if (false == isCheque(cheque)) { return false; }

    const auto nymID = cheque.GetSenderNymID().str();
    Lock global(lock_);
    const auto workflow = get_workflow(
        global, {proto::PAYMENTWORKFLOWTYPE_OUTGOINGCHEQUE}, nymID, cheque);

    if (false == bool(workflow)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this cheque does not exist."")
            .Flush();

        return false;
    }

    auto lock = get_workflow_lock(global, workflow->id());

    if (false == can_convey_cheque(*workflow)) { return false; }

    return add_cheque_event(
        lock,
        nymID,
        request.m_strNymID2->Get(),
        *workflow,
        proto::PAYMENTWORKFLOWSTATE_CONVEYED,
        proto::PAYMENTEVENTTYPE_CONVEY,
        OUTGOING_CHEQUE_EVENT_VERSION,
        request,
        reply);
}

void Workflow::update_activity(
    const Identifier& localNymID,
    const Identifier& remoteNymID,
    const Identifier& sourceID,
    const Identifier& workflowID,
    const StorageBox type,
    std::chrono::time_point<std::chrono::system_clock> time) const
{
    const auto contactID = contact_.ContactID(remoteNymID);

    OT_ASSERT(false == contactID->empty())

    const bool added = activity_.AddPaymentEvent(
        localNymID, contactID, type, sourceID, workflowID, time);

    if (added) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Success adding payment event to thread "")(contactID->str())
            .Flush();
    } else {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Failed to add payment event to thread "")(contactID->str())
            .Flush();
    }
}

void Workflow::update_rpc(
    const std::string& localNymID,
    const std::string& remoteNymID,
    const std::string& accountID,
    const proto::AccountEventType type,
    const std::string& workflowID,
    const Amount amount,
    const Amount pending,
    const std::chrono::time_point<std::chrono::system_clock> time,
    const std::string& memo) const
{
    proto::RPCPush push{};
    push.set_version(RPC_PUSH_VERSION);
    push.set_type(proto::RPCPUSH_ACCOUNT);
    push.set_id(localNymID);
    auto& event = *push.mutable_accountevent();
    event.set_version(RPC_ACCOUNT_EVENT_VERSION);
    event.set_id(accountID);
    event.set_type(type);

    if (false == remoteNymID.empty()) {
        event.set_contact(
            contact_.NymToContact(Identifier::Factory(remoteNymID))->str());
    }

    event.set_workflow(workflowID);
    event.set_amount(amount);
    event.set_pendingamount(pending);
    event.set_timestamp(std::chrono::system_clock::to_time_t(time));
    event.set_memo(memo);

    OT_ASSERT(proto::Validate(push, VERBOSE));

    auto message = zmq::Message::Factory();
    message->AddFrame();
    message->AddFrame(localNymID);
    message->AddFrame(proto::ProtoAsData(push));
    rpc_publisher_->Push(message);
}

bool Workflow::validate_recipient(
    const Identifier& nymID,
    const opentxs::Cheque& cheque)
{
    if (nymID.empty()) { return true; }

    return (nymID == cheque.GetRecipientNymID());
}

std::vector<OTIdentifier> Workflow::WorkflowsByAccount(
    const Identifier& nymID,
    const Identifier& accountID) const
{
    std::vector<OTIdentifier> output{};
    const auto workflows =
        api_.Storage().PaymentWorkflowsByAccount(nymID.str(), accountID.str());
    std::transform(
        workflows.begin(),
        workflows.end(),
        std::inserter(output, output.end()),
        [](const std::string& id) -> OTIdentifier {
            return Identifier::Factory(id);
        });

    return output;
}

OTIdentifier Workflow::WriteCheque(const opentxs::Cheque& cheque) const
{
    if (false == isCheque(cheque)) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Invalid item type on cheque object"")
            .Flush();

        return Identifier::Factory();
    }

    const auto nymID = cheque.GetSenderNymID().str();
    Lock global(lock_);
    const auto existing = get_workflow(
        global, {proto::PAYMENTWORKFLOWTYPE_OUTGOINGCHEQUE}, nymID, cheque);

    if (existing) {
        LogOutput(OT_METHOD)(__FUNCTION__)(
            "": Workflow for this cheque already exist."")
            .Flush();

        return Identifier::Factory(existing->id());
    }

    const std::string party =
        cheque.HasRecipient() ? cheque.GetRecipientNymID().str() : """";
    const auto [workflowID, workflow] = create_cheque(
        global,
        nymID,
        cheque,
        proto::PAYMENTWORKFLOWTYPE_OUTGOINGCHEQUE,
        proto::PAYMENTWORKFLOWSTATE_UNSENT,
        OUTGOING_CHEQUE_WORKFLOW_VERSION,
        OUTGOING_CHEQUE_SOURCE_VERSION,
        OUTGOING_CHEQUE_EVENT_VERSION,
        party,
        cheque.GetSenderAcctID().str());
    global.unlock();
    const bool haveWorkflow = (false == workflowID->empty());
    const auto time{
        std::chrono::system_clock::from_time_t(workflow.event(0).time())};

    if (haveWorkflow && cheque.HasRecipient()) {
        update_activity(
            cheque.GetSenderNymID(),
            cheque.GetRecipientNymID(),
            Identifier::Factory(cheque),
            workflowID,
            StorageBox::OUTGOINGCHEQUE,
            time);
    }

    if (false == workflowID->empty()) {
        update_rpc(
            nymID,
            cheque.GetRecipientNymID().str(),
            cheque.SourceAccountID().str(),
            proto::ACCOUNTEVENT_OUTGOINGCHEQUE,
            workflowID->str(),
            0,
            -1 * cheque.GetAmount(),
            time,
            cheque.GetMemo().Get());
    }

    return workflowID;
}
}  // namespace implementation
}  // namespace opentxs::api::client
",16324,True,3866.0844809809805,median
"#define _CRT_SECURE_NO_WARNINGS
#include ""inmost_sparse.h""
#include ""inmost_dense.h""
#include <fstream>
#include <sstream>

namespace INMOST
{
	namespace Sparse
	{

#if defined(USE_SOLVER) || defined(USE_AUTODIFF)
		bool _hasRowEntryType = false;

		INMOST_MPI_Type RowEntryType = INMOST_MPI_DATATYPE_NULL;

		INMOST_MPI_Type GetRowEntryType() {return RowEntryType;}

		bool HaveRowEntryType() {return _hasRowEntryType;}

		void CreateRowEntryType()
		{
#if defined(USE_MPI)
			if( !HaveRowEntryType() )
			{
				int ierr;
				MPI_Datatype type[2] = { INMOST_MPI_DATA_ENUM_TYPE, INMOST_MPI_DATA_REAL_TYPE };
				int blocklen[2] = { 1, 1 };
				MPI_Aint disp[2];
				disp[0] = offsetof(Sparse::Row::entry,first);
				disp[1] = offsetof(Sparse::Row::entry,second);
				//disp[2] = sizeof(Sparse::Row::entry);
				ierr = MPI_Type_create_struct(2, blocklen, disp, type, &RowEntryType);
				if( ierr != MPI_SUCCESS )
				{
					std::cout << __FILE__ << "":"" << __LINE__ << ""problem in MPI_Type_create_struct"" << std::endl;
				}
				ierr = MPI_Type_commit(&RowEntryType);
				if( ierr != MPI_SUCCESS )
				{
					std::cout << __FILE__ << "":"" << __LINE__ << ""problem in MPI_Type_commit"" << std::endl;
				}
			}
#endif
			_hasRowEntryType = true;
		}

		void DestroyRowEntryType()
		{
#if defined(USE_MPI)
			if( HaveRowEntryType() )
			{
				MPI_Type_free(&RowEntryType);
				RowEntryType = INMOST_MPI_DATATYPE_NULL;
			}
#endif
			_hasRowEntryType = false;
		}

////////class RowMerger

		RowMerger::RowMerger() : Sorted(true), Nonzeros(0), IntervalBeg(0), IntervalEnd(0) {}

		INMOST_DATA_REAL_TYPE & RowMerger::operator[] (INMOST_DATA_ENUM_TYPE pos)
		{
			INMOST_DATA_ENUM_TYPE map = MapIndex(pos);
			if( map == ENUMUNDEF )
				return Nonlocal[pos];
			if( LinkedList[map+1].first != UNDEF ) return LinkedList[map+1].second;
			else
			{
				INMOST_DATA_ENUM_TYPE index = LinkedList.get_interval_beg(), next;
				if( Sorted )
				{
					next = index;
					while(next < map+1)
					{
						index = next;
						next = LinkedList[index].first;
					}
					assert(index < map+1);
					assert(map+1 < next);
					++Nonzeros;
					LinkedList[index].first = map+1;
					LinkedList[map+1].first = next;
					return LinkedList[map+1].second;
				}
				else
				{
					INMOST_DATA_ENUM_TYPE index = LinkedList.get_interval_beg();
					++Nonzeros;
					LinkedList[map+1].first = LinkedList[index].first;
					LinkedList[index].first = map+1;
					return LinkedList[map+1].second;
				}
			}
		}

		INMOST_DATA_REAL_TYPE RowMerger::operator[] (INMOST_DATA_ENUM_TYPE pos) const
		{
			INMOST_DATA_ENUM_TYPE map = MapIndex(pos);
			if( map == ENUMUNDEF )
			{
				std::map<INMOST_DATA_ENUM_TYPE,INMOST_DATA_REAL_TYPE>::const_iterator it = Nonlocal.find(pos);
				if( it != Nonlocal.end() )
					return it->second;
			}
			else
				if( LinkedList[map+1].first != UNDEF ) return LinkedList[map+1].second;
			throw -1;
		}

		RowMerger::RowMerger(INMOST_DATA_ENUM_TYPE interval_begin, INMOST_DATA_ENUM_TYPE interval_end, bool Sorted)
				: Sorted(Sorted), Nonzeros(0), IntervalBeg(interval_begin), IntervalEnd(interval_end), LinkedList(interval_begin,interval_end+1,Row::make_entry(UNDEF,0.0))
		{
			LinkedList.begin()->first = EOL;
		}

		void RowMerger::Resize(INMOST_DATA_ENUM_TYPE interval_begin, INMOST_DATA_ENUM_TYPE interval_end, bool _Sorted)
		{
			LinkedList.set_interval_beg(static_cast<INMOST_DATA_ENUM_TYPE>(interval_begin));// - NonlocalPre.size()));
			LinkedList.set_interval_end(static_cast<INMOST_DATA_ENUM_TYPE>(interval_end + 1));// + NonlocalPost.size()));
			IntervalBeg = interval_begin;
			IntervalEnd = interval_end;
			std::fill(LinkedList.begin(),LinkedList.end(),Row::make_entry(UNDEF,0.0));
			LinkedList.begin()->first = EOL;
			Nonzeros = 0;
			Sorted = _Sorted;
			Nonlocal.clear();
		}

#if defined(USE_SOLVER)
		void RowMerger::Resize(const Matrix & A, bool _Sorted)
		{
			INMOST_DATA_ENUM_TYPE mbeg, mend, k, l, ind;
			//retrive interval of indices
			A.GetInterval(mbeg,mend);
			//gather non-local mapping from matrix
			std::set<INMOST_DATA_ENUM_TYPE> Pre, Post;
			for(k = mbeg; k < mend; ++k)
			{
				for(l = 0; l < A[k].Size(); ++l)
				{
					ind = A[k].GetIndex(l);
					if( ind < mbeg ) Pre.insert(ind);
					else if( ind >= mend ) Post.insert(ind);
				}
			}
			Resize(mbeg,mend,_Sorted);
			Nonlocal.clear();
		}

		RowMerger::RowMerger(const Matrix & A, bool Sorted) : Sorted(Sorted), Nonzeros(0)
		{
			Resize(A,Sorted);
		}
#endif

		RowMerger::~RowMerger() {}

		/*
		INMOST_DATA_ENUM_TYPE RowMerger::MapIndex(INMOST_DATA_ENUM_TYPE pos) const
		{
			if( pos < IntervalBeg || pos >= IntervalEnd )
				return ENUMUNDEF;
			return pos;
		}

		INMOST_DATA_ENUM_TYPE RowMerger::UnmapIndex(INMOST_DATA_ENUM_TYPE pos) const
		{
			return pos;
		}
		*/


		void RowMerger::Clear()
		{
			INMOST_DATA_ENUM_TYPE i = LinkedList.begin()->first, j;
			LinkedList.begin()->first = EOL;
			while( i != EOL )
			{
				j = LinkedList[i].first;
				LinkedList[i].first = UNDEF;
				LinkedList[i].second = 0.0;
				i = j;
			}
			Nonlocal.clear();
			Nonzeros = 0;
		}


		void RowMerger::PushRow(INMOST_DATA_REAL_TYPE coef, Row & r, bool PreSortRow)
		{
			if( Sorted && PreSortRow ) std::sort(r.Begin(),r.End());
			PushRow(coef,r);
		}
		
		void RowMerger::Multiply(INMOST_DATA_REAL_TYPE coef)
		{
			INMOST_DATA_ENUM_TYPE i = LinkedList.begin()->first;
			while( i != EOL )
			{
				LinkedList[i].second *= coef;
				i = LinkedList[i].first;
			}
			if( !Nonlocal.empty() )
			{
				std::map< INMOST_DATA_ENUM_TYPE, INMOST_DATA_REAL_TYPE >::iterator it;
				for(it = Nonlocal.begin(); it != Nonlocal.end(); ++it)
					it->second *= coef;
			}
		}
		

		void RowMerger::PushRow(INMOST_DATA_REAL_TYPE coef, const Row & r)
		{
			assert(Nonzeros == 0); //Linked list should be empty
			assert(LinkedList.begin()->first == EOL); //again check that list is empty
			if( coef )
			{
				INMOST_DATA_ENUM_TYPE index = LinkedList.get_interval_beg();
				Row::const_iterator it = r.Begin(), jt;
				while( it != r.End() )
				{
					INMOST_DATA_ENUM_TYPE pos = it->first;
					INMOST_DATA_ENUM_TYPE map = MapIndex(pos);
					if( map == ENUMUNDEF )
						Nonlocal[pos] = it->second*coef;
					else
					{
						LinkedList[index].first = map+1;
						LinkedList[map+1].first = EOL;
						LinkedList[map+1].second = it->second*coef;
						index = map+1;
						++Nonzeros;
					}
					jt = it;
					++it;
					assert(!Sorted || it == r.End() || jt->first < it->first);
				}
			}
		}

		void RowMerger::AddRow(INMOST_DATA_REAL_TYPE coef, Row & r, bool PreSortRow)
		{
			if( Sorted && PreSortRow ) std::sort(r.Begin(),r.End());
			AddRow(coef,r);
		}

		void RowMerger::AddRow(INMOST_DATA_REAL_TYPE coef, const Row & r)
		{
			if( coef )
			{
				INMOST_DATA_ENUM_TYPE index = LinkedList.get_interval_beg(), next;
				Row::const_iterator it = r.Begin(), itend = r.End(), jt;
				while( it != itend )
				{
					INMOST_DATA_ENUM_TYPE pos = it->first;
					INMOST_DATA_ENUM_TYPE map = MapIndex(pos);
					if( map == ENUMUNDEF )
						Nonlocal[pos] += coef*it->second;
					else
					{
						if( LinkedList[map+1].first != UNDEF )
							LinkedList[map+1].second += coef*it->second;
						else if( Sorted )
						{
							next = index;
							while(next < map+1)
							{
								index = next;
								next = LinkedList[index].first;
							}
							assert(index < map+1);
							assert(map+1 < next);
							LinkedList[index].first = map+1;
							LinkedList[map+1].first = next;
							LinkedList[map+1].second = coef*it->second;
							++Nonzeros;
						}
						else
						{
							LinkedList[map+1].first = LinkedList[index].first;
							LinkedList[map+1].second = coef*it->second;
							LinkedList[index].first = map+1;
							++Nonzeros;
						}
					}
					jt = it;
					++it;
					assert(!Sorted || it == itend || jt->first < it->first);
				}
			}
		}


		void RowMerger::RetriveRow(Row & r)
		{
            r.Resize(static_cast<INMOST_DATA_ENUM_TYPE>(Nonzeros+Nonlocal.size()));
			INMOST_DATA_ENUM_TYPE i = LinkedList.begin()->first, k = 0;
			while( i != EOL )
			{
				if( LinkedList[i].second )
				{
					r.GetIndex(k) = UnmapIndex(i-1);
					r.GetValue(k) = LinkedList[i].second;
					++k;
				}
				i = LinkedList[i].first;
			}
			if( !Nonlocal.empty() )
			{
				std::map< INMOST_DATA_ENUM_TYPE, INMOST_DATA_REAL_TYPE >::iterator it;
				for(it = Nonlocal.begin(); it != Nonlocal.end(); ++it) if( it->second )
				{
					r.GetIndex(k) = it->first;
					r.GetValue(k) = it->second;
					++k;
				}
			}
			r.Resize(k);
		}
////////class HessianRow

		void   HessianRow::RowVec(INMOST_DATA_REAL_TYPE alpha, const Row & rU, INMOST_DATA_REAL_TYPE beta, Row & rJ) const
		{
			INMOST_DATA_ENUM_TYPE end = rU.Size();
			for(INMOST_DATA_ENUM_TYPE i = 0; i < end; i++) rJ.GetValue(i) *= beta;
			for(INMOST_DATA_ENUM_TYPE i = 0; i < end; i++)
			{
				const index & ind = GetIndex(i);
				if( ind.first == ind.second )
					rJ[ind.first] += alpha*rU.get_safe(ind.first)*GetValue(i);
				else
				{
					rJ[ind.first ] += alpha*rU.get_safe(ind.second)*GetValue(i);
					rJ[ind.second] += alpha*rU.get_safe(ind.first )*GetValue(i);
				}
			}
		}

		bool HessianRow::isSorted() const
		{
			for(INMOST_DATA_ENUM_TYPE k = 1; k < Size(); ++k)
				if( GetIndex(k) < GetIndex(k-1) ) return false;
			return true;
		}

		void HessianRow::MergeSortedRows(INMOST_DATA_REAL_TYPE alpha, const HessianRow & left, INMOST_DATA_REAL_TYPE beta, const HessianRow & right, HessianRow & output)
		{
			assert(left.isSorted());
			assert(right.isSorted());
			output.Resize(left.Size()+right.Size());
			INMOST_DATA_ENUM_TYPE i = 0, j = 0, q = 0;
			while( i < left.Size() && j < right.Size() )
			{
				if( left.GetIndex(i) < right.GetIndex(j) )
				{
					output.GetIndex(q) = left.GetIndex(i);
					output.GetValue(q) = alpha*left.GetValue(i);
					++q;
					++i;
				}
				else if( left.GetIndex(i) == right.GetIndex(j) )
				{
					output.GetIndex(q) = left.GetIndex(i);
					output.GetValue(q) = alpha*left.GetValue(i) + beta*right.GetValue(j);
					++q;
					++i;
					++j;
				}
				else //right is smaller
				{
					output.GetIndex(q) = right.GetIndex(j);
					output.GetValue(q) = beta*right.GetValue(j);
					++q;
					++j;
				}
			}
			while( i < left.Size() )
			{
				if( q > 0 && (output.GetIndex(q-1) == left.GetIndex(i)) )
					output.GetValue(q-1) += alpha*left.GetValue(i);
				else
				{
					output.GetIndex(q) = left.GetIndex(i);
					output.GetValue(q) = alpha*left.GetValue(i);
					++q;
				}
				++i;
			}
			while( j < right.Size() )
			{
				if( q > 0 && (output.GetIndex(q-1) == right.GetIndex(j)) )
					output.GetValue(q-1) += beta*right.GetValue(j);
				else
				{
					output.GetIndex(q) = right.GetIndex(j);
					output.GetValue(q) = beta*right.GetValue(j);
					++q;
				}
				++j;
			}
			output.Resize(q);
		}

		void HessianRow::MergeJacobianHessian(INMOST_DATA_REAL_TYPE a, const Row & JL, const Row & JR, INMOST_DATA_REAL_TYPE b, const HessianRow & HL, INMOST_DATA_REAL_TYPE c, const HessianRow & HR, HessianRow & output)
		{
			// merge three sorted arrays at once
			// one of the array is synthesized from JL and JR on the go
			static const entry stub_entry = make_entry(make_index(ENUMUNDEF,ENUMUNDEF),0.0);
			assert(JL.isSorted());
			assert(JR.isSorted());
			assert(HL.isSorted());
			assert(HR.isSorted());
			output.Resize(HL.Size()+HR.Size()+JL.Size()*JR.Size());
			INMOST_DATA_ENUM_TYPE i = 0, j = 0, k1 = 0, l1 = 0, k2 = 0, l2 = 0, q = 0, kk1 = 0, ll2 = 0, r;
			while(kk1 < JL.Size() && JL.GetIndex(kk1) < JR.GetIndex(l1) ) kk1++;
			k1 = kk1;
			while(ll2 < JR.Size() && JL.GetIndex(k2) > JR.GetIndex(ll2) ) ll2++;
			l2 = ll2;
			entry candidate[4] = {stub_entry,stub_entry,stub_entry,stub_entry};
			if( i < HL.Size() )
				candidate[0] = make_entry(HL.GetIndex(i),b*HL.GetValue(i));
			if( j < HR.Size() )
				candidate[1] = make_entry(HR.GetIndex(j),c*HR.GetValue(j));
			if( k1 < JL.Size() && l1 < JR.Size() )
				candidate[2] = make_entry(make_index(JL.GetIndex(k1),JR.GetIndex(l1)),(JL.GetIndex(k1)==JR.GetIndex(l1)?0.5:1)*a*JL.GetValue(k1)*JR.GetValue(l1));
			if( k2 < JL.Size() && l2 < JR.Size() )
				candidate[3] = make_entry(make_index(JL.GetIndex(k2),JR.GetIndex(l2)),(JL.GetIndex(k2)==JR.GetIndex(l2)?0.5:1)*a*JL.GetValue(k2)*JR.GetValue(l2));
			do
			{
				//pick smallest
				r = 0;
				if( candidate[1].first < candidate[r].first ) r = 1;
				if( candidate[2].first < candidate[r].first ) r = 2;
				if( candidate[3].first < candidate[r].first ) r = 3;
				//all candidates are stub - exit
				if( candidate[r].first == stub_entry.first ) break;
				//record selected entry
				if( q > 0 && (output.GetIndex(q-1) == candidate[r].first) )
					output.GetValue(q-1) += candidate[r].second;
				else
				{
					output.GetIndex(q) = candidate[r].first;
					output.GetValue(q) = candidate[r].second;
					++q;
				}
				if( r == 0 ) //update left hessian index
				{
					if( ++i < HL.Size() )
						candidate[0] = make_entry(HL.GetIndex(i),b*HL.GetValue(i));
					else candidate[0] = stub_entry;
				}
				else if( r == 1 ) //update right hessian index
				{
					if( ++j < HR.Size() )
						candidate[1] = make_entry(HR.GetIndex(j),c*HR.GetValue(j));
					else candidate[1] = stub_entry;
				}
				else if( r == 2 ) //update jacobians indexes
				{
					if( ++k1 == JL.Size() )
					{
						++l1;
						if( l1 < JR.Size() )
						{
							while(kk1 < JL.Size() && JL.GetIndex(kk1) < JR.GetIndex(l1) ) kk1++;
							k1 = kk1;
						}
					}
					if( k1 < JL.Size() && l1 < JR.Size() )
						candidate[2] = make_entry(make_index(JL.GetIndex(k1),JR.GetIndex(l1)),(JL.GetIndex(k1)==JR.GetIndex(l1)?0.5:1)*a*JL.GetValue(k1)*JR.GetValue(l1));
					else
						candidate[2] = stub_entry;
				}
				else //update jacobians indexes
				{
					if( ++l2 == JR.Size() )
					{
						++k2;
						if( k2 < JL.Size() )
						{
							while(ll2 < JR.Size() && JL.GetIndex(k2) > JR.GetIndex(ll2) ) ll2++;
							l2 = ll2;
						}
					}
					if( k2 < JL.Size() && l2 < JR.Size() )
						candidate[3] = make_entry(make_index(JL.GetIndex(k2),JR.GetIndex(l2)),(JL.GetIndex(k2)==JR.GetIndex(l2)?0.5:1)*a*JL.GetValue(k2)*JR.GetValue(l2));
					else
						candidate[3] = stub_entry;
				}
			}
			while(true);
			output.Resize(q);
		}

		void HessianRow::MergeJacobianHessian(INMOST_DATA_REAL_TYPE a, const Row & JL, const Row & JR, INMOST_DATA_REAL_TYPE b, const HessianRow & H, HessianRow & output)
		{
			// merge three sorted arrays at once
			// one of the array is synthesized from JL and JR on the go
			static const entry stub_entry = make_entry(make_index(ENUMUNDEF,ENUMUNDEF),0.0);
			assert(JL.isSorted());
			assert(JR.isSorted());
			assert(H.isSorted());
			output.Resize(H.Size()+JL.Size()*JR.Size());
			INMOST_DATA_ENUM_TYPE i = 0, k1 = 0, l1 = 0, q = 0, k2 = 0, l2 = 0, r, ll2 = 0, kk1 = 0;
			while(kk1 < JL.Size() && JL.GetIndex(kk1) < JR.GetIndex(l1) ) kk1++;
			k1 = kk1;
			while(ll2 < JR.Size() && JL.GetIndex(k2) > JR.GetIndex(ll2) ) ll2++;
			l2 = ll2;
			entry candidate[3] = {stub_entry,stub_entry,stub_entry};
			if( i < H.Size() )
				candidate[0] = make_entry(H.GetIndex(i),b*H.GetValue(i));
			if( k1 < JL.Size() && l1 < JR.Size() )
				candidate[1] = make_entry(make_index(JL.GetIndex(k1),JR.GetIndex(l1)),(JL.GetIndex(k1)==JR.GetIndex(l1)?0.5:1)*a*JL.GetValue(k1)*JR.GetValue(l1));
			if( k2 < JL.Size() && l2 < JR.Size() )
				candidate[2] = make_entry(make_index(JL.GetIndex(k2),JR.GetIndex(l2)),(JL.GetIndex(k2)==JR.GetIndex(l2)?0.5:1)*a*JL.GetValue(k2)*JR.GetValue(l2));
			do
			{
				//pick smallest
				r = 0;
				if( candidate[1].first < candidate[r].first ) r = 1;
				if( candidate[2].first < candidate[r].first ) r = 2;
				//all candidates are stub - exit
				if( candidate[r].first == stub_entry.first ) break;
				//record selected entry
				if( q > 0 && (output.GetIndex(q-1) == candidate[r].first) )
				{
					output.GetValue(q-1) += candidate[r].second;
				}
				else
				{
					output.GetIndex(q) = candidate[r].first;
					output.GetValue(q) = candidate[r].second;
					++q;
				}
				if( r == 0 ) //update left hessian index
				{
					if( ++i < H.Size() )
						candidate[0] = make_entry(H.GetIndex(i),b*H.GetValue(i));
					else candidate[0] = stub_entry;
				}
				else if( r == 1 )
				{
					if( ++k1 == JL.Size() )
					{
						++l1;
						if( l1 < JR.Size() )
						{
							while(kk1 < JL.Size() && JL.GetIndex(kk1) < JR.GetIndex(l1) ) kk1++;
							k1 = kk1;
						}
					}
					if( k1 < JL.Size() && l1 < JR.Size() )
						candidate[1] = make_entry(make_index(JL.GetIndex(k1),JR.GetIndex(l1)),(JL.GetIndex(k1)==JR.GetIndex(l1)?0.5:1)*a*JL.GetValue(k1)*JR.GetValue(l1));
					else
						candidate[1] = stub_entry;
				}
				else //update jacobians indexes
				{
					if( ++l2 == JR.Size() )
					{
						++k2;
						if( k2 < JL.Size() )
						{
							while(ll2 < JR.Size() && JL.GetIndex(k2) > JR.GetIndex(ll2) ) ll2++;
							l2 = ll2;
						}
					}
					if( k2 < JL.Size() && l2 < JR.Size() )
						candidate[2] = make_entry(make_index(JL.GetIndex(k2),JR.GetIndex(l2)),(JL.GetIndex(k2)==JR.GetIndex(l2)?0.5:1)*a*JL.GetValue(k2)*JR.GetValue(l2));
					else
						candidate[2] = stub_entry;
				}
			}
			while(true);
			output.Resize(q);
		}

////////class Row
#if defined(USE_SOLVER)
		INMOST_DATA_REAL_TYPE   Row::RowVec(Vector & x) const
		{
			INMOST_DATA_REAL_TYPE ret = 0;
			INMOST_DATA_ENUM_TYPE end = Size();
			for(INMOST_DATA_ENUM_TYPE i = 0; i < end; i++) ret = ret + x[GetIndex(i)]*GetValue(i);
			return ret;
		}
#endif //USE_SOLVER
		bool Row::isSorted() const
		{
			for(INMOST_DATA_ENUM_TYPE k = 1; k < Size(); ++k)
				if( GetIndex(k) < GetIndex(k-1) ) return false;
			return true;
		}
		void Row::MergeSortedRows(INMOST_DATA_REAL_TYPE alpha, const Row & left, INMOST_DATA_REAL_TYPE beta, const Row & right, Row & output)
		{
			assert(left.isSorted());
			assert(right.isSorted());
			output.Resize(left.Size()+right.Size());
			INMOST_DATA_ENUM_TYPE i = 0, j = 0, q = 0;
			while( i < left.Size() && j < right.Size() )
			{
				if( left.GetIndex(i) < right.GetIndex(j) )
				{
					output.GetIndex(q) = left.GetIndex(i);
					output.GetValue(q) = alpha*left.GetValue(i);
					++q;
					++i;
				}
				else if( left.GetIndex(i) == right.GetIndex(j) )
				{
					output.GetIndex(q) = left.GetIndex(i);
					output.GetValue(q) = alpha*left.GetValue(i) + beta*right.GetValue(j);
					++q;
					++i;
					++j;
				}
				else //right is smaller
				{
					output.GetIndex(q) = right.GetIndex(j);
					output.GetValue(q) = beta*right.GetValue(j);
					++q;
					++j;
				}
			}
			while( i < left.Size() )
			{
				if( q > 0 && (output.GetIndex(q-1) == left.GetIndex(i)) )
					output.GetValue(q-1) += alpha*left.GetValue(i);
				else
				{
					output.GetIndex(q) = left.GetIndex(i);
					output.GetValue(q) = alpha*left.GetValue(i);
					++q;
				}
				++i;
			}
			while( j < right.Size() )
			{
				if( q > 0 && (output.GetIndex(q-1) == right.GetIndex(j)) )
					output.GetValue(q-1) += beta*right.GetValue(j);
				else
				{
					output.GetIndex(q) = right.GetIndex(j);
					output.GetValue(q) = beta*right.GetValue(j);
					++q;
				}
				++j;
			}
			output.Resize(q);
		}
#endif //defined(USE_SOLVER) || defined(USE_AUTODIFF)


#if defined(USE_SOLVER)
////////class Vector
		Vector::Vector(std::string _name, INMOST_DATA_ENUM_TYPE start, INMOST_DATA_ENUM_TYPE end, INMOST_MPI_Comm _comm) :data(start,end)
		{
			comm = _comm;
			name = _name;
			is_parallel = false;
		}

		Vector::Vector(const Vector & other) : data(other.data)
		{
			comm = other.comm;
			name = other.name;
			is_parallel = other.is_parallel;
		}

		Vector & Vector::operator =(Vector const & other)
		{
			comm = other.comm;
			data = other.data;
			name = other.name;
			is_parallel = other.is_parallel;
			return *this;
		}

		Vector::~Vector()
		{
		}

		void     Vector::Load(std::string file, INMOST_DATA_ENUM_TYPE mbeg, INMOST_DATA_ENUM_TYPE mend, std::string file_ord)
		{
			char str[16384];
			std::ifstream input(file.c_str());
			if( input.fail() ) throw -1;
			int state = 0, k;
			INMOST_DATA_ENUM_TYPE vec_size, vec_block, ind = 0;
			INMOST_DATA_REAL_TYPE val;
			int size = 1, rank = 0;
#if defined(USE_MPI)
			int flag = 0;
			MPI_Initialized(&flag);
			if( flag && mend == ENUMUNDEF && mbeg == ENUMUNDEF )
			{
				MPI_Comm_rank(GetCommunicator(),&rank);
				MPI_Comm_size(GetCommunicator(),&size);
			}
#endif
			INMOST_DATA_ENUM_TYPE * ord = NULL;
			if (file_ord != """")
			{
				std::ifstream input_ord;
				input_ord.open(file_ord.c_str(), std::ifstream::in);
				if( input_ord.fail() ) throw -2;
				int n;
				input_ord >> n;
				ord = (INMOST_DATA_ENUM_TYPE *)malloc(sizeof(INMOST_DATA_ENUM_TYPE)* n);
				assert(ord != NULL);
				for (int i=0; i<n; i++) input_ord >> ord[i];
				int nbl;
				input_ord >> nbl;
				if( nbl != size ) throw -3;
				int * ibl;
				ibl = (int *) malloc(sizeof(int) * (nbl+1));
				assert(ibl != NULL);
				for (int i=0; i<nbl+1; i++) input_ord >> ibl[i];
				if( mbeg == ENUMUNDEF ) mbeg = ibl[rank];
				if( mend == ENUMUNDEF ) mend = ibl[rank+1];
				for (int i=0; i<n; i++) ord[i] -= 1;
				free(ibl);
				input_ord.close();
				//std::cout<<""Vector::Load(): n=""<<n<<"" nbl=""<<nbl<<"" np=""<<size<<"" id=""<<rank<<"" mbeg=""<<mbeg<<"" mend=""<<mend<<std::endl;//db
			}

			while( !input.getline(str,16384).eof() )
			{
				k = 0; while( isspace(str[k]) ) k++;
				if( str[k] == '%' || str[k] == '\\0' ) continue;
				std::istringstream istr(str+k);
				switch(state)
				{
					case 0:
						istr >> vec_size; state = 1;
						vec_block = vec_size/size;
						if( mbeg == ENUMUNDEF ) mbeg = rank*vec_block;
						if( mend == ENUMUNDEF )
						{
							if( rank == size-1 ) mend = vec_size;
							else mend = mbeg+vec_block;
						}
						SetInterval(mbeg,mend);
						break;
					case 1:
						istr >> val;
						if( ord ) {
							if( ord[ind] >= mbeg && ord[ind] < mend ) data[ord[ind]] = val;
						} else {
							if( ind >= mbeg && ind < mend ) data[ind] = val;
						}
						ind++;
						break;
				}
			}
			input.close();
			if (file_ord != """") free(ord);
		}


		void     Vector::Save(std::string file)
		{
			INMOST_DATA_ENUM_TYPE vecsize = Size();

#if defined(USE_MPI)
			int rank = 0, size = 1;
			{
				MPI_Comm_rank(GetCommunicator(),&rank);
				MPI_Comm_size(GetCommunicator(),&size);
				INMOST_DATA_ENUM_TYPE temp = vecsize;
				MPI_Allreduce(&temp,&vecsize,1,INMOST_MPI_DATA_ENUM_TYPE,MPI_SUM,GetCommunicator());
			}
#endif
			std::stringstream rhs(std::ios::in | std::ios::out);
			rhs << std::scientific;
			rhs.precision(15);
			for(iterator it = Begin(); it != End(); ++it) rhs << *it << std::endl;
#if defined(USE_MPI) && defined(USE_MPI_FILE) // Use mpi files
			{
				int ierr;
				MPI_File fh;
				MPI_Status stat;
				ierr = MPI_File_open(GetCommunicator(),const_cast<char *>(file.c_str()), MPI_MODE_CREATE | MPI_MODE_DELETE_ON_CLOSE | MPI_MODE_WRONLY, MPI_INFO_NULL, &fh);
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
				ierr = MPI_File_close(&fh);
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
				ierr = MPI_File_open(GetCommunicator(),const_cast<char *>(file.c_str()),MPI_MODE_WRONLY | MPI_MODE_CREATE,MPI_INFO_NULL,&fh);
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
				std::vector<INMOST_DATA_BIG_ENUM_TYPE> datasizes(rank ? 1 : size), offsets(rank ? 1 : size);
				std::string buffer = rhs.str();
				INMOST_DATA_BIG_ENUM_TYPE datasize = buffer.size(), offset;
				ierr = MPI_Gather(&datasize,1,INMOST_MPI_DATA_BIG_ENUM_TYPE,&datasizes[0],1,INMOST_MPI_DATA_BIG_ENUM_TYPE,0,GetCommunicator());
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
				if( rank == 0 )
				{
					MPI_Offset off;
					std::stringstream header;
					//header << ""% vector "" << name << std::endl;
					//header << ""% is written by INMOST"" << std::endl;
					//header << ""% by MPI_File_* api"" << std::endl;
					header << vecsize << std::endl;
					ierr = MPI_File_write(fh,const_cast<char *>(header.str().c_str()),static_cast<int>(header.str().size()),MPI_CHAR,&stat);
					if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
					ierr = MPI_File_get_position(fh,&off);
					if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
					offsets[0] = off;
					for(int k = 1; k < size; ++k)
						offsets[k] = offsets[k-1] + datasizes[k-1];
				}
				ierr = MPI_Scatter(&offsets[0],1,INMOST_MPI_DATA_BIG_ENUM_TYPE,&offset,1,INMOST_MPI_DATA_BIG_ENUM_TYPE,0,GetCommunicator());
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
				if( datasize )
				{
					INMOST_DATA_BIG_ENUM_TYPE shift = 0, chunk;
					while( shift != datasize )
					{
						chunk = std::min(static_cast<INMOST_DATA_BIG_ENUM_TYPE>(INT_MAX),datasize-shift);
						ierr = MPI_File_write_at(fh,offset+shift,buffer.c_str()+shift,static_cast<INMOST_MPI_SIZE>(chunk),MPI_CHAR,&stat);
						if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
						shift += chunk;
					}
				}
				ierr = MPI_File_close(&fh);
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
			}
#elif defined(USE_MPI) //USE_MPI alternative
			std::string senddata = rhs.str(), recvdata;
			INMOST_DATA_BIG_ENUM_TYPE sendsize = static_cast<int>(senddata.size());
			std::vector<INMOST_DATA_BIG_ENUM_TYPE> recvsize(rank ? 1 : size);
			std::vector<MPI_Request> requests;
			int ierr = MPI_Gather(&sendsize,1,INMOST_MPI_DATA_BIG_ENUM_TYPE,&recvsize[0],1,INMOST_MPI_DATA_BIG_ENUM_TYPE,0,GetCommunicator());
			if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
			int max_tag = 32767;
			int flag = 0;
			int * p_max_tag;
#if defined(USE_MPI2)
			MPI_Comm_get_attr(comm,MPI_TAG_UB,&p_max_tag,&flag);
#else //USE_MPI2
			MPI_Attr_get(comm,MPI_TAG_UB,&p_max_tag,&flag);
#endif //USE_MPI2
			if( flag ) max_tag = *p_max_tag;
			if( rank == 0 )
			{
				INMOST_DATA_BIG_ENUM_TYPE sizesum = recvsize[0];
				for(int k = 1; k < size; k++)
					sizesum += recvsize[k];
				recvdata.resize(sizesum);
				memcpy(&recvdata[0],&senddata[0],sizeof(char)*recvsize[0]);
				INMOST_DATA_BIG_ENUM_TYPE offset = recvsize[0];
				for(int k = 1; k < size; k++)
				{
					INMOST_DATA_BIG_ENUM_TYPE chunk, shift = 0;
					int it = 0; // for mpi tag
					while( shift != recvsize[k] )
					{
						MPI_Request req;
						chunk = std::min(static_cast<INMOST_DATA_BIG_ENUM_TYPE>(INT_MAX),recvsize[k] - shift);
						ierr = MPI_Irecv(&senddata[offset+shift],chunk,MPI_CHAR,k, (k*1000 + it)%max_tag, GetCommunicator(), &req);
						if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
						requests.push_back(req);
						shift += chunk;
						it++;
						//TODO: remove temporary check
						if( it >= 1000 )
							std::cout << __FILE__ << "":"" << __LINE__ << "" too many iterations!!! "" << it << "" datasize "" << recvsize[k] << std::endl;
					}
					offset += shift;
				}
			}
			else 
			{
				INMOST_DATA_BIG_ENUM_TYPE chunk, shift = 0;
				int it = 0; // for mpi tag
				while( shift != sendsize )
				{
					MPI_Request req;
					chunk = std::min(static_cast<INMOST_DATA_BIG_ENUM_TYPE>(INT_MAX),sendsize - shift);
					ierr = MPI_Isend(&senddata[shift],chunk,MPI_CHAR, 0, (rank*1000 + it)%max_tag, GetCommunicator(), &req);
					if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
					requests.push_back(req);
					shift += chunk;
					it++;
					//TODO: remove temporary check
					if( it >= 1000 )
						std::cout << __FILE__ << "":"" << __LINE__ << "" too many iterations!!! "" << it << "" datasize "" << sendsize << std::endl;
				}
			}
			if( !requests.empty() )
			{
				ierr = MPI_Waitall((int)requests.size(),&requests[0],MPI_STATUSES_IGNORE);
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
			}
			if( rank == 0 )
			{
				std::fstream output(file.c_str(),std::ios::out);
				output << vecsize << std::endl;
				output << recvdata;
			}
#else
			std::fstream output(file.c_str(),std::ios::out);
			//output << ""% vector "" << name << std::endl;
			//output << ""% is written by INMOST"" << std::endl;
			//output << ""% by sequential write"" << std::endl;
			output << vecsize << std::endl;
			output << rhs.rdbuf();
#endif
		}
		
		INMOST::Matrix<INMOST_DATA_REAL_TYPE> Vector::operator [](const INMOST::AbstractMatrix<INMOST_DATA_INTEGER_TYPE> & rows) const
		{
			INMOST::Matrix<INMOST_DATA_REAL_TYPE> ret(rows.Rows(),rows.Cols());
			for(INMOST_DATA_ENUM_TYPE i = 0; i < rows.Rows(); ++i)
				for(INMOST_DATA_ENUM_TYPE j = 0; j < rows.Cols(); ++j)
					ret(i,j) = data[rows(i,j)];
			return ret;
		}

		INMOST::Matrix<value_reference> Vector::operator [](const INMOST::AbstractMatrix<INMOST_DATA_INTEGER_TYPE>& rows)
		{
			INMOST::Matrix<value_reference> ret(rows.Rows(), rows.Cols());
			for (INMOST_DATA_ENUM_TYPE i = 0; i < rows.Rows(); ++i)
				for (INMOST_DATA_ENUM_TYPE j = 0; j < rows.Cols(); ++j)
					new (&ret(i, j)) value_reference(data[rows(i, j)]);
			return ret;
		}

////////class Matrix
		void Matrix::MatVec(INMOST_DATA_REAL_TYPE alpha, Vector & x, INMOST_DATA_REAL_TYPE beta, Vector & out) const //y = alpha*A*x + beta * y
		{
			INMOST_DATA_ENUM_TYPE mbeg, mend;
			INMOST_DATA_INTEGER_TYPE ind, imbeg, imend;
			if( out.Empty() )
			{
				INMOST_DATA_ENUM_TYPE vbeg,vend;
				GetInterval(vbeg,vend);
				out.SetInterval(vbeg,vend);
			}
			//CHECK SOMEHOW FOR DEBUG THAT PROVIDED VECTORS ARE OK
			//~ assert(GetFirstIndex() == out.GetFirstIndex());
			//~ assert(Size() == out.Size());
			GetInterval(mbeg,mend);
			imbeg = mbeg;
			imend = mend;
#if defined(USE_OMP)
#pragma omp for private(ind)
#endif
			for(ind = imbeg; ind < imend; ++ind) //iterate rows of matrix
				out[ind] = beta * out[ind] + alpha * (*this)[ind].RowVec(x);
			// outer procedure should update out vector, if needed
		}
		
		
		


		void Matrix::MatVecTranspose(INMOST_DATA_REAL_TYPE alpha, Vector & x, INMOST_DATA_REAL_TYPE beta, Vector & out) const //y = alpha*A*x + beta * y
		{
			INMOST_DATA_ENUM_TYPE mbeg, mend;
			INMOST_DATA_INTEGER_TYPE ind, imbeg, imend;
			if( out.Empty() )
			{
				INMOST_DATA_ENUM_TYPE vbeg,vend;
				GetInterval(vbeg,vend);
				out.SetInterval(vbeg,vend);
			}
			//CHECK SOMEHOW FOR DEBUG THAT PROVIDED VECTORS ARE OK
			//~ assert(GetFirstIndex() == out.GetFirstIndex());
			//~ assert(Size() == out.Size());
			GetInterval(mbeg,mend);
			imbeg = mbeg;
			imend = mend;
			if( beta ) for(Vector::iterator it = out.Begin(); it != out.End(); ++it) (*it) *= beta;
			else for(Vector::iterator it = out.Begin(); it != out.End(); ++it) (*it) = 0.0;
#if defined(USE_OMP)
#pragma omp for private(ind)
#endif
			for(ind = imbeg; ind < imend; ++ind)
			{
				for(Row::const_iterator it = (*this)[ind].Begin(); it != (*this)[ind].End(); ++it)
					out[it->first] += alpha * x[ind] * it->second;
			}
			// outer procedure should update out vector, if needed
		}


		Matrix::Matrix(std::string _name, INMOST_DATA_ENUM_TYPE start, INMOST_DATA_ENUM_TYPE end, INMOST_MPI_Comm _comm)
				:data(start,end)
		{
			is_parallel = false;
			comm = _comm;
			SetInterval(start,end);
			name = _name;
		}

		Matrix::Matrix(const Matrix & other) :data(other.data)
		{
			comm = other.comm;
			name = other.name;
		}


		Matrix & Matrix::operator =(Matrix const & other)
		{
			comm = other.comm;
			data = other.data;
			name = other.name;
			return *this;
		}

		Matrix::~Matrix() {}

		void      Matrix::MoveRows(INMOST_DATA_ENUM_TYPE from, INMOST_DATA_ENUM_TYPE to, INMOST_DATA_ENUM_TYPE size)
		{
			INMOST_DATA_ENUM_TYPE i = to + size, j = from + size;
			if( size > 0 && to != from )
				while( j != from ) data[--j].MoveRow(data[--i]);
		}

		void      HessianMatrix::MoveRows(INMOST_DATA_ENUM_TYPE from, INMOST_DATA_ENUM_TYPE to, INMOST_DATA_ENUM_TYPE size)
		{
			INMOST_DATA_ENUM_TYPE i = to + size, j = from + size;
			if( size > 0 && to != from )
				while( j != from ) data[--j].MoveRow(data[--i]);
		}


		void     Matrix::Load(std::string file, INMOST_DATA_ENUM_TYPE mbeg, INMOST_DATA_ENUM_TYPE mend, std::string file_ord)
		{
			char str[16384];
			std::ifstream input(file.c_str());
			if( input.fail() ) throw -1;
			int state = 0, k;
			INMOST_DATA_ENUM_TYPE mat_size, max_lines, row, col, mat_block;
			INMOST_DATA_REAL_TYPE val;
			int size = 1, rank = 0;
#if defined(USE_MPI)
			int flag = 0;
			MPI_Initialized(&flag);
			if( flag && mend == ENUMUNDEF && mbeg == ENUMUNDEF )
			{
				MPI_Comm_rank(GetCommunicator(),&rank);
				MPI_Comm_size(GetCommunicator(),&size);
			}
#endif
			int * ord = NULL;
			if (file_ord != """")
			{
				std::ifstream input_ord;
				input_ord.open(file_ord.c_str(), std::ifstream::in);
				if( input_ord.fail() ) throw -2;
				int n;
				input_ord >> n; // check if( n == line )
				ord = (int *) malloc(sizeof(int) * n);
				assert(ord != NULL);
				for (int i=0; i<n; i++) input_ord >> ord[i];
				int nbl;
				input_ord >> nbl;
				if( nbl != size ) throw -3;
				int * ibl;
				ibl = (int *) malloc(sizeof(int) * (nbl+1));
				assert(ibl != NULL);
				for (int i=0; i<nbl+1; i++) input_ord >> ibl[i];
				if( mbeg == ENUMUNDEF ) mbeg = (unsigned int) ibl[rank];
				if( mend == ENUMUNDEF ) mend = (unsigned int) ibl[rank + 1];
				for (int i=0; i<n; i++) ord[i] -= 1;
				free(ibl);
				input_ord.close();
				//std::cout<<""Matrix::Load(): n=""<<n<<"" nbl=""<<nbl<<"" np=""<<size<<"" id=""<<rank<<"" mbeg=""<<mbeg<<"" mend=""<<mend<<std::endl;//db
			}

			int line = 0;
			while( !input.getline(str,16384).eof() )
			{
				line++;
				k = 0; while( isspace(str[k]) ) k++;
				//TODO: check for %%MatrixMarket matrix coordinate real general
				if( str[k] == '%' || str[k] == '\\0' ) continue;
				std::istringstream istr(str+k);
				switch(state)
				{
					case 0:
						istr >> mat_size >> mat_size >> max_lines; state = 1;
						mat_block = mat_size/size;
						if( mbeg == ENUMUNDEF ) mbeg = rank*mat_block;
						if( mend == ENUMUNDEF )
						{
							if( rank == size-1 ) mend = mat_size;
							else mend = mbeg+mat_block;
						}
						SetInterval(mbeg,mend);
						//~ std::cout << rank << "" my interval "" << mbeg << "":"" << mend << std::endl;
						break;
					case 1:
						istr >> row >> col >> val;
						row--; col--;
						if( ord ) { row = ord[row]; col = ord[col]; }
						if( row >= mbeg && row < mend ) data[row][col] = val;
						break;
				}
			}
			int nonzero = 0;
			for(iterator it = Begin(); it != End(); ++it) nonzero += it->Size();
			//~ std::cout << rank << "" total nonzero "" << max_lines << "" my nonzero "" << nonzero << std::endl;
			input.close();
			if (file_ord != """") free(ord);
		}

		void     Matrix::Save(std::string file, const AnnotationService * text)
		{
			INMOST_DATA_ENUM_TYPE matsize = Size(), nonzero = 0, row = GetFirstIndex()+1;
			bool have_annotation = false;
			if( text && !text->Empty() )
			{
				if( text->GetFirstIndex() == GetFirstIndex() &&
					text->GetLastIndex() == GetLastIndex())
					have_annotation = true;
				else
				{
					std::cout << ""Size of provided annotation ("" << text->GetFirstIndex() << "","" << text->GetLastIndex() << "")"" << std::endl;
					std::cout << ""differs from the size of the matrix ("" << GetFirstIndex() << "","" << GetLastIndex() << "")"" << std::endl;
				}
			}
			for(iterator it = Begin(); it != End(); ++it) nonzero += it->Size();
#if defined(USE_MPI)
			int rank = 0, size = 1;
			{
				MPI_Comm_rank(GetCommunicator(),&rank);
				MPI_Comm_size(GetCommunicator(),&size);
				INMOST_DATA_ENUM_TYPE temp_two[2] = {matsize,nonzero}, two[2];
				MPI_Allreduce(temp_two,two,2,INMOST_MPI_DATA_ENUM_TYPE,MPI_SUM,GetCommunicator());
				matsize = two[0];
				nonzero = two[1];
			}
#endif
			std::stringstream mtx(std::ios::in | std::ios::out);
			mtx << std::scientific;
			mtx.precision(15);
			for(INMOST_DATA_ENUM_TYPE k = GetFirstIndex(); k < GetLastIndex(); ++k)
			{
				if( have_annotation )
				{
					const std::string & str = text->GetAnnotation(k);
					if( !str.empty() ) mtx << ""% "" << str << ""\\n"";
				}
				for(Row::iterator jt = (*this)[k].Begin(); jt != (*this)[k].End(); ++jt)
					mtx << row << "" "" << jt->first+1 << "" "" << jt->second << ""\\n"";
				++row;
			}
#if defined(USE_MPI) && defined(USE_MPI_FILE) // USE_MPI2?
			{
				char estring[MPI_MAX_ERROR_STRING];
				int ierr, len;
				MPI_File fh;
				MPI_Status stat;
				std::string buffer = mtx.str();
				ierr = MPI_File_open(GetCommunicator(),const_cast<char *>(file.c_str()), MPI_MODE_CREATE | MPI_MODE_DELETE_ON_CLOSE | MPI_MODE_WRONLY, MPI_INFO_NULL, &fh);
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
				ierr = MPI_File_close(&fh);
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
				ierr = MPI_Barrier(GetCommunicator());
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
				ierr = MPI_File_open(GetCommunicator(),const_cast<char *>(file.c_str()),MPI_MODE_WRONLY | MPI_MODE_CREATE,MPI_INFO_NULL,&fh);
				if( ierr != MPI_SUCCESS )
				{
					MPI_Error_string(ierr,estring,&len);
					std::cout << estring << std::endl;
					MPI_Abort(GetCommunicator(),__LINE__);
				}
				std::vector<INMOST_DATA_BIG_ENUM_TYPE> datasizes(rank ? 1 : size), offsets(rank ? 1 : size);
				INMOST_DATA_BIG_ENUM_TYPE datasize = buffer.size(), offset;
				ierr = MPI_Gather(&datasize,1,INMOST_MPI_DATA_BIG_ENUM_TYPE,&datasizes[0],1,INMOST_MPI_DATA_BIG_ENUM_TYPE,0,GetCommunicator());
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
				if( rank == 0 )
				{
					MPI_Offset off;
					std::stringstream header;
					header << ""%%MatrixMarket matrix coordinate real general"" << std::endl;
					header << ""% matrix "" << name << std::endl;
					header << ""% is written by INMOST"" << std::endl;
					header << ""% by MPI_File_* api"" << std::endl;
					header << matsize << "" "" << matsize << "" "" << nonzero << std::endl;
					//std::string header_data(header.str());
					ierr = MPI_File_write(fh,const_cast<char *>(header.str().c_str()),static_cast<int>(header.str().size()),MPI_CHAR,&stat);
					if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
					ierr = MPI_File_get_position(fh,&off);
					if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
					offsets[0] = off;
					for(int k = 1; k < size; ++k)
						offsets[k] = offsets[k-1] + datasizes[k-1];
				}
				ierr = MPI_Scatter(&offsets[0],1,INMOST_MPI_DATA_BIG_ENUM_TYPE,&offset,1,INMOST_MPI_DATA_BIG_ENUM_TYPE,0,GetCommunicator());
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
				if( datasize )
				{
					INMOST_DATA_BIG_ENUM_TYPE shift = 0, chunk;
					while( shift != datasize )
					{
						chunk = std::min(static_cast<INMOST_DATA_BIG_ENUM_TYPE>(INT_MAX),datasize-shift);
						ierr = MPI_File_write_at(fh,offset+shift,buffer.c_str()+shift,static_cast<INMOST_MPI_SIZE>(chunk),MPI_CHAR,&stat);
						if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
						shift += chunk;
					}
				}
				ierr = MPI_File_close(&fh);
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
			}
#elif defined(USE_MPI)//USE_MPI alternative
			std::string senddata = mtx.str(), recvdata;
			INMOST_DATA_BIG_ENUM_TYPE sendsize = senddata.size();
			std::vector<INMOST_DATA_BIG_ENUM_TYPE> recvsize(rank ? 1 : size);
			std::vector<MPI_Request> requests;
			int ierr = MPI_Gather(&sendsize,1,INMOST_MPI_DATA_BIG_ENUM_TYPE,&recvsize[0],1,INMOST_MPI_DATA_BIG_ENUM_TYPE,0,GetCommunicator());
			if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
			int max_tag = 32767;
			int flag = 0;
			int * p_max_tag;
#if defined(USE_MPI2)
			MPI_Comm_get_attr(comm,MPI_TAG_UB,&p_max_tag,&flag);
#else //USE_MPI2
			MPI_Attr_get(comm,MPI_TAG_UB,&p_max_tag,&flag);
#endif //USE_MPI2
			if( flag ) max_tag = *p_max_tag;
			if( rank == 0 )
			{
				INMOST_DATA_BIG_ENUM_TYPE sizesum = recvsize[0];
				for(int k = 1; k < size; k++)
					sizesum += recvsize[k];
				recvdata.resize(sizesum);
				memcpy(&recvdata[0],&senddata[0],sizeof(char)*recvsize[0]);
				INMOST_DATA_BIG_ENUM_TYPE offset = recvsize[0];
				for(int k = 1; k < size; k++)
				{
					INMOST_DATA_BIG_ENUM_TYPE chunk, shift = 0;
					int it = 0; // for mpi tag
					while( shift != recvsize[k] )
					{
						MPI_Request req;
						chunk = std::min(static_cast<INMOST_DATA_BIG_ENUM_TYPE>(INT_MAX),recvsize[k] - shift);
						ierr = MPI_Irecv(&senddata[offset+shift],chunk,MPI_CHAR,k, (k*1000 + it)%max_tag, GetCommunicator(), &req);
						if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
						requests.push_back(req);
						shift += chunk;
						it++;
						//TODO: remove temporary check
						if( it >= 1000 )
							std::cout << __FILE__ << "":"" << __LINE__ << "" too many iterations!!! "" << it << "" datasize "" << recvsize[k] << std::endl;
					}
					offset += shift;
				}
			}
			else 
			{
				INMOST_DATA_BIG_ENUM_TYPE chunk, shift = 0;
				int it = 0; // for mpi tag
				while( shift != sendsize )
				{
					MPI_Request req;
					chunk = std::min(static_cast<INMOST_DATA_BIG_ENUM_TYPE>(INT_MAX),sendsize - shift);
					ierr = MPI_Isend(&senddata[shift],chunk,MPI_CHAR, 0, (rank*1000 + it)%max_tag, GetCommunicator(), &req);
					if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
					requests.push_back(req);
					shift += chunk;
					it++;
					//TODO: remove temporary check
					if( it >= 1000 )
						std::cout << __FILE__ << "":"" << __LINE__ << "" too many iterations!!! "" << it << "" datasize "" << sendsize << std::endl;
				}
			}
			if( !requests.empty() )
			{
				ierr = MPI_Waitall((int)requests.size(),&requests[0],MPI_STATUSES_IGNORE);
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
			}
			
			if( rank == 0 )
			{
				std::fstream output(file.c_str(),std::ios::out);
				output << ""%%MatrixMarket matrix coordinate real general"" << std::endl;
				output << ""% matrix "" << name << std::endl;
				output << ""% is written by INMOST"" << std::endl;
				output << ""% by MPI_Gather* api and sequential write"" << std::endl;
				output << matsize << "" "" << matsize << "" "" << nonzero << std::endl;
				output << recvdata;
			}
#else
			std::fstream output(file.c_str(),std::ios::out);
			output << ""%%MatrixMarket matrix coordinate real general"" << std::endl;
			output << ""% matrix "" << name << std::endl;
			output << ""% is written by INMOST"" << std::endl;
			output << ""% by sequential write "" << std::endl;
			output << matsize << "" "" << matsize << "" "" << nonzero << std::endl;
			output << mtx.rdbuf();
#endif
		}

		void Matrix::Swap(Matrix & other)
		{
			data.swap(other.data);
			name.swap(other.name);
			std::swap(comm,other.comm);
			std::swap(is_parallel,other.is_parallel);
		}

#if defined(USE_OMP)
		bool LockService::HaveLocks() const
		{
			return !locks.empty();
		}
		bool LockService::Lock(INMOST_DATA_ENUM_TYPE row)
		{
			assert( !locks.empty() );
			omp_set_lock(&locks[row]);
			return true;
		}
		bool LockService::TestLock(INMOST_DATA_ENUM_TYPE row)
		{
			assert( !locks.empty() );
			if( omp_test_lock(&locks[row]) )
				return true;
			else
				return false;
		}
		bool LockService::UnLock(INMOST_DATA_ENUM_TYPE row)
		{
			assert( !locks.empty() );
			omp_unset_lock(&locks[row]);
			return true;
		}
		void LockService::SetInterval(INMOST_DATA_ENUM_TYPE beg, INMOST_DATA_ENUM_TYPE end)
		{
			if( !locks.empty() ) DestroyLocks();
			if( end != beg )
			{
				locks.set_interval_beg(beg);
				locks.set_interval_end(end);
				for(INMOST_DATA_ENUM_TYPE k = beg; k < end; ++k)
					omp_init_lock(&locks[k]);
			}
		}
		void LockService::DestroyLocks()
		{
			INMOST_DATA_ENUM_TYPE kbeg,kend;
			kbeg = locks.get_interval_beg();
			kend = locks.get_interval_end();
			for(INMOST_DATA_ENUM_TYPE k = kbeg; k < kend; ++k)
				omp_destroy_lock(&locks[k]);
		}
		INMOST_DATA_ENUM_TYPE  LockService::GetFirstIndex() const {return locks.get_interval_beg();}
		INMOST_DATA_ENUM_TYPE  LockService::GetLastIndex() const {return locks.get_interval_end();}
		bool LockService::Empty() const {return locks.empty();}
		void LockService::GetInterval(INMOST_DATA_ENUM_TYPE & start, INMOST_DATA_ENUM_TYPE & end) const {start = locks.get_interval_beg(); end = locks.get_interval_end();}
#else
		bool LockService::HaveLocks() const {return false;}
		bool LockService::Lock(INMOST_DATA_ENUM_TYPE row) {(void)row; return true;}
		bool LockService::TestLock(INMOST_DATA_ENUM_TYPE row) {(void)row; return true;}
		bool LockService::UnLock(INMOST_DATA_ENUM_TYPE row) {(void)row; return true;}
		void LockService::SetInterval(INMOST_DATA_ENUM_TYPE beg, INMOST_DATA_ENUM_TYPE end) {(void)beg; (void)end;}
		void LockService::DestroyLocks() {}
		INMOST_DATA_ENUM_TYPE  LockService::GetFirstIndex() const {return 0;}
		INMOST_DATA_ENUM_TYPE  LockService::GetLastIndex() const {return 0;}
		bool LockService::Empty() const {return true;}
		void LockService::GetInterval(INMOST_DATA_ENUM_TYPE & start, INMOST_DATA_ENUM_TYPE & end) const {start = 0; end = 0;}
#endif


////////class HessianMatrix

		void     HessianMatrix::Load(std::string file, INMOST_DATA_ENUM_TYPE mbeg, INMOST_DATA_ENUM_TYPE mend)
		{
			char str[16384];
			std::ifstream input(file.c_str());
			if( input.fail() ) throw -1;
			int state = 0, k;
			INMOST_DATA_ENUM_TYPE mat_size, max_lines, row, coli, colj, mat_block;
			INMOST_DATA_REAL_TYPE val;
			int size = 1, rank = 0;
#if defined(USE_MPI)
			int flag = 0;
			MPI_Initialized(&flag);
			if( flag && mend == ENUMUNDEF && mbeg == ENUMUNDEF )
			{
				MPI_Comm_rank(GetCommunicator(),&rank);
				MPI_Comm_size(GetCommunicator(),&size);
			}
#endif
			int line = 0;
			while( !input.getline(str,16384).eof() )
			{
				line++;
				k = 0; while( isspace(str[k]) ) k++;
				//TODO: check for %%MatrixMarket hessian coordinate real general
				if( str[k] == '%' || str[k] == '\\0' ) continue;
				std::istringstream istr(str+k);
				switch(state)
				{
					case 0:
						istr >> mat_size >> mat_size >> max_lines; state = 1;
						mat_block = mat_size/size;
						if( mbeg == ENUMUNDEF ) mbeg = rank*mat_block;
						if( mend == ENUMUNDEF )
						{
							if( rank == size-1 ) mend = mat_size;
							else mend = mbeg+mat_block;
						}
						SetInterval(mbeg,mend);
						//~ std::cout << rank << "" my interval "" << mbeg << "":"" << mend << std::endl;
						break;
					case 1:
						istr >> row >> coli >> colj >> val;
						row--; coli--; colj--;
						if( row >= mbeg && row < mend ) data[row][HessianRow::make_index(coli,colj)] = val;
						break;
				}
			}
			int nonzero = 0;
			for(iterator it = Begin(); it != End(); ++it) nonzero += it->Size();
			//~ std::cout << rank << "" total nonzero "" << max_lines << "" my nonzero "" << nonzero << std::endl;
			input.close();
		}

		HessianMatrix::HessianMatrix(std::string _name, INMOST_DATA_ENUM_TYPE start, INMOST_DATA_ENUM_TYPE end, INMOST_MPI_Comm _comm)
				:data(start,end)
		{
			is_parallel = false;
			comm = _comm;
			SetInterval(start,end);
			name = _name;
		}

		HessianMatrix::HessianMatrix(const HessianMatrix & other) :data(other.data)
		{
			comm = other.comm;
			name = other.name;
		}


		HessianMatrix & HessianMatrix::operator =(HessianMatrix const & other)
		{
			comm = other.comm;
			data = other.data;
			name = other.name;
			return *this;
		}

		HessianMatrix::~HessianMatrix() {}

		void     HessianMatrix::Save(std::string file, const AnnotationService * text)
		{
			INMOST_DATA_ENUM_TYPE matsize = Size(), nonzero = 0, row = GetFirstIndex()+1;
			bool have_annotation = false;
			if( text && !text->Empty() )
			{
				if( text->GetFirstIndex() == GetFirstIndex() &&
					text->GetLastIndex() == GetLastIndex())
					have_annotation = true;
				else
				{
					std::cout << ""Size of provided annotation ("" << text->GetFirstIndex() << "","" << text->GetLastIndex() << "")"" << std::endl;
					std::cout << ""differs from the size of the matrix ("" << GetFirstIndex() << "","" << GetLastIndex() << "")"" << std::endl;
				}
			}
			for(iterator it = Begin(); it != End(); ++it) nonzero += it->Size();
#if defined(USE_MPI)
			int rank = 0, size = 1;
			{
				MPI_Comm_rank(GetCommunicator(),&rank);
				MPI_Comm_size(GetCommunicator(),&size);
				INMOST_DATA_ENUM_TYPE temp_two[2] = {matsize,nonzero}, two[2];
				MPI_Allreduce(temp_two,two,2,INMOST_MPI_DATA_ENUM_TYPE,MPI_SUM,GetCommunicator());
				matsize = two[0];
				nonzero = two[1];
			}
#endif
			std::stringstream mtx(std::ios::in | std::ios::out);
			mtx << std::scientific;
			mtx.precision(15);
			for(INMOST_DATA_ENUM_TYPE k = GetFirstIndex(); k < GetLastIndex(); ++k)
			{
				if( have_annotation )
				{
					const std::string & str = text->GetAnnotation(k);
					if( !str.empty() ) mtx << ""% "" << str << ""\\n"";
				}
				for(HessianRow::iterator jt = (*this)[k].Begin(); jt != (*this)[k].End(); ++jt)
					mtx << row << "" "" << jt->first.first+1 << "" "" << jt->first.second+1 << "" "" << jt->second << ""\\n"";
				++row;
			}
#if defined(USE_MPI) && defined(USE_MPI_FILE) // USE_MPI2?
			{
				int ierr;
				MPI_File fh;
				MPI_Status stat;
				ierr = MPI_File_open(GetCommunicator(),const_cast<char *>(file.c_str()), MPI_MODE_CREATE | MPI_MODE_DELETE_ON_CLOSE | MPI_MODE_WRONLY, MPI_INFO_NULL, &fh);
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
				ierr = MPI_File_close(&fh);
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
				ierr = MPI_File_open(GetCommunicator(),const_cast<char *>(file.c_str()),MPI_MODE_WRONLY | MPI_MODE_CREATE,MPI_INFO_NULL,&fh);
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
				if( rank == 0 )
				{
					std::stringstream header;
					header << ""%%MatrixMarket hessian coordinate real general"" << std::endl;
					header << ""% matrix "" << name << std::endl;
					header << ""% is written by INMOST"" << std::endl;
					header << ""% by MPI_File_* api"" << std::endl;
					header << matsize << "" "" << matsize << "" "" << nonzero << std::endl;
					//std::string header_data(header.str());
					ierr = MPI_File_write_shared(fh,const_cast<char *>(header.str().c_str()),static_cast<int>(header.str().size()),MPI_CHAR,&stat);
					if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
				}
				ierr = MPI_File_write_ordered(fh,const_cast<char *>(mtx.str().c_str()),static_cast<int>(mtx.str().size()),MPI_CHAR,&stat);
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
				ierr = MPI_File_close(&fh);
				if( ierr != MPI_SUCCESS ) MPI_Abort(GetCommunicator(),__LINE__);
			}
#elif defined(USE_MPI)//USE_MPI alternative
			std::string senddata = mtx.str(), recvdata;
			int sendsize = static_cast<int>(senddata.size());
			std::vector<int> recvsize(size), displ(size);
			MPI_Gather(&sendsize,1,MPI_INT,&recvsize[0],1,MPI_INT,0,GetCommunicator());
			if( rank == 0 )
			{
				int totsize = recvsize[0];

				displ[0] = 0;
				for(int i = 1; i < size; i++)
				{
					totsize += recvsize[i];
					displ[i] = displ[i-1]+recvsize[i-1];
				}
				recvdata.resize(totsize);
			}
			else recvdata.resize(1); //protect from dereferencing null
			MPI_Gatherv(&senddata[0],sendsize,MPI_CHAR,&recvdata[0],&recvsize[0],&displ[0],MPI_CHAR,0,GetCommunicator());
			if( rank == 0 )
			{
				std::fstream output(file.c_str(),std::ios::out);
				output << ""%%MatrixMarket hessian coordinate real general"" << std::endl;
				output << ""% matrix "" << name << std::endl;
				output << ""% is written by INMOST"" << std::endl;
				output << ""% by MPI_Gather* api and sequential write"" << std::endl;
				output << matsize << "" "" << matsize << "" "" << nonzero << std::endl;
				output << recvdata;
			}
#else
			std::fstream output(file.c_str(),std::ios::out);
			output << ""%%MatrixMarket hessian coordinate real general"" << std::endl;
			output << ""% matrix "" << name << std::endl;
			output << ""% is written by INMOST"" << std::endl;
			output << ""% by sequential write "" << std::endl;
			output << matsize << "" "" << matsize << "" "" << nonzero << std::endl;
			output << mtx.rdbuf();
#endif
		}

		void HessianMatrix::Swap(HessianMatrix & other)
		{
			data.swap(other.data);
			name.swap(other.name);
			std::swap(comm,other.comm);
			std::swap(is_parallel,other.is_parallel);
		}
		void HessianMatrix::MatVec(INMOST_DATA_REAL_TYPE alpha, const Matrix & U, INMOST_DATA_REAL_TYPE beta, Matrix & J) const //y = alpha*A*x + beta * y
		{
			INMOST_DATA_ENUM_TYPE mbeg, mend;
			INMOST_DATA_INTEGER_TYPE ind, imbeg, imend;
			if( J.Empty() )
			{
				INMOST_DATA_ENUM_TYPE vbeg,vend;
				GetInterval(vbeg,vend);
				J.SetInterval(vbeg,vend);
			}
			//CHECK SOMEHOW FOR DEBUG THAT PROVIDED VECTORS ARE OK
			//~ assert(GetFirstIndex() == out.GetFirstIndex());
			//~ assert(Size() == out.Size());
			GetInterval(mbeg,mend);
			imbeg = mbeg;
			imend = mend;
#if defined(USE_OMP)
#pragma omp for private(ind)
#endif
			for(ind = imbeg; ind < imend; ++ind) //iterate rows of matrix
				(*this)[ind].RowVec(alpha,U[ind],beta,J[ind]);
			// outer procedure should update J Matrix, if needed
		}


#endif //USE_SOLVER
	}
}
",16352,True,2934.8850354860942,median
"[id=""contributing-to-docs-doc-guidelines""]
= Documentation guidelines
include::modules/common-attributes.adoc
:toc: macro

The documentation guidelines for OpenShift 4 build on top of the
link:https://redhat-documentation.github.io/modular-docs/[Red Hat modular docs reference guide].

toc::[]

== General file guidelines

* Set your editor to strip trailing whitespace.
* Do *not* hard wrap lines at 80 characters (or at any other length).
+
It is not necessary to update existing content to unwrap lines, but you can remove existing hard wrapping from any lines that you are currently working in.
+
[TIP]
====
In the Atom editor, you can use `Ctrl`+`J` to undo hard wrapping on a paragraph.
====

== Assembly file metadata

Every assembly file should contain the following metadata at the top, with no line
spacing in between, except where noted:

----
[id=""<unique-heading-for-assembly>""]                            <1>
= Assembly title                                                <2>
include::modules/common-attributes.adoc[]                       <3>
:context: <unique-context-for-assembly>                         <4>
                                                                <5>
toc::[]                                                         <6>
----

<1> A unique (within OpenShift docs) anchor id for this assembly. Example: cli-developer-commands
<2> Human readable title (notice the '=' top-level header)
<3> Includes attributes common to OpenShift docs.
+
[NOTE]
====
The `{product-name}` and `{product-version}` common attributes are not defined in the `modules/common-attributes.adoc` file. Those attributes are pulled by AsciiBinder from the distro mapping definitions in the https://github.com/openshift/openshift-docs/blob/main/_distro_map.yml[_distro_map.yml] file. See xref:product-name-and-version[Product name and version] for more information on this topic.
====
+
<4> Context used for identifying headers in modules that is the same as the anchor id. Example: cli-developer-commands.
<5> A blank line. You *must* have a blank line here before the toc.
<6> The table of contents for the current assembly.

After the heading block and a single whitespace line, you can include any content for this assembly.

[NOTE]
====
The assembly title, which is the first line of the document, is the only level 1 ( = ) title.
Section headers within the assembly must be level 2 ( == ) or lower. When you include modules, you must add
leveloffsets in the include statements. You can manually add more level 2 or lower section headers in the assembly.
====

== Module file metadata
Every module should be placed in the modules folder and should contain the following metadata at the top:

----
// Module included in the following assemblies:
//
// * list of assemblies where this module is included              <1>

[id=""<module-anchor>_{context}""]                                   <2>
= Module title                                                     <3>
----

<1> List of assemblies in which this module is included.
<2> A module anchor with {context} that must match the module's file name.
<3> Human readable title. To ensure consistency in the results of the
leveloffset values in include statements, you must use a level one heading
( = ) for the module title.

Example:

----
// Module included in the following assemblies:
//
// * cli_reference/openshift_cli/developer-cli-commands.adoc

[id=""cli-basic-commands_{context}""]
= Basic CLI commands
----

== Assembly/module file names

Try to shorten the file name as much as possible _without_ abbreviating important terms that may cause confusion. For example, the `managing-authorization-policies.adoc` file name would be appropriate for an assembly titled ""Managing Authorization Policies"".

== Directory names

If you create a directory with a multiple-word name, separate each word with an underscore, for example `backup_and_restore`. Do not create a top-level directory in the repository without checking with the docs team. In the main OpenShift docs, you can create one level of subdirectories. In the docs for features that are designed to be used with OpenShift, such as Service Mesh and OpenShift virtualization, you can create two levels of subdirectories.

When creating a new directory or subdirectory, you must create two symbolic links in it:

* An `images` symbolic link to the top-level `images/` directory
* A `modules` symbolic link to the top-level `modules/` directory

If the directory that contains an assembly does not have the `images` symbolic link, any images in that assembly or its modules will not be included properly when building the docs.

[TIP]
====
To create the symbolic links:

. Navigate to the directory that you need to add the links in.
. Use the following command to create a symbolic link:
+
----
$ ln -s <target_directory> <link_name>
----
+
For example, if you are creating the links in a directory that is two levels deep, such as `cli_reference/openshift_cli`, use the following commands:
+
----
$ ln -s ../../images/ images
$ ln -s ../../modules/ modules
----
+
Be sure to adjust the number of levels to back up (`../`) depending on how deep your directory is.

If you accidentally create an incorrect link, you can remove that link by using `unlink <link_name>`.
====

== Assembly/Module titles and section headings

Use sentence case in all titles and section headings. See http://www.titlecase.com/ or https://convertcase.net/ for a conversion tool.

Try to be as descriptive as possible with the title or section headings
without making them unnecessarily long. For assemblies and task modules,
use a gerund form in headings, such as:

* Creating
* Managing
* Using

Do not use ""Overview"" as a heading.

Do not use backticks or other markup in assembly or module headings.

=== Discrete headings

If you have a section heading that you do not want to appear in the TOC (like if you think that some section is not worth showing up or if there are already too many nested levels), you can use a discrete (or floating) heading:

http://asciidoctor.org/docs/user-manual/#discrete-or-floating-section-titles

A discrete heading also will not get a section number in the Customer Portal build of the doc. Previously, we would use plain bold mark-up around a heading like this, but discrete headings also allow you to ignore section nesting rules (like jumping from a `==` section level to a `====` level if you wanted for some style reason).

To use a discrete heading, just add `[discrete]` to the line before your unique ID. For example:

----
[discrete]
[id=""managing-authorization-policies_{context}""]
== Managing authorization policies
----

== Anchoring titles and section headings

All titles and section headings must have an anchor ID. The anchor ID must be similar to the title or section heading.

=== Anchoring in assembly files

The following is an example anchor ID in an assembly file:

----
[id=""configuring-alert-notifications""]
= Configuring alert notifications
----

[NOTE]
====
Do not include line spaces between the anchor ID and the section title.
====

=== Anchoring in module files

You must add the `{context}` variable to the end of anchor IDs in module files. When called, the `{context}` variable is resolved into the value declared in the `:context:` attribute in the corresponding assembly file. This enables cross-referencing to module IDs in context to a specific assembly and is useful when a module is included in multiple assemblies.

The following is an example of an anchor ID in a module file:

----
[id=""sending-notifications-to-external-systems_{context}""]
= Sending notifications to external systems
----

[NOTE]
====
The `{context}` variable must be preceded by an underscore (`_`) when declared in an anchor ID.
====

=== Anchoring ""Prerequisites"", ""Additional resources"", and ""Next steps"" titles in assemblies

Use unique IDs for ""Prerequisites"", ""Additional resources"", and ""Next steps"" titles in assemblies. You can add the prefixes `prerequisites_`, `additional-resources_`, or `next-steps_` to a unique string that describes the assembly topic. The unique string can match the value assigned to the `:context:` attribute in the assembly.

[NOTE]
====
The `prerequisites_`, `additional-resources_`, and `next-steps_` prefixes must end with an underscore (`_`) when declared in an anchor ID in an assembly.
====

The following examples include IDs that are unique to the ""Configuring alert notifications"" assembly:

*Example unique ID for a ""Prerequisites"" title*

----
[id=""prerequisites_configuring-alert-notifications""]
== Prerequisites
----

*Example unique ID for an ""Additional resources"" title*

----
[id=""additional-resources_configuring-alert-notifications""]
== Additional resources
----

*Example unique ID for a ""Next steps"" title*

----
[id=""next-steps_configuring-alert-notifications""]
== Next steps
----

== Writing assemblies
An _assembly_ is a collection of modules that describes how to accomplish a user story.

For more information about forming assemblies, see the
link:https://redhat-documentation.github.io/modular-docs/#forming-assemblies[Red Hat modular docs reference guide] and the link:https://raw.githubusercontent.com/redhat-documentation/modular-docs/master/modular-docs-manual/files/TEMPLATE_ASSEMBLY_a-collection-of-modules.adoc[assembly template].

[NOTE]
====
When using the ""Prerequisites"", ""Next steps"", or ""Additional resources"" headings in an assembly, use `==` formatting, such as `== Prerequisites` or `== Additional resources`. Use of this heading syntax at the assembly level indicates that the sections relate to the whole assembly.

Only use `.` formatting (`.Additional resources`) to follow a module in an assembly. Because you cannot use the xrefs in modules, this functions as a _trailing include_ at the assembly level, where the `.` formatting of the `include` statement indicates that the resource applies specifically to the module and not to the assembly.
====

== Writing concepts
A _concept_ contains information to support the tasks that users want to do and
must not include task information like commands or numbered steps. In most
cases, create your concepts as individual modules and include them in
appropriate assemblies.

Avoid using gerunds in concept titles. ""About <concept>""
is a common concept module title.

For more information about creating concept modules, see the
link:https://redhat-documentation.github.io/modular-docs/#creating-concept-modules[Red Hat modular docs reference guide] and the link:https://raw.githubusercontent.com/redhat-documentation/modular-docs/master/modular-docs-manual/files/TEMPLATE_CONCEPT_concept-explanation.adoc[concept template].

== Writing procedures
A _procedure_ contains the steps that users follow to complete a process or task. Procedures contain ordered steps and explicit commands. In most cases, create your procedures as individual modules and include them in appropriate assemblies.

Use a gerund in the procedure title, such as ""Creating"".

For more information about writing procedures, see the
link:https://redhat-documentation.github.io/modular-docs/#creating-procedure-modules[Red Hat modular docs reference guide] and the link:https://raw.githubusercontent.com/redhat-documentation/modular-docs/master/modular-docs-manual/files/TEMPLATE_PROCEDURE_doing-one-procedure.adoc[procedure template].

[NOTE]
====
When needed, use `.Prerequisites`, `.Next steps`, or `.Additional resources` syntax to suppress TOC formatting within a module. Do not use `==` syntax for these headings in modules. Because you cannot use the xrefs in modules, if you need to include a link under one of these headings, place the entire subsection in the assembly instead.
====

[id=""using-conscious-language""]
== Using conscious language

To assist with the removal of the problematic word ""master"" from the documentation, use the following terminology when referring to OpenShift control plane nodes:

[options=""header""]
|===
|Branch |Control plane node reference

|`main` and `enterprise-4.9`
|Control plane node

|`enterprise-4.8` and earlier
|Control plane (also known as master) node

|`enterprise-3.11`
|Master node

|===

You can replace ""node"" in the preceding examples with ""machine"", ""host"", or another suitable description.

[NOTE]
====
If you are cherry picking from `main` to `enterprise-4.8` or earlier, you must manually cherry pick to include the “(also known as master)” phrasing. This is required only if the phrase “control plane” is introduced for the first time in an assembly or module.
====

[id=""adding-a-subsection-on-making-open-source-more-inclusive""]
=== Adding a subsection on making open source more inclusive

If you create a release notes assembly for a sub-product within the `openshift/openshift-docs` repo, you might include a ""Making open source more inclusive"" statement. Instead of pasting the statement from the OpenShift Release Notes, use the following module, which is available in the `enterprise-4.8` branch and later:

[source,text]
----
\\include::modules/making-open-source-more-inclusive.adoc[leveloffset=+1]
----

[id=""product-name-and-version""]
== Product name and version

When possible, generalize references to the product name and/or version by using
the `{product-title}` and/or `{product-version}` attributes. These attributes
are pulled by AsciiBinder from the distro mapping definitions in the
https://github.com/openshift/openshift-docs/blob/main/_distro_map.yml[_distro_map.yml]
file.

The `{product-title}` comes from the first `name:` field in a distro mapping,
while the associated `{product-version}` comes from the `name:` fields on any
`branches:` defined.

How these attributes render is dependent on which distro and branch build you
are viewing. The following table shows the current distros and the
possible values for `{product-title}` and `{product-version}`.

[options=""header""]
|===
|Distro |`{product-title}` |`{product-version}`

|`openshift-origin`
|OKD
|1.2, 1.3, 1.4, 1.5, 3.6, 3.7, 3.9, 3.10, 3.11, Latest

|`openshift-enterprise`
|OpenShift Container Platform
|3.0, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.9, 3.10, 3.11, 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7

|`openshift-dedicated`
|OpenShift Dedicated
|Latest

|`openshift-online`
|OpenShift Online
|Latest
|===

For example:

----
You can deploy applications on {product-title}.
----

This is a safe statement that could appear in probably any of the builds, so an
https://github.com/openshift/openshift-docs/blob/main/contributing_to_docs/contributing.adoc#conditional-text-between-products[ifdef/endif
statement] is not necessary. For example, if you were viewing a build for the
`openshift-enterprise` distro (for any of the distro-defined branches), this
would render as:

> You can deploy applications on OpenShift Container Platform.

And for the `openshift-origin` distro:

> You can deploy applications on OKD.

Considering that we use distinct branches to keep content for product versions separated, global use of `{product-version}` across all branches is probably less useful, but it is available if you come across a requirement for it. Just consider how it will render across any branches that the content appears in.

If it makes more sense in context to refer to the major version of the product instead of a specific minor version (for example, if comparing how something in OpenShift Container Platform 4 differs from OpenShift Container Platform 3), just use the major version number. Do not prepend with a `v`, as in `v3` or `v4`.

[NOTE]
====
Other common attribute values are defined in the `modules/common-attributes.adoc` file. Where possible, generalize references to those values by using the common attributes. For example, use `{cloud-redhat-com}` to refer to Red Hat OpenShift Cluster Manager.
====

== Node names

Do not use internal company server names in commands or example output. Provide generic OpenShift Container Platform node name examples that are not provider-specific, unless required. Where possible, use the example.com domain name when providing fully qualified domain names (FQDNs).

The following table includes example OpenShift Container Platform 4 node names and their corresponding role types:

[options=""header""]
|===

|Node name |Role type

|*node-1.example.com*
.3+.^|You can use this format for nodes that do not need role-specific node names.

|*node-2.example.com*

|*node-3.example.com*

|*control-plane-1.example.com*
.3+.^|You can use this format if you need to describe the control plane role type within a node name.

|*control-plane-2.example.com*

|*control-plane-3.example.com*

|*compute-1.example.com*
.2+.^|You can use this format if you need to describe the compute node role type within a node name.

|*compute-2.example.com*

|*bootstrap.example.com*
|You can use this format if you need to describe the bootstrap node role type within a node name.
|===

This example lists the status of cluster nodes that use the node name formatting guidelines:

....
[source,terminal]
----
$ oc get nodes
----
+
.Example output
[source,terminal]
----
NAME                          STATUS   ROLES    AGE   VERSION
compute-1.example.com         Ready    worker   33m   v1.19.0+9f84db3
control-plane-1.example.com   Ready    master   41m   v1.19.0+9f84db3
control-plane-2.example.com   Ready    master   45m   v1.19.0+9f84db3
compute-2.example.com         Ready    worker   38m   v1.19.0+9f84db3
compute-3.example.com         Ready    worker   33m   v1.19.0+9f84db3
control-plane-3.example.com   Ready    master   41m   v1.19.0+9f84db3
----
....

[NOTE]
====
Some provider-formatted hostnames include IPv4 addresses. An OpenShift Container Platform node name typically reflects the hostname of a node. If node names in your output need to be provider-specific and require this format, use private IPv4 addresses. For example, you could use `ip-10-0-48-9.example.com` as a node name that includes a private IPv4 address.
====

== IP addresses

You may include IPv4 addresses from test clusters in examples in the documentation, as long as they are private. Private IPv4 addresses fall into one of the following ranges:

* 10.0.0.0 to 10.255.255.255 (class A address block 10.0.0.0/8)
* 172.16.0.0 to 172.31.255.255 (class B address block 172.16.0.0/12)
* 192.168.0.0 to 192.168.255.255 (class C address block 192.168.0.0/16)

Replace all public IP addresses with an address from the following blocks. These address blocks are reserved for documentation:

* 192.0.2.0 to 192.0.2.255 (TEST-NET-1 address block 192.0.2.0/24)
* 198.51.100.0 to 198.51.100.255 (TEST-NET-2 address block 198.51.100.0/24)
* 203.0.113.0 to 203.0.113.255 (TEST-NET-3 address block 203.0.113.0/24)

[NOTE]
====
There might be advanced networking examples that require specific IP addresses, or cloud provider-specific examples that require a public IP address. Contact a subject matter expert if you need assistance with replacing IP addresses.
====

== Links, hyperlinks, and cross references
Links can be used to cross-reference internal assemblies or send readers to external information resources for further reading.

In OpenShift docs:

* All links to internal content is created using `xref` and **must have an anchor ID**.
* Only use `xref` in assemblies, not modules.
* All links to external websites are created using `link`.

[IMPORTANT]
====
Do not split link paths across lines when wrapping text. This will cause issues with the doc builds.
====

=== Example URLs
To provide an example URL path that you do not want to render as a hyperlink, use this format:

....
`\\https://www.example.com`
....

=== Internal cross-references
Whenever possible the link to another assembly should be part of the actual sentence.
Avoid creating links as a separate sentence that begins with ""See [this assembly] for more information on x"".

[NOTE]
====
Use the relative file path (from the file you are editing, to the file you are linking to),
even if you are linking to the same directory that you are writing in. This makes search and replace
operations to fix broken links much easier.

For example, if you are writing in *_architecture/core_concepts/deployments.adoc_* and you want to
link to *_architecture/core_concepts/routes.adoc_* then you must include the path back to the first
level of the assembly directory:

----
xref:../../architecture/networking/routes.adoc#architecture-core-concepts-routes
----
====

.Markup example of cross-referencing
----
Rollbacks revert part of an application back to a previous deployment. Rollbacks can be performed using the REST API or
the xref:../cli_reference/openshift_cli/get_started_cli.adoc#installing-openshift-cli[OpenShift CLI].

Before you can create a domain, you must first xref:../dev_guide/application_lifecycle/new_app.adoc#dev-guide-new-app[create an application].
----

.Rendered output of cross-referencing
> Rollbacks revert part of an application back to a previous deployment. Rollbacks can be performed using the REST API or the xref:../cli_reference/openshift_cli/get_started_cli.adoc#installing-openshift-cli[OpenShift CLI].
>
> Before you can create a domain, you must first xref:../dev_guide/application_lifecycle/new_app.adoc#dev-guide-new-app[create an application].

=== Links to external websites

If you want to link to a different website, use:

----
link:http://othersite.com/otherpath[friendly reference text]
----

IMPORTANT: You must use `link:` before the start of the URL.

IMPORTANT: You cannot link to a repository that is hosted on www.github.com.

TIP: If you want to build a link from a URL _without_ changing the text from the actual URL, just print the URL without adding a `[friendly text]` block at the end; it will automatically be rendered as a link.

=== Links to internal content
There are two scenarios for linking to other assemblies:

1. Link to another file that exists in the same directory.
2. Link to another file that exists in a separate directory.

The following examples use the example directory structure shown here:
....
/
/foo
/foo/bar.adoc
/baz
/baz/zig.adoc
/baz/zag.adoc
....

*Link to assembly in same directory*

----
xref:<filename>#anchor-id[friendly title]
----

You must use the `.adoc` file extension. The document processor will correctly link this to the resulting HTML file.

For example, using the above syntax, if you are working on `zig.adoc` and want to link to `zag.adoc`, do it this way:

----
xref:../zag.adoc#baz-zag[comment]
----

where `baz-zag` is the anchor ID at the top of the file `zag.adoc`.

*Link to assembly in different directory*

----
xref:../dir/<filename>.adoc#anchor-id[friendly title]
----

For example, if you are working on `bar.adoc` and you want to link to `zig.adoc`, do it this way:

----
xref:../baz/zig.adoc#baz-zig[see the ZIG manual for more]
----

[NOTE]
====
You must use the .adoc extension in order for the link to work correctly and you must specify an anchor ID.
====

== Embedding an external file

You can embed content hosted outside the link:https://github.com/openshift/openshift-docs[openshift-docs]
GitHub repository by using the `include` directive to target the URI of a raw
file. This is helpful for cases where content frequently changes; you embed the raw
file and the content auto-updates based on the changes made to the content on its
host site.

[IMPORTANT]
====
You are restricted to only embed files from GitHub repositories managed by the
`openshift` GitHub user. You must also prefix your external file URI with `https`.
URIs beginning with `http` are forbidden for security reasons and will fail the
documentation build.
====

For example, if you want to embed the link:https://github.com/openshift/installer/blob/release-4.8/upi/azure/01_vnet.json[01_vnet.json] template, include the URI of its raw file version like this:

```
.`01_vnet.json` ARM template
[source,json]
----
\\include::https://raw.githubusercontent.com/openshift/installer/release-4.8/upi/azure/01_vnet.json[]
----
```

[NOTE]
====
Embedding external files is restricted for files that change frequently, like templates. You must ensure that embedded files are QE verified before they are updated on their host site.
====

[NOTE]
====
You must get approval from the Engineering, QE, and Docs teams before embedding an external file.
====

== Indicating Technology Preview features

To indicate that a feature is in Technology Preview, include the
`modules/technology-preview.adoc` file in the feature's assembly to keep the
supportability wording consistent across Technology Preview features and provide a value for the :FeatureName: variable before you include this module.

See link:https://github.com/openshift/openshift-docs/pull/13878/files#diff-615ba1bf3b09d11a9c2604b775aa32f2[an example] of how this is applied.

== Indicating deprecated features

To indicate that a feature is deprecated, include the `modules/deprecated-feature.adoc` file in the feature's assembly, or to each relevant assembly such as for a deprecated Operator, to keep the supportability wording consistent across deprecated features. Provide a value for the :FeatureName: variable before you include this module.

See link:https://github.com/openshift/openshift-docs/pull/31776/files[an example] of how this is applied.

== Verification of your content
All documentation changes must be verified by a QE team associate before merging. This includes executing all ""Procedure"" changes and confirming expected results. There are exceptions for typo-level changes, formatting-only changes, and other negotiated documentation sets and distributions.

If a documentation change is due to a Bugzilla bug or Jira issue, the bug/issue should be put on ON_QA when you have a PR ready. After QE approval is given (either in the bug/issue or in the PR), the QE associate should move the bug/issue status to VERIFIED, at which point the associated PR can be merged. It is also ok for the assigned writer to change the status of the bug/issue to VERIFIED if approval for the changes has been provided in another forum (slack, PR, or email). The writer should indicate that the QE team approved the change as a comment in the bug/issue.

== Images

=== Block images

To include a block image (an image on its own line):

1. Put the image file in the `images` folder.
+
Ensure that the folder containing your assembly contains an `images` symbolic link to the top-level `images/` directory, otherwise the image will not be found when building the docs.

2. In the `.adoc` content, use this format to link to the image:
+
----
image::<image_filename>[<alt_text>]
----
+
Note the double `::` instead of a single `:`, as seen in inline image usage.
You only have to specify `<image_filename>` itself and not the full file path;
the build mechanism automatically expands this appropriately.

=== Inline images (icons)

Inline images can be used to indicate graphic items in the web console, such as
buttons or menu icons.

====  Inserting reusable images inline

To simplify reuse, the following common SVGs (the OpenShift web console uses the
Font Awesome icon set) have already been added to the `images` folder with a
user-defined entity added to the `common-attributes.adoc` module:

|===
|Icon |Entity |Alt text |File name

|Kebab
|`:kebab:`
|Options menu
|`ellipsis-v.svg`

|===

When using inline, include the image after the UI element name. For example:

----
Click the *Options* menu {kebab}.
----

==== Inserting images inline without reuse

If you are inserting an image that is not part of the `common-attributes.adoc`
module, then include the image using this formatting:

----
image:<image_filename>[title=""<alt_text>""]
----

Note the single `:` instead of a double `::`, as seen in block image usage.

For example:

----
image:manage-columns.png[title=""Manage Columns icon""]
----

== Formatting

For all of the system blocks including table delimiters, use four characters. For example:

....
|=== for tables
---- for code blocks
....

[NOTE]
====
You can use backticks or other markup in the title for a block, such as a code block `.Example` or a table `.Description` title.
====

=== Code blocks, command syntax, and example output

Code blocks are generally used to show examples of command syntax, example
screen output, and configuration files.

The main distinction between showing command syntax and a command example is
that a command syntax shows readers how to use the command without real values.
An example command, however, shows the command with actual values with an
example output of that command, where applicable.

For example:

....
In the following example, the `oc get` operation returns a complete list of services that are currently defined:

[source,terminal]
----
$ oc get se
----

.Example output
[source,terminal]
----
NAME                LABELS                                    SELECTOR            IP                  PORT
kubernetes          component=apiserver,provider=kubernetes   <none>              172.30.17.96        443
kubernetes-ro       component=apiserver,provider=kubernetes   <none>              172.30.17.77        80
docker-registry     <none>                                    name=registrypod    172.30.17.158       5001
----
....

This renders as:

> In the following example, the `oc get` operation returns a complete list of services that are currently defined:
>
> ----
> $ oc get se
> ----
>
> .Example output
> ----
> NAME                LABELS                                    SELECTOR            IP                  PORT
> kubernetes          component=apiserver,provider=kubernetes   <none>              172.30.17.96        443
> kubernetes-ro       component=apiserver,provider=kubernetes   <none>              172.30.17.77        80
> docker-registry     <none>                                    name=registrypod    172.30.17.158       5001
> ----

The following guidelines go into more detail about specific requirements and
recommendations when using code blocks:

* If a step in a procedure is to run a command, make sure that the step
text includes an explicit instruction to ""run"" or ""enter"" the command. In most cases,
use one of the following patterns to introduce the code block:

** <Step description>, run the following command:
** <Step description>, enter the following command:

* Do NOT use any markup in code blocks; code blocks generally do not accept any markup.

* For all code blocks, you must include an empty line above a code block (unless
that line is introducing block metadata, such as `[source,terminal]` for syntax
highlighting).
+
Acceptable:
+
....
Lorem ipsum

----
$ lorem.sh
----
....
+
Not acceptable:
+
....
Lorem ipsum
----
$ lorem.sh
----
....
+
Without the line spaces, the content is likely to be not parsed correctly.

* Use `[source,terminal]` for `oc` commands or any terminal commands to enable
syntax highlighting. Any `[source]` metadata must go on the line directly before
the code block. For example:
+
....
[source,terminal]
----
$ oc get nodes
----
....
+
If you are also showing a code block for the output of the command, use
`[source,terminal]` for that code block as well.

* Use source tags for the programming language used in the code block to enable
syntax highlighting. For example:

** `[source,yaml]`
** `[source,go]`
** `[source,javascript]`

* Do not use more than one command per code block. For example, the following must
be split up into three separate code blocks:
+
....
To create templates you can modify, run the following commands :

[source,terminal]
----
$ oc adm create-login-template > login.html
----

[source,terminal]
----
$ oc adm create-provider-selection-template > providers.html
----

[source,terminal]
----
$ oc adm create-error-template > errors.html
----
....

* Separate a command and its related example output into individual code blocks.
This allows the command to be easily copied using the button on
+++docs.openshift.com+++.
+
In addition, prepend the code block for the output with the title `.Example output`
to make it consistently clear across the docs when this is being represented. A
lead-in sentence explaining the example output is optional. For example:
+
....
Use the `oc new-project` command to create a new project:

[source,terminal]
----
$ oc new-project my-project
----

The output verifies that a new project was created:

.Example output
[source,terminal]
----
Now using project ""my-project"" on server ""https://openshift.example.com:6443"".
----
....

* To mark up command syntax, use the code block and wrap any replaceable values in
angle brackets (`<>`) with the required command parameter, using underscores
(`_`) between words as necessary for legibility. For example:
+
....
To view a list of objects for the specified object type, enter the following command:

[source,terminal]
----
$ oc get <object_type> <object_id>
----
....
+
This renders as:
+
--
> To view a list of objects for the specified object type, enter the following command:
>
> ----
> $ oc get <object_type> <object_id>
> ----
--
+
NOTE: Avoid using full command syntax inline with sentences.

* If you must provide additional information on what a line of a code block
represents, use callouts (`<1>`, `<2>`, etc.) to provide that information.
+
Use this format when embedding callouts into the code block:
+
[subs=-callouts]
....
----
code example 1 <1>
code example 2 <2>
----
<1> A note about the first example value.
<2> A note about the second example value.
....

* If you must provide additional information on what a line of a code block
represents and the use of callouts is impractical, you can use a description list
to provide information about the variables in the code block. Using callouts
might be impractical if a code block contains too many conditional statements to
easily use numbered callouts or if the same note applies to multiple lines of the codeblock.
+
....
----
code <variable_1>
code <variable_2>
----
+
where:

<variable_1>:: Specifies the explanation of the first variable.
<variable_2>:: Specifies the explanation of the first variable.
....
+
Be sure to introduce the description list with ""where:"" and start each variable
description with ""Specifies.""

* For long lines of code that you want to break up among multiple lines, use a
backslash to show the line break. For example:
+
----
$ oc get endpoints --all-namespaces --template \\
    '{{ range .items }}{{ .metadata.namespace }}:{{ .metadata.name }} \\
    {{ range .subsets }}{{ range .addresses }}{{ .ip }} \\
    {{ end }}{{ end }}{{ ""\\n"" }}{{ end }}' | awk '/ 172\\.30\\./ { print $1 }'
----

* If the user must run a command as root, use a number sign (`#`) at the start of the command instead of a dollar sign (`$`). For example:
+
----
# subscription-manager list
----

* For snippets or sections of a larger file, use an ellipsis (`...`) to show that
the file continues before and/or after the quoted block:
+
----
apiVersion: v1
kind: Pod
metadata:
  labels:
    test: liveness
...
----
+
or
+
----
...
spec:
  containers:
  - args:
    image: k8s.gcr.io/liveness
...
----
+
Do not use `[...]`, `<snip>`, or any other variant.

* Do not use `jq` in commands (unless it is truly required), because this requires users to install the `jq` tool. Oftentimes, the same or similar result can be accomplished using `jsonpath` for `oc` commands.
+
For example, this command that uses `jq`:
+
----
$ oc get clusterversion -o json|jq "".items[0].spec""
----
+
can be updated to use `jsonpath` instead:
+
----
$ oc get clusterversion -o jsonpath='{.items[0].spec}{""\\n""}'
----

=== Inline code or commands
Do NOT show full commands or command syntax inline within a sentence. The next section covers how to show commands and command syntax.

Only use case for inline commands would be general commands and operations, without replaceables and command options. In this case an inline command is marked up using the back ticks:

....
Use the `GET` operation to do x.
....

This renders as:

> Use the `GET` operation to do x.

=== System messages

System messages include error, warning, confirmation, and information messages that are presented to the user in places such as the GUI, CLI, or system logs.

If a message is short enough to include inline, enclose it in back ticks:

....
Previously, image builds and pushes would fail with the `error reading blob from source` error message because the builder logic would compute the contents of new layers twice.
....

This renders as:

> Previously, image builds and pushes would fail with the `error reading blob from source` error message because the builder logic would compute the contents of new layers twice.

If a message is too long to include inline, put it inside a code block with `[source,text]` metadata:

....
Previously, the AWS Terraform provider that the installation program used occasionally caused a race condition with the S3 bucket, and the cluster installation failed with the following error message:

[source,text]
----
When applying changes to module.bootstrap.aws_s3_bucket.ignition, provider level=error msg=""\\""aws\\"" produced an unexpected new value for was present, but now absent.
----

Now, the installation program uses different AWS Terraform provider code, which now robustly handles S3 eventual consistency, and the installer-provisioned AWS cluster installation does not fail with that error message.
....

This renders as:

> Previously, the AWS Terraform provider that the installation program used occasionally caused a race condition with the S3 bucket, and the cluster installation failed with the following error message:
>
> ----
> When applying changes to module.bootstrap.aws_s3_bucket.ignition, provider level=error msg=""\\""aws\\"" produced an unexpected new value for was present, but now absent.
> ----
>
> Now, the installation program uses different AWS Terraform provider code, which now robustly handles S3 eventual consistency, and the installer-provisioned AWS cluster installation does not fail with that error message.

NOTE: Always refer to a message with the type of message it is, followed by the word ""message"". For example, refer to an error message as an ""error message"", and not simply as an ""error"".

=== Lists
Lists are created as shown in this example:

....
. Item 1 (2 spaces between the period and the first character)

. Item 2

. Item 3
....

This renders as:

> . Item 1
> . Item 2
> . Item 3

If you must add any text, admonitions, or code blocks you have to add the continuous +, as shown in the example:

....
. Item 1
+
----
some code block
----

. Item 2

. Item 3
....

This renders as:

> . Item 1
> +
> ----
> some code block
> ----
> . Item 2
> . Item 3

=== Footnotes

Avoid footnotes when possible.

If you reference a footnote from only a single location, use the following syntax:

.Footnote
....
footnote:[This is the footnote text.]
....

If you reference a footnote from multiple locations, set an attribute with the footnote text. As a consequence, this will duplicate the footnote text at bottom of the page.

.Footnote with text set by an attribute
....
:note-text: This is a footnote.

This text has a footnote qualifier attached footnote:[{note-text}].

But this other text uses the same qualifier elsewhere footnote:[{note-text}].
....

Avoid using `footnoteref`.

[IMPORTANT]
====
The `footnoteref` directive is deprecated in asciidoctor and causes a build warning when `ascii_binder` is run.
====

.Footnote with reference
....
footnoteref:[ref-string, This is the footnote text.]
....

==== Alternative footnote styling in tables

For footnotes in tables, use the following syntax to mimic Asciidoctor's
styling:

....
[cols=""3"",options=""header""]
|===
|Header 1
|Header 2
|Header 3

|Item A ^[1]^
|Item B
|Item C ^[2]^

|Item D
|Item E ^[3]^
|Item F ^[3]^
|===
[.small]
--
1. A description.
2. Another description.
3. Two items relate to this description.
--
....

The notes are kept immediately after the table, instead of moved to the bottom
of the rendered assembly. This manual method also allows you to reuse the same
footnote number for multiple references as needed.

Note the following:

* Add a space before the superscripted numbers with square brackets.
* To match the table cell's font size, start the ordered list with a `[.small]`
style and wrap it in a `--` block.

[id=""collapsible-content""]
=== Collapsible content
You can collapse sections of content by using the `collapsible` option, which converts the Asciidoctor markup to HTML `details` and `summary` sections. The `collapsible` option is used at the writer's discretion and is appropriate for considerably long code blocks, lists, or other such content that significantly increases the length of a module or assembly.

[NOTE]
====
You must set a title for the `summary` section. If a title is not set, the default title is ""Details.""
====

Collapsible content is formatted as shown:

....
.Title of the `summary` dropdown
[%collapsible]
====
This is content within the `details` section.
====
....

This renders as a dropdown with collapsed content:

.Title of the `summary` dropdown
[%collapsible]
====
This is content within the `details` section.
====

If your collapsible content includes an admonition such as a note or warning, the admonition must be nested:

....
.Collapsible content that includes an admonition
[%collapsible]
====
This content includes an admonition.

[source,terminal]
----
$ oc whoami
----

[NOTE]
=====
Nest admonitions when using the `collapsible` option.
=====
====
....

This renders as:

.Collapsible content that includes an admonition
[%collapsible]
====
This content includes an admonition.

[source,terminal]
----
$ oc whoami
----

[NOTE]
=====
Nest admonitions when using the `collapsible` option.
=====
====

=== Quick reference

.User accounts and info
[option=""header""]
|===
|Markup in command syntax |Description |Substitute value in Example block

|`<username>`
|Name of user account
|user@example.com

|`<password>`
|User password
|password
|===

.Projects and applications
[option=""header""]
|===
|Markup in command syntax |Description |Substitute value in Example block

|`<project>`
|Name of project
|myproject

|`<app>`
|Name of an application
|myapp
|===

== Admonitions
Admonitions such as notes and warnings are formatted as shown:

....
[ADMONITION]
====
Text for admonition
====
....

[id=""api-object-formatting""]
== API object formatting

For terms that are API objects, the way they are written depends on whether the term is a general reference or an actual reference to the object.

[id=""api-object-general-references""]
=== General references

A general reference is any time you are speaking conceptually, or generally, about these components in a cluster.

When referring to API object terms in general usage, use lowercase and separate multi-word API objects. *Default to following this guidance unless you are specifically interacting with/referring to the API object (see xref:api-object-object-references[Object references]).*

For example:

* pod
* node
* daemon set
* config map
* deployment
* image stream
* persistent volume claim

.Examples of general references
....
Kubernetes runs your workload by placing containers into pods to run on nodes.

You must have at least one secret, config map, or service account.

The total number of persistent volume claims in a project.
....

Note that if an object uses an acronym or other special capitalization, then its general reference should honor that. For example, general references to `APIService` should be written as ""API service"", not ""api service"". Any other exceptions or special guidance are noted in the xref:../contributing_to_docs/term_glossary.adoc[glossary].

[id=""api-object-object-references""]
=== Object references

An object reference is when you are referring to the actual instance of an API object, where the object name is important.

When referring to actual instances of API objects, use link:https://en.wikipedia.org/wiki/Camel_case#Variations_and_synonyms[PascalCase] and mark it up as monospace in backticks (````).

[NOTE]
====
Do not use backticks or other markup in assembly or module headings. You can use backticks or other markup in the title for a block, such as a code block `.Example` or a table `.Description` title.
====

Be sure to match the proper object type (or `kind` in Kubernetes terms); for example, do not add an ""s"" to make it plural. *Only follow this guidance if you are explicitly referring to the API object (for example, when editing an object in the CLI or viewing an object in the web console).*

For example:

* `Pod`
* `Node`
* `DaemonSet`
* `ConfigMap`
* `Deployment`
* `ImageStream`
* `PersistentVolumeClaim`

.Examples of API object references
....
After you create a `Node` object, or the kubelet on a node self-registers, the control plane checks whether the new `Node` object is valid.

The default amount of CPU that a container can use if not specified in the `Pod` spec.

Create a file, `pvc.yaml`, with the `PersistentVolumeClaim` object definition.
....

[NOTE]
====
Use ""object"", ""resource"", ""custom resource"", ""spec"", etc. as appropriate after the object reference. This helps with clarity and readability.

Another situation where this is necessary is when referring to the plural version of objects. Do not add an ""s"" to the end of an object name reference to make it plural. Use only the official `kind` of object (for example, seen when you run `oc api-resources`).

For example, the object `kind` for a node is `Node`, not `Nodes`. So do not write ""You can create `Nodes` using `kubectl`."" Instead, rewrite to something like ""You can create `Node` objects using `kubectl`.""
====

[id=""operator-name-capitalization""]
=== Operator capitalization

The term ""Operator"" is always capitalized. For example:

----
= Support policy for unmanaged Operators

Individual Operators have a `managementState` parameter in their configuration.
----

An Operator's full name must be a proper noun, with each word initially
capitalized. If it includes a product name, defer the product's capitalization
style guidelines. For example:

- Red Hat OpenShift Logging Operator
- Prometheus Operator
- etcd Operator
- Node Tuning Operator
- Cluster Version Operator

== Declarative config examples

Many of our procedures provide imperative `oc` commands (which cannot be stored in a Git repo). Due to efforts around improving the experience for GitOps users, we sometimes also want to provide a declarative YAML example that achieves the same configuration. This allows users to store these YAML configurations in a Git repo and follow GitOps practices to configure OpenShift.

[IMPORTANT]
====
When adding declarative examples to procedures, do not completely replace the imperative command with the declarative YAML example. Some users might still prefer the imperative option.
====

To add a declarative YAML example to a procedure step with an existing imperative command, add it in a ""TIP"" admonition by following the template in the example below. This example uses an imperative command (`oc create configmap`) to create a config map, and then provides the declarative YAML example of the `ConfigMap` object afterward.

....
* Define a `ConfigMap` object containing the certificate authority by using the following command:
+
[source,terminal]
----
$ oc create configmap ca-config-map --from-file=ca.crt=/path/to/ca -n openshift-config
----
+
[TIP]
====
You can alternatively apply the following YAML to create the config map:

[source,yaml]
----
apiVersion: v1
kind: ConfigMap
metadata:
  name: ca-config-map
  namespace: openshift-config
type: Opaque
data:
  ca.crt: <base64_encoded_CA_certificate_PEM>
----
====
....

This renders as:

> * Define a `ConfigMap` object containing the certificate authority by using the following command:
> +
> [source,terminal]
> ----
> $ oc create configmap ca-config-map --from-file=ca.crt=/path/to/ca -n openshift-config
> ----
> +
> [TIP]
> ====
> You can alternatively apply the following YAML to create the config map:
>
> [source,yaml]
> ----
> apiVersion: v1
> kind: ConfigMap
> metadata:
>   name: ca-config-map
>   namespace: openshift-config
> type: Opaque
> data:
>   ca.crt: <base64_encoded_CA_certificate_PEM>
> ----
> ====

[NOTE]
====
If you are adding a particularly long YAML block, you can optionally use the xref:collapsible-content[`%collapsible`] feature to allow users to collapse the code block.
====

== Quick markup reference

|===
|Convention |Markup |Example rendered output

|Code blocks

a|
....
Use the following syntax for the `oc` command:

----
$ oc <action> <object_type> <object_name_or_id>
----
....

a|
> Use the following syntax for the `oc` command:
>
> ----
> $ oc <action> <object_type> <object_name_or_id>
> ----

a|Use backticks for all non-GUI ""system items"", including:

* Inline commands, operations, literal values, variables, parameters, settings,
flags, environment variables, user input
* System term/item, user names, unique or example names for individual API
objects/resources (e.g., a pod named `mypod`), daemon, service, or software
package
* RPM packages
* File names or directory paths

a|
....
`oc get`

Set the `upgrade` variable to `true`.

Use the `--amend` flag.

Answer by typing `Yes` or `No` when prompted.

`user_name`

`service_name`

`package_name`

`filename`
....

a|
> Use the `oc get services` command to get a list of services that are currently defined.
>
> &nbsp;
>
> Use the `--amend` flag.
>
> &nbsp;
>
> Set the `upgrade` variable to `true`.
>
> &nbsp;
>
> Answer by typing `Yes` or `No` when prompted.
>
> &nbsp;
>
> `cluster-admin` user
>
> &nbsp;
>
> `firewalld` service
>
> &nbsp;
>
> `rubygems` RPM package
>
> &nbsp;
>
> The `express.conf` configuration file is located in the `/usr/share` directory.

|System or software variable to be replaced by the user
a|
....
`<project>`

`<deployment>`
....

a|
> Use the following command to roll back a Deployment, specifying the Deployment name:
>
> `oc rollback <deployment>`

|Use single asterisks for web console / GUI items (menus, buttons, page titles, etc.).
Use two characters to form the arrow in a series of menu items (`$$->$$`).

a|
....
Choose *Cluster Console* from the list.

Navigate to the *Operators* -> *Catalog Sources* page.

Click *Create Subscription*.
....

a|
> Choose *Cluster Console* from the list.
>
> &nbsp;
>
> Navigate to the *Operators* -> *Catalog Sources* page.
>
> &nbsp;
>
> Click *Create Subscription*.

|Use underscores to emphasize the first appearance of a new term.

a|
....
An _Operator_ is a method of packaging, deploying,
and managing a Kubernetes application.
....

a|
> An _Operator_ is a method of packaging, deploying, and managing a Kubernetes application.

|Use of underscores for general emphasis is allowed but should only be used
very sparingly. Let the writing, instead of font usage, create the emphasis
wherever possible.

a|
....
Do _not_ delete the file.
....

a|
> Do _not_ delete the file.

|Footnotes

|A footnote is created with the footnote macro. If you plan to reference a footnote more than once, use the ID footnoteref macro. The Customer Portal does not support spaces in the footnoteref. For example, ""dynamic PV"" should be ""dynamicPV"".

|See link:http://asciidoctor.org/docs/user-manual/#user-footnotes[Footnotes] for the footnote and footnoteref syntax.

|===
",12059,False,1959.2116644691514,median
"// Copyright (c) 2017-2018, The Masari Project
// Copyright (c) 2014-2018, The Monero Project
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS"" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers


#include ""wallet.h""
#include ""pending_transaction.h""
#include ""unsigned_transaction.h""
#include ""transaction_history.h""
#include ""address_book.h""
#include ""subaddress.h""
#include ""subaddress_account.h""
#include ""common_defines.h""
#include ""common/util.h""

#include ""mnemonics/electrum-words.h""
#include ""mnemonics/english.h""
#include <boost/format.hpp>
#include <sstream>
#include <unordered_map>

#ifdef WIN32
#include <boost/locale.hpp>
#include <boost/filesystem.hpp>
#endif

using namespace std;
using namespace cryptonote;

#undef MONERO_DEFAULT_LOG_CATEGORY
#define MONERO_DEFAULT_LOG_CATEGORY ""WalletAPI""

namespace Monero {

namespace {
    // copy-pasted from simplewallet
    static const int    DEFAULT_REFRESH_INTERVAL_MILLIS = 1000 * 10;
    // limit maximum refresh interval as one minute
    static const int    MAX_REFRESH_INTERVAL_MILLIS = 1000 * 60 * 1;
    // Default refresh interval when connected to remote node
    static const int    DEFAULT_REMOTE_NODE_REFRESH_INTERVAL_MILLIS = 1000 * 10;
    // Connection timeout 30 sec
    static const int    DEFAULT_CONNECTION_TIMEOUT_MILLIS = 1000 * 30;

    std::string get_default_ringdb_path()
    {
      boost::filesystem::path dir = tools::get_default_data_dir();
      // remove .bitmonero, replace with .shared-ringdb
      dir = dir.remove_filename();
      dir /= "".shared-ringdb"";
      return dir.string();
    }
    void checkMultisigWalletReady(const tools::wallet2* wallet) {
        if (!wallet) {
            throw runtime_error(""Wallet is not initialized yet"");
        }

        bool ready;
        if (!wallet->multisig(&ready)) {
            throw runtime_error(""Wallet is not multisig"");
        }

        if (!ready) {
            throw runtime_error(""Multisig wallet is not finalized yet"");
        }
    }

    void checkMultisigWalletNotReady(const tools::wallet2* wallet) {
        if (!wallet) {
            throw runtime_error(""Wallet is not initialized yet"");
        }

        bool ready;
        if (!wallet->multisig(&ready)) {
            throw runtime_error(""Wallet is not multisig"");
        }

        if (ready) {
            throw runtime_error(""Multisig wallet is already finalized"");
        }
    }
}

struct Wallet2CallbackImpl : public tools::i_wallet2_callback
{

    Wallet2CallbackImpl(WalletImpl * wallet)
     : m_listener(nullptr)
     , m_wallet(wallet)
    {

    }

    ~Wallet2CallbackImpl()
    {

    }

    void setListener(WalletListener * listener)
    {
        m_listener = listener;
    }

    WalletListener * getListener() const
    {
        return m_listener;
    }

    virtual void on_new_block(uint64_t height, const cryptonote::block& block)
    {
        // Don't flood the GUI with signals. On fast refresh - send signal every 1000th block
        // get_refresh_from_block_height() returns the blockheight from when the wallet was 
        // created or the restore height specified when wallet was recovered
        if(height >= m_wallet->m_wallet->get_refresh_from_block_height() || height % 1000 == 0) {
            // LOG_PRINT_L3(__FUNCTION__ << "": new block. height: "" << height);
            if (m_listener) {
                m_listener->newBlock(height);
            }
        }
    }

    virtual void on_money_received(uint64_t height, const crypto::hash &txid, const cryptonote::transaction& tx, uint64_t amount, const cryptonote::subaddress_index& subaddr_index)
    {

        std::string tx_hash =  epee::string_tools::pod_to_hex(txid);

        LOG_PRINT_L3(__FUNCTION__ << "": money received. height:  "" << height
                     << "", tx: "" << tx_hash
                     << "", amount: "" << print_money(amount)
                     << "", idx: "" << subaddr_index);
        // do not signal on received tx if wallet is not syncronized completely
        if (m_listener && m_wallet->synchronized()) {
            m_listener->moneyReceived(tx_hash, amount);
            m_listener->updated();
        }
    }

    virtual void on_unconfirmed_money_received(uint64_t height, const crypto::hash &txid, const cryptonote::transaction& tx, uint64_t amount, const cryptonote::subaddress_index& subaddr_index)
    {

        std::string tx_hash =  epee::string_tools::pod_to_hex(txid);

        LOG_PRINT_L3(__FUNCTION__ << "": unconfirmed money received. height:  "" << height
                     << "", tx: "" << tx_hash
                     << "", amount: "" << print_money(amount)
                     << "", idx: "" << subaddr_index);
        // do not signal on received tx if wallet is not syncronized completely
        if (m_listener && m_wallet->synchronized()) {
            m_listener->unconfirmedMoneyReceived(tx_hash, amount);
            m_listener->updated();
        }
    }

    virtual void on_money_spent(uint64_t height, const crypto::hash &txid, const cryptonote::transaction& in_tx,
                                uint64_t amount, const cryptonote::transaction& spend_tx, const cryptonote::subaddress_index& subaddr_index)
    {
        // TODO;
        std::string tx_hash = epee::string_tools::pod_to_hex(txid);
        LOG_PRINT_L3(__FUNCTION__ << "": money spent. height:  "" << height
                     << "", tx: "" << tx_hash
                     << "", amount: "" << print_money(amount)
                     << "", idx: "" << subaddr_index);
        // do not signal on sent tx if wallet is not syncronized completely
        if (m_listener && m_wallet->synchronized()) {
            m_listener->moneySpent(tx_hash, amount);
            m_listener->updated();
        }
    }

    virtual void on_skip_transaction(uint64_t height, const crypto::hash &txid, const cryptonote::transaction& tx)
    {
        // TODO;
    }

    // Light wallet callbacks
    virtual void on_lw_new_block(uint64_t height)
    {
      if (m_listener) {
        m_listener->newBlock(height);
      }
    }

    virtual void on_lw_money_received(uint64_t height, const crypto::hash &txid, uint64_t amount)
    {
      if (m_listener) {
        std::string tx_hash =  epee::string_tools::pod_to_hex(txid);
        m_listener->moneyReceived(tx_hash, amount);
      }
    }

    virtual void on_lw_unconfirmed_money_received(uint64_t height, const crypto::hash &txid, uint64_t amount)
    {
      if (m_listener) {
        std::string tx_hash =  epee::string_tools::pod_to_hex(txid);
        m_listener->unconfirmedMoneyReceived(tx_hash, amount);
      }
    }

    virtual void on_lw_money_spent(uint64_t height, const crypto::hash &txid, uint64_t amount)
    {
      if (m_listener) {
        std::string tx_hash =  epee::string_tools::pod_to_hex(txid);
        m_listener->moneySpent(tx_hash, amount);
      }
    }

    WalletListener * m_listener;
    WalletImpl     * m_wallet;
};

Wallet::~Wallet() {}

WalletListener::~WalletListener() {}


string Wallet::displayAmount(uint64_t amount)
{
    return cryptonote::print_money(amount);
}

uint64_t Wallet::amountFromString(const string &amount)
{
    uint64_t result = 0;
    cryptonote::parse_amount(result, amount);
    return result;
}

uint64_t Wallet::amountFromDouble(double amount)
{
    std::stringstream ss;
    ss << std::fixed << std::setprecision(CRYPTONOTE_DISPLAY_DECIMAL_POINT) << amount;
    return amountFromString(ss.str());
}

std::string Wallet::genPaymentId()
{
    crypto::hash8 payment_id = crypto::rand<crypto::hash8>();
    return epee::string_tools::pod_to_hex(payment_id);

}

bool Wallet::paymentIdValid(const string &paiment_id)
{
    crypto::hash8 pid8;
    if (tools::wallet2::parse_short_payment_id(paiment_id, pid8))
        return true;
    crypto::hash pid;
    if (tools::wallet2::parse_long_payment_id(paiment_id, pid))
        return true;
    return false;
}

bool Wallet::addressValid(const std::string &str, NetworkType nettype)
{
  cryptonote::address_parse_info info;
  return get_account_address_from_str(info, static_cast<cryptonote::network_type>(nettype), str);
}

bool Wallet::keyValid(const std::string &secret_key_string, const std::string &address_string, bool isViewKey, NetworkType nettype, std::string &error)
{
  cryptonote::address_parse_info info;
  if(!get_account_address_from_str(info, static_cast<cryptonote::network_type>(nettype), address_string)) {
      error = tr(""Failed to parse address"");
      return false;
  }
  
  cryptonote::blobdata key_data;
  if(!epee::string_tools::parse_hexstr_to_binbuff(secret_key_string, key_data) || key_data.size() != sizeof(crypto::secret_key))
  {
      error = tr(""Failed to parse key"");
      return false;
  }
  crypto::secret_key key = *reinterpret_cast<const crypto::secret_key*>(key_data.data());

  // check the key match the given address
  crypto::public_key pkey;
  if (!crypto::secret_key_to_public_key(key, pkey)) {
      error = tr(""failed to verify key"");
      return false;
  }
  bool matchAddress = false;
  if(isViewKey)
      matchAddress = info.address.m_view_public_key == pkey;
  else
      matchAddress = info.address.m_spend_public_key == pkey;

  if(!matchAddress) {
      error = tr(""key does not match address"");
      return false;
  }
  
  return true;
}

std::string Wallet::paymentIdFromAddress(const std::string &str, NetworkType nettype)
{
  cryptonote::address_parse_info info;
  if (!get_account_address_from_str(info, static_cast<cryptonote::network_type>(nettype), str))
    return """";
  if (!info.has_payment_id)
    return """";
  return epee::string_tools::pod_to_hex(info.payment_id);
}

uint64_t Wallet::maximumAllowedAmount()
{
    return std::numeric_limits<uint64_t>::max();
}

void Wallet::init(const char *argv0, const char *default_log_base_name, const std::string &log_path, bool console) {
#ifdef WIN32
    // Activate UTF-8 support for Boost filesystem classes on Windows
    std::locale::global(boost::locale::generator().generate(""""));
    boost::filesystem::path::imbue(std::locale());
#endif
    epee::string_tools::set_module_name_and_folder(argv0);
    mlog_configure(log_path.empty() ? mlog_get_default_log_path(default_log_base_name) : log_path.c_str(), console);
}

void Wallet::debug(const std::string &category, const std::string &str) {
    MCDEBUG(category.empty() ? MONERO_DEFAULT_LOG_CATEGORY : category.c_str(), str);
}

void Wallet::info(const std::string &category, const std::string &str) {
    MCINFO(category.empty() ? MONERO_DEFAULT_LOG_CATEGORY : category.c_str(), str);
}

void Wallet::warning(const std::string &category, const std::string &str) {
    MCWARNING(category.empty() ? MONERO_DEFAULT_LOG_CATEGORY : category.c_str(), str);
}

void Wallet::error(const std::string &category, const std::string &str) {
    MCERROR(category.empty() ? MONERO_DEFAULT_LOG_CATEGORY : category.c_str(), str);
}

///////////////////////// WalletImpl implementation ////////////////////////
WalletImpl::WalletImpl(NetworkType nettype)
    :m_wallet(nullptr)
    , m_status(Wallet::Status_Ok)
    , m_trustedDaemon(false)
    , m_wallet2Callback(nullptr)
    , m_recoveringFromSeed(false)
    , m_synchronized(false)
    , m_rebuildWalletCache(false)
    , m_is_connected(false)
{
    m_wallet = new tools::wallet2(static_cast<cryptonote::network_type>(nettype));
    m_history = new TransactionHistoryImpl(this);
    m_wallet2Callback = new Wallet2CallbackImpl(this);
    m_wallet->callback(m_wallet2Callback);
    m_refreshThreadDone = false;
    m_refreshEnabled = false;
    m_addressBook = new AddressBookImpl(this);
    m_subaddress = new SubaddressImpl(this);
    m_subaddressAccount = new SubaddressAccountImpl(this);


    m_refreshIntervalMillis = DEFAULT_REFRESH_INTERVAL_MILLIS;

    m_refreshThread = boost::thread([this] () {
        this->refreshThreadFunc();
    });

}

WalletImpl::~WalletImpl()
{

    LOG_PRINT_L1(__FUNCTION__);
    // Pause refresh thread - prevents refresh from starting again
    pauseRefresh();
    // Close wallet - stores cache and stops ongoing refresh operation 
    close(false); // do not store wallet as part of the closing activities
    // Stop refresh thread
    stopRefresh();
    delete m_wallet2Callback;
    delete m_history;
    delete m_addressBook;
    delete m_subaddress;
    delete m_subaddressAccount;
    delete m_wallet;
    LOG_PRINT_L1(__FUNCTION__ << "" finished"");
}

bool WalletImpl::create(const std::string &path, const std::string &password, const std::string &language)
{

    clearStatus();
    m_recoveringFromSeed = false;
    bool keys_file_exists;
    bool wallet_file_exists;
    tools::wallet2::wallet_exists(path, keys_file_exists, wallet_file_exists);
    LOG_PRINT_L3(""wallet_path: "" << path << """");
    LOG_PRINT_L3(""keys_file_exists: "" << std::boolalpha << keys_file_exists << std::noboolalpha
                 << ""  wallet_file_exists: "" << std::boolalpha << wallet_file_exists << std::noboolalpha);


    // add logic to error out if new wallet requested but named wallet file exists
    if (keys_file_exists || wallet_file_exists) {
        std::string error = ""attempting to generate or restore wallet, but specified file(s) exist.  Exiting to not risk overwriting."";
        LOG_ERROR(error);
        setStatusCritical(error);
        return false;
    }
    // TODO: validate language
    m_wallet->set_seed_language(language);
    crypto::secret_key recovery_val, secret_key;
    try {
        recovery_val = m_wallet->generate(path, password, secret_key, false, false);
        m_password = password;
        clearStatus();
    } catch (const std::exception &e) {
        LOG_ERROR(""Error creating wallet: "" << e.what());
        setStatusCritical(e.what());
        return false;
    }

    return true;
}

bool WalletImpl::createWatchOnly(const std::string &path, const std::string &password, const std::string &language) const
{
    clearStatus();
    std::unique_ptr<tools::wallet2> view_wallet(new tools::wallet2(m_wallet->nettype()));

    // Store same refresh height as original wallet
    view_wallet->set_refresh_from_block_height(m_wallet->get_refresh_from_block_height());

    bool keys_file_exists;
    bool wallet_file_exists;
    tools::wallet2::wallet_exists(path, keys_file_exists, wallet_file_exists);
    LOG_PRINT_L3(""wallet_path: "" << path << """");
    LOG_PRINT_L3(""keys_file_exists: "" << std::boolalpha << keys_file_exists << std::noboolalpha
                 << ""  wallet_file_exists: "" << std::boolalpha << wallet_file_exists << std::noboolalpha);

    // add logic to error out if new wallet requested but named wallet file exists
    if (keys_file_exists || wallet_file_exists) {
        std::string error = ""attempting to generate view only wallet, but specified file(s) exist.  Exiting to not risk overwriting."";
        LOG_ERROR(error);
        setStatusError(error);
        return false;
    }
    // TODO: validate language
    view_wallet->set_seed_language(language);

    const crypto::secret_key viewkey = m_wallet->get_account().get_keys().m_view_secret_key;
    const cryptonote::account_public_address address = m_wallet->get_account().get_keys().m_account_address;

    try {
        // Generate view only wallet
        view_wallet->generate(path, password, address, viewkey);

        // Export/Import outputs
        auto outputs = m_wallet->export_outputs();
        view_wallet->import_outputs(outputs);

        // Copy scanned blockchain
        auto bc = m_wallet->export_blockchain();
        view_wallet->import_blockchain(bc);

        // copy payments
        auto payments = m_wallet->export_payments();
        view_wallet->import_payments(payments);

        // copy confirmed outgoing payments
        std::list<std::pair<crypto::hash, tools::wallet2::confirmed_transfer_details>> out_payments;
        m_wallet->get_payments_out(out_payments, 0);
        view_wallet->import_payments_out(out_payments);

        // Export/Import key images
        // We already know the spent status from the outputs we exported, thus no need to check them again
        auto key_images = m_wallet->export_key_images();
        uint64_t spent = 0;
        uint64_t unspent = 0;
        view_wallet->import_key_images(key_images,spent,unspent,false);
        clearStatus();
    } catch (const std::exception &e) {
        LOG_ERROR(""Error creating view only wallet: "" << e.what());
        setStatusError(e.what());
        return false;
    }
    // Store wallet
    view_wallet->store();
    return true;
}

bool WalletImpl::recoverFromKeys(const std::string &path,
                                const std::string &language,
                                const std::string &address_string,
                                const std::string &viewkey_string,
                                const std::string &spendkey_string)
{
    return recoverFromKeysWithPassword(path, """", language, address_string, viewkey_string, spendkey_string);
}

bool WalletImpl::recoverFromKeysWithPassword(const std::string &path,
                                 const std::string &password,
                                 const std::string &language,
                                 const std::string &address_string,
                                 const std::string &viewkey_string,
                                 const std::string &spendkey_string)
{
    cryptonote::address_parse_info info;
    if(!get_account_address_from_str(info, m_wallet->nettype(), address_string))
    {
        setStatusError(tr(""failed to parse address""));
        return false;
    }

    // parse optional spend key
    crypto::secret_key spendkey;
    bool has_spendkey = false;
    cryptonote::blobdata spendkey_data;
    if (!spendkey_string.empty()) {
        if(!epee::string_tools::parse_hexstr_to_binbuff(spendkey_string, spendkey_data) || spendkey_data.size() != sizeof(crypto::secret_key))
        {
            setStatusError(tr(""failed to parse secret spend key""));
            return false;
        }
        has_spendkey = true;
        spendkey = *reinterpret_cast<const crypto::secret_key*>(spendkey_data.data());
    }

    // parse view secret key
    crypto::secret_key viewkey;
    if (viewkey_string.empty()) {
        if(has_spendkey)
        {
          // generate deterministic view key if it was not supplied
          crypto::ec_scalar scalar;
          crypto::hash_to_scalar(spendkey_data.data(), sizeof(crypto::secret_key), scalar);
          viewkey = reinterpret_cast<crypto::secret_key &>(scalar);
        }
        else {
        setStatusError(tr(""No view key supplied, cancelled""));
          return false;
        }
    }
    else
    {
      cryptonote::blobdata viewkey_data;
      if(!epee::string_tools::parse_hexstr_to_binbuff(viewkey_string, viewkey_data) || viewkey_data.size() != sizeof(crypto::secret_key))
      {
        setStatusError(tr(""failed to parse secret view key""));
          return false;
      }
      viewkey = *reinterpret_cast<const crypto::secret_key*>(viewkey_data.data());
    }
    
    // check the spend and view keys match the given address
    crypto::public_key pkey;
    if(has_spendkey) {
        if (!crypto::secret_key_to_public_key(spendkey, pkey)) {
            setStatusError(tr(""failed to verify secret spend key""));
            return false;
        }
        if (info.address.m_spend_public_key != pkey) {
            setStatusError(tr(""spend key does not match address""));
            return false;
        }
    }
    if (!crypto::secret_key_to_public_key(viewkey, pkey)) {
        setStatusError(tr(""failed to verify secret view key""));
        return false;
    }
    if (info.address.m_view_public_key != pkey) {
        setStatusError(tr(""view key does not match address""));
        return false;
    }

    try
    {
        if (has_spendkey) {
            m_wallet->generate(path, password, info.address, spendkey, viewkey);
            setSeedLanguage(language);
            LOG_PRINT_L1(""Generated new wallet from keys with seed language: "" + language);
        }
        else {
            m_wallet->generate(path, password, info.address, viewkey);
            LOG_PRINT_L1(""Generated new view only wallet from keys"");
        }
        
    }
    catch (const std::exception& e) {
        setStatusError(string(tr(""failed to generate new wallet: "")) + e.what());
        return false;
    }
    return true;
}


bool WalletImpl::open(const std::string &path, const std::string &password)
{
    clearStatus();
    m_recoveringFromSeed = false;
    try {
        // TODO: handle ""deprecated""
        // Check if wallet cache exists
        bool keys_file_exists;
        bool wallet_file_exists;
        tools::wallet2::wallet_exists(path, keys_file_exists, wallet_file_exists);
        if(!wallet_file_exists){
            // Rebuilding wallet cache, using refresh height from .keys file
            m_rebuildWalletCache = true;
        }
        m_wallet->set_ring_database(get_default_ringdb_path());
        m_wallet->load(path, password);

        m_password = password;
    } catch (const std::exception &e) {
        LOG_ERROR(""Error opening wallet: "" << e.what());
        setStatusCritical(e.what());
    }
    return status() == Status_Ok;
}

bool WalletImpl::recover(const std::string &path, const std::string &seed)
{
    return recover(path, """", seed);
}

bool WalletImpl::recover(const std::string &path, const std::string &password, const std::string &seed)
{
    clearStatus();
    m_errorString.clear();
    if (seed.empty()) {
        LOG_ERROR(""Electrum seed is empty"");
        setStatusError(tr(""Electrum seed is empty""));
        return false;
    }

    m_recoveringFromSeed = true;
    crypto::secret_key recovery_key;
    std::string old_language;
    if (!crypto::ElectrumWords::words_to_bytes(seed, recovery_key, old_language)) {
        setStatusError(tr(""Electrum-style word list failed verification""));
        return false;
    }

    if (old_language == crypto::ElectrumWords::old_language_name)
        old_language = Language::English().get_language_name();

    try {
        m_wallet->set_seed_language(old_language);
        m_wallet->generate(path, password, recovery_key, true, false);

    } catch (const std::exception &e) {
        setStatusCritical(e.what());
    }
    return status() == Status_Ok;
}

bool WalletImpl::close(bool store)
{

    bool result = false;
    LOG_PRINT_L1(""closing wallet..."");
    try {
        if (store) {
            // Do not store wallet with invalid status
            // Status Critical refers to errors on opening or creating wallets.
            if (status() != Status_Critical)
                m_wallet->store();
            else
                LOG_ERROR(""Status_Critical - not saving wallet"");
            LOG_PRINT_L1(""wallet::store done"");
        }
        LOG_PRINT_L1(""Calling wallet::stop..."");
        m_wallet->stop();
        LOG_PRINT_L1(""wallet::stop done"");
        result = true;
        clearStatus();
    } catch (const std::exception &e) {
        setStatusCritical(e.what());
        LOG_ERROR(""Error closing wallet: "" << e.what());
    }
    return result;
}

std::string WalletImpl::seed() const
{
    std::string seed;
    if (m_wallet)
        m_wallet->get_seed(seed);
    return seed;
}

std::string WalletImpl::getSeedLanguage() const
{
    return m_wallet->get_seed_language();
}

void WalletImpl::setSeedLanguage(const std::string &arg)
{
    m_wallet->set_seed_language(arg);
}

int WalletImpl::status() const
{
    boost::lock_guard<boost::mutex> l(m_statusMutex);
    return m_status;
}

bool WalletImpl::isMultisig() const
{
  bool ready;
  if(!m_wallet->multisig(&ready))
    return false;
  else if(!ready)
    return false;
  else
    return true;
}

std::string WalletImpl::errorString() const
{
    boost::lock_guard<boost::mutex> l(m_statusMutex);
    return m_errorString;
}

void WalletImpl::statusWithErrorString(int& status, std::string& errorString) const {
    boost::lock_guard<boost::mutex> l(m_statusMutex);
    status = m_status;
    errorString = m_errorString;
}

bool WalletImpl::setPassword(const std::string &password)
{
    clearStatus();
    try {
        m_wallet->rewrite(m_wallet->get_wallet_file(), password);
        m_password = password;
    } catch (const std::exception &e) {
        setStatusError(e.what());
    }
    return status() == Status_Ok;
}

std::string WalletImpl::address(uint32_t accountIndex, uint32_t addressIndex) const
{
    return m_wallet->get_subaddress_as_str({accountIndex, addressIndex});
}

std::string WalletImpl::integratedAddress(const std::string &payment_id) const
{
    crypto::hash8 pid;
    if (!tools::wallet2::parse_short_payment_id(payment_id, pid)) {
        return """";
    }
    return m_wallet->get_integrated_address_as_str(pid);
}

std::string WalletImpl::secretViewKey() const
{
    return epee::string_tools::pod_to_hex(m_wallet->get_account().get_keys().m_view_secret_key);
}

std::string WalletImpl::publicViewKey() const
{
    return epee::string_tools::pod_to_hex(m_wallet->get_account().get_keys().m_account_address.m_view_public_key);
}

std::string WalletImpl::secretSpendKey() const
{
    return epee::string_tools::pod_to_hex(m_wallet->get_account().get_keys().m_spend_secret_key);
}

std::string WalletImpl::publicSpendKey() const
{
    return epee::string_tools::pod_to_hex(m_wallet->get_account().get_keys().m_account_address.m_spend_public_key);
}

std::string WalletImpl::publicMultisigSignerKey() const
{
    try {
        crypto::public_key signer = m_wallet->get_multisig_signer_public_key();
        return epee::string_tools::pod_to_hex(signer);
    } catch (const std::exception&) {
        return """";
    }
}

std::string WalletImpl::path() const
{
    return m_wallet->path();
}

bool WalletImpl::store(const std::string &path)
{
    clearStatus();
    try {
        if (path.empty()) {
            m_wallet->store();
        } else {
            m_wallet->store_to(path, m_password);
        }
    } catch (const std::exception &e) {
        LOG_ERROR(""Error saving wallet: "" << e.what());
        setStatusError(e.what());
        return false;
    }

    return true;
}

string WalletImpl::filename() const
{
    return m_wallet->get_wallet_file();
}

string WalletImpl::keysFilename() const
{
    return m_wallet->get_keys_file();
}

bool WalletImpl::init(const std::string &daemon_address, uint64_t upper_transaction_size_limit, const std::string &daemon_username, const std::string &daemon_password, bool use_ssl, bool lightWallet)
{
    clearStatus();
    m_wallet->set_light_wallet(lightWallet);
    if(daemon_username != """")
        m_daemon_login.emplace(daemon_username, daemon_password);
    return doInit(daemon_address, upper_transaction_size_limit, use_ssl);
}

bool WalletImpl::lightWalletLogin(bool &isNewWallet) const
{
  return m_wallet->light_wallet_login(isNewWallet);
}

bool WalletImpl::lightWalletImportWalletRequest(std::string &payment_id, uint64_t &fee, bool &new_request, bool &request_fulfilled, std::string &payment_address, std::string &status)
{
  try
  {
    cryptonote::COMMAND_RPC_IMPORT_WALLET_REQUEST::response response;
    if(!m_wallet->light_wallet_import_wallet_request(response)){
      setStatusError(tr(""Failed to send import wallet request""));
      return false;
    }
    fee = response.import_fee;
    payment_id = response.payment_id;
    new_request = response.new_request;
    request_fulfilled = response.request_fulfilled;
    payment_address = response.payment_address;
    status = response.status;
  }
  catch (const std::exception &e)
  {
    LOG_ERROR(""Error sending import wallet request: "" << e.what());
    setStatusError(e.what());
    return false;
  }
  return true;
}

void WalletImpl::setRefreshFromBlockHeight(uint64_t refresh_from_block_height)
{
    m_wallet->set_refresh_from_block_height(refresh_from_block_height);
}

void WalletImpl::setRecoveringFromSeed(bool recoveringFromSeed)
{
    m_recoveringFromSeed = recoveringFromSeed;
}

uint64_t WalletImpl::balance(uint32_t accountIndex) const
{
    return m_wallet->balance(accountIndex);
}

uint64_t WalletImpl::unlockedBalance(uint32_t accountIndex) const
{
    return m_wallet->unlocked_balance(accountIndex);
}

uint64_t WalletImpl::blockChainHeight() const
{
    if(m_wallet->light_wallet()) {
        return m_wallet->get_light_wallet_scanned_block_height();
    }
    return m_wallet->get_blockchain_current_height();
}
uint64_t WalletImpl::approximateBlockChainHeight() const
{
    return m_wallet->get_approximate_blockchain_height();
}
uint64_t WalletImpl::daemonBlockChainHeight() const
{
    if(m_wallet->light_wallet()) {
        return m_wallet->get_light_wallet_scanned_block_height();
    }
    if (!m_is_connected)
        return 0;
    std::string err;
    uint64_t result = m_wallet->get_daemon_blockchain_height(err);
    if (!err.empty()) {
        LOG_ERROR(__FUNCTION__ << "": "" << err);
        result = 0;
        setStatusError(err);

    } else {
        clearStatus();
    }
    return result;
}

uint64_t WalletImpl::daemonBlockChainTargetHeight() const
{
    if(m_wallet->light_wallet()) {
        return m_wallet->get_light_wallet_blockchain_height();
    }
    if (!m_is_connected)
        return 0;
    std::string err;
    uint64_t result = m_wallet->get_daemon_blockchain_target_height(err);
    if (!err.empty()) {
        LOG_ERROR(__FUNCTION__ << "": "" << err);
        result = 0;
        setStatusError(err);

    } else {
        clearStatus();
    }
    // Target height can be 0 when daemon is synced. Use blockchain height instead. 
    if(result == 0)
        result = daemonBlockChainHeight();
    return result;
}

bool WalletImpl::daemonSynced() const
{   
    if(connected() == Wallet::ConnectionStatus_Disconnected)
        return false;
    uint64_t blockChainHeight = daemonBlockChainHeight();
    return (blockChainHeight >= daemonBlockChainTargetHeight() && blockChainHeight > 1);
}

bool WalletImpl::synchronized() const
{
    return m_synchronized;
}

bool WalletImpl::refresh()
{
    clearStatus();
    //TODO: make doRefresh return bool to know whether the error occured during refresh or not
    //otherwise one may try, say, to send transaction, transfer fails and this method returns false
    doRefresh();
    return status() == Status_Ok;
}

void WalletImpl::refreshAsync()
{
    LOG_PRINT_L3(__FUNCTION__ << "": Refreshing asynchronously.."");
    clearStatus();
    m_refreshCV.notify_one();
}

void WalletImpl::setAutoRefreshInterval(int millis)
{
    if (millis > MAX_REFRESH_INTERVAL_MILLIS) {
        LOG_ERROR(__FUNCTION__<< "": invalid refresh interval "" << millis
                  << "" ms, maximum allowed is "" << MAX_REFRESH_INTERVAL_MILLIS << "" ms"");
        m_refreshIntervalMillis = MAX_REFRESH_INTERVAL_MILLIS;
    } else {
        m_refreshIntervalMillis = millis;
    }
}

int WalletImpl::autoRefreshInterval() const
{
    return m_refreshIntervalMillis;
}

UnsignedTransaction *WalletImpl::loadUnsignedTx(const std::string &unsigned_filename) {
  clearStatus();
  UnsignedTransactionImpl * transaction = new UnsignedTransactionImpl(*this);
  if (!m_wallet->load_unsigned_tx(unsigned_filename, transaction->m_unsigned_tx_set)){
    setStatusError(tr(""Failed to load unsigned transactions""));
  }
  
  // Check tx data and construct confirmation message
  std::string extra_message;
  if (!transaction->m_unsigned_tx_set.transfers.empty())
    extra_message = (boost::format(""%u outputs to import. "") % (unsigned)transaction->m_unsigned_tx_set.transfers.size()).str();
  transaction->checkLoadedTx([&transaction](){return transaction->m_unsigned_tx_set.txes.size();}, [&transaction](size_t n)->const tools::wallet2::tx_construction_data&{return transaction->m_unsigned_tx_set.txes[n];}, extra_message);
  setStatus(transaction->status(), transaction->errorString());
    
  return transaction;
}

bool WalletImpl::submitTransaction(const string &fileName) {
  clearStatus();
  std::unique_ptr<PendingTransactionImpl> transaction(new PendingTransactionImpl(*this));

  bool r = m_wallet->load_tx(fileName, transaction->m_pending_tx);
  if (!r) {
    setStatus(Status_Ok, tr(""Failed to load transaction from file""));
    return false;
  }
  
  if(!transaction->commit()) {
    setStatusError(transaction->m_errorString);
    return false;
  }

  return true;
}

bool WalletImpl::exportKeyImages(const string &filename) 
{
  if (m_wallet->watch_only())
  {
    setStatusError(tr(""Wallet is view only""));
    return false;
  }
  
  try
  {
    if (!m_wallet->export_key_images(filename))
    {
      setStatusError(tr(""failed to save file "") + filename);
      return false;
    }
  }
  catch (const std::exception &e)
  {
    LOG_ERROR(""Error exporting key images: "" << e.what());
    setStatusError(e.what());
    return false;
  }
  return true;
}

bool WalletImpl::importKeyImages(const string &filename)
{
  if (!trustedDaemon()) {
    setStatusError(tr(""Key images can only be imported with a trusted daemon""));
    return false;
  }
  try
  {
    uint64_t spent = 0, unspent = 0;
    uint64_t height = m_wallet->import_key_images(filename, spent, unspent);
    LOG_PRINT_L2(""Signed key images imported to height "" << height << "", ""
        << print_money(spent) << "" spent, "" << print_money(unspent) << "" unspent"");
  }
  catch (const std::exception &e)
  {
    LOG_ERROR(""Error exporting key images: "" << e.what());
    setStatusError(string(tr(""Failed to import key images: "")) + e.what());
    return false;
  }

  return true;
}

void WalletImpl::addSubaddressAccount(const std::string& label)
{
    m_wallet->add_subaddress_account(label);
}
size_t WalletImpl::numSubaddressAccounts() const
{
    return m_wallet->get_num_subaddress_accounts();
}
size_t WalletImpl::numSubaddresses(uint32_t accountIndex) const
{
    return m_wallet->get_num_subaddresses(accountIndex);
}
void WalletImpl::addSubaddress(uint32_t accountIndex, const std::string& label)
{
    m_wallet->add_subaddress(accountIndex, label);
}
std::string WalletImpl::getSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex) const
{
    try
    {
        return m_wallet->get_subaddress_label({accountIndex, addressIndex});
    }
    catch (const std::exception &e)
    {
        LOG_ERROR(""Error getting subaddress label: "") << e.what();
        setStatusError(string(tr(""Failed to get subaddress label: "")) + e.what());
        return """";
    }
}
void WalletImpl::setSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label)
{
    try
    {
        return m_wallet->set_subaddress_label({accountIndex, addressIndex}, label);
    }
    catch (const std::exception &e)
    {
        LOG_ERROR(""Error setting subaddress label: "") << e.what();
        setStatusError(string(tr(""Failed to set subaddress label: "")) + e.what());
    }
}

MultisigState WalletImpl::multisig() const {
    MultisigState state;
    state.isMultisig = m_wallet->multisig(&state.isReady, &state.threshold, &state.total);

    return state;
}

string WalletImpl::getMultisigInfo() const {
    try {
        clearStatus();
        return m_wallet->get_multisig_info();
    } catch (const exception& e) {
        LOG_ERROR(""Error on generating multisig info: "") << e.what();
        setStatusError(string(tr(""Failed to get multisig info: "")) + e.what());
    }

    return string();
}

string WalletImpl::makeMultisig(const vector<string>& info, uint32_t threshold) {
    try {
        clearStatus();

        if (m_wallet->multisig()) {
            throw runtime_error(""Wallet is already multisig"");
        }

        return m_wallet->make_multisig(epee::wipeable_string(m_password), info, threshold);
    } catch (const exception& e) {
        LOG_ERROR(""Error on making multisig wallet: "") << e.what();
        setStatusError(string(tr(""Failed to make multisig: "")) + e.what());
    }

    return string();
}

bool WalletImpl::finalizeMultisig(const vector<string>& extraMultisigInfo) {
    try {
        clearStatus();
        checkMultisigWalletNotReady(m_wallet);

        if (m_wallet->finalize_multisig(epee::wipeable_string(m_password), extraMultisigInfo)) {
            return true;
        }

        setStatusError(tr(""Failed to finalize multisig wallet creation""));
    } catch (const exception& e) {
        LOG_ERROR(""Error on finalizing multisig wallet creation: "") << e.what();
        setStatusError(string(tr(""Failed to finalize multisig wallet creation: "")) + e.what());
    }

    return false;
}

bool WalletImpl::exportMultisigImages(string& images) {
    try {
        clearStatus();
        checkMultisigWalletReady(m_wallet);

        auto blob = m_wallet->export_multisig();
        images = epee::string_tools::buff_to_hex_nodelimer(blob);
        return true;
    } catch (const exception& e) {
        LOG_ERROR(""Error on exporting multisig images: "") << e.what();
        setStatusError(string(tr(""Failed to export multisig images: "")) + e.what());
    }

    return false;
}

size_t WalletImpl::importMultisigImages(const vector<string>& images) {
    try {
        clearStatus();
        checkMultisigWalletReady(m_wallet);

        std::vector<std::string> blobs;
        blobs.reserve(images.size());

        for (const auto& image: images) {
            std::string blob;
            if (!epee::string_tools::parse_hexstr_to_binbuff(image, blob)) {
                LOG_ERROR(""Failed to parse imported multisig images"");
                setStatusError(tr(""Failed to parse imported multisig images""));
                return 0;
            }

            blobs.emplace_back(std::move(blob));
        }

        return m_wallet->import_multisig(blobs);
    } catch (const exception& e) {
        LOG_ERROR(""Error on importing multisig images: "") << e.what();
        setStatusError(string(tr(""Failed to import multisig images: "")) + e.what());
    }

    return 0;
}

PendingTransaction* WalletImpl::restoreMultisigTransaction(const string& signData) {
    try {
        clearStatus();
        checkMultisigWalletReady(m_wallet);

        string binary;
        if (!epee::string_tools::parse_hexstr_to_binbuff(signData, binary)) {
            throw runtime_error(""Failed to deserialize multisig transaction"");
        }

        tools::wallet2::multisig_tx_set txSet;
        if (!m_wallet->load_multisig_tx(binary, txSet, {})) {
          throw runtime_error(""couldn't parse multisig transaction data"");
        }

        auto ptx = new PendingTransactionImpl(*this);
        ptx->m_pending_tx = txSet.m_ptx;
        ptx->m_signers = txSet.m_signers;

        return ptx;
    } catch (exception& e) {
        LOG_ERROR(""Error on restoring multisig transaction: "") << e.what();
        setStatusError(string(tr(""Failed to restore multisig transaction: "")) + e.what());
    }

    return nullptr;
}

// TODO:
// 1 - properly handle payment id (add another menthod with explicit 'payment_id' param)
// 2 - check / design how ""Transaction"" can be single interface
// (instead of few different data structures within wallet2 implementation:
//    - pending_tx;
//    - transfer_details;
//    - payment_details;
//    - unconfirmed_transfer_details;
//    - confirmed_transfer_details)

PendingTransaction *WalletImpl::createTransaction(const string &dst_addr, const string &payment_id, optional<uint64_t> amount, uint32_t mixin_count,
                                                  PendingTransaction::Priority priority, uint32_t subaddr_account, std::set<uint32_t> subaddr_indices)

{
    clearStatus();
    // Pause refresh thread while creating transaction
    pauseRefresh();
      
    cryptonote::address_parse_info info;

    // indicates if dst_addr is integrated address (address + payment_id)
    // TODO:  (https://bitcointalk.org/index.php?topic=753252.msg9985441#msg9985441)
    size_t fake_outs_count = mixin_count > 0 ? mixin_count : m_wallet->default_mixin();
    if (fake_outs_count == 0)
        fake_outs_count = DEFAULT_MIXIN;

    uint32_t adjusted_priority = m_wallet->adjust_priority(static_cast<uint32_t>(priority));

    PendingTransactionImpl * transaction = new PendingTransactionImpl(*this);

    do {
        if(!cryptonote::get_account_address_from_str(info, m_wallet->nettype(), dst_addr)) {
            // TODO: copy-paste 'if treating as an address fails, try as url' from simplewallet.cpp:1982
            setStatusError(tr(""Invalid destination address""));
            break;
        }


        std::vector<uint8_t> extra;
        // if dst_addr is not an integrated address, parse payment_id
        if (!info.has_payment_id && !payment_id.empty()) {
            // copy-pasted from simplewallet.cpp:2212
            crypto::hash payment_id_long;
            bool r = tools::wallet2::parse_long_payment_id(payment_id, payment_id_long);
            if (r) {
                std::string extra_nonce;
                cryptonote::set_payment_id_to_tx_extra_nonce(extra_nonce, payment_id_long);
                r = add_extra_nonce_to_tx_extra(extra, extra_nonce);
            } else {
                r = tools::wallet2::parse_short_payment_id(payment_id, info.payment_id);
                if (r) {
                    std::string extra_nonce;
                    set_encrypted_payment_id_to_tx_extra_nonce(extra_nonce, info.payment_id);
                    r = add_extra_nonce_to_tx_extra(extra, extra_nonce);
                }
            }

            if (!r) {
                setStatusError(tr(""payment id has invalid format, expected 16 or 64 character hex string: "") + payment_id);
                break;
            }
        }
        else if (info.has_payment_id) {
            std::string extra_nonce;
            set_encrypted_payment_id_to_tx_extra_nonce(extra_nonce, info.payment_id);
            bool r = add_extra_nonce_to_tx_extra(extra, extra_nonce);
            if (!r) {
                setStatusError(tr(""Failed to add short payment id: "") + epee::string_tools::pod_to_hex(info.payment_id));
                break;
            }
        }


        //std::vector<tools::wallet2::pending_tx> ptx_vector;

        try {
            if (amount) {
                vector<cryptonote::tx_destination_entry> dsts;
                cryptonote::tx_destination_entry de;
                de.addr = info.address;
                de.amount = *amount;
                de.is_subaddress = info.is_subaddress;
                dsts.push_back(de);
                transaction->m_pending_tx = m_wallet->create_transactions_2(dsts, fake_outs_count, 0 /* unlock_time */,
                                                                          adjusted_priority,
                                                                          extra, subaddr_account, subaddr_indices, m_trustedDaemon);
            } else {
                // for the GUI, sweep_all (i.e. amount set as ""(all)"") will always sweep all the funds in all the addresses
                if (subaddr_indices.empty())
                {
                    for (uint32_t index = 0; index < m_wallet->get_num_subaddresses(subaddr_account); ++index)
                        subaddr_indices.insert(index);
                }
                transaction->m_pending_tx = m_wallet->create_transactions_all(0, info.address, info.is_subaddress, fake_outs_count, 0 /* unlock_time */,
                                                                          adjusted_priority,
                                                                          extra, subaddr_account, subaddr_indices, m_trustedDaemon);
            }

            if (multisig().isMultisig) {
                transaction->m_signers = m_wallet->make_multisig_tx_set(transaction->m_pending_tx).m_signers;
            }
			
        } catch (const tools::error::daemon_busy&) {
            // TODO: make it translatable with ""tr""?
            setStatusError(tr(""daemon is busy. Please try again later.""));
        } catch (const tools::error::no_connection_to_daemon&) {
            setStatusError(tr(""no connection to daemon. Please make sure daemon is running.""));;
        } catch (const tools::error::wallet_rpc_error& e) {
            setStatusError(tr(""RPC error: "") +  e.to_string());
        } catch (const tools::error::get_random_outs_error &e) {
            setStatusError((boost::format(tr(""failed to get random outputs to mix: %s"")) % e.what()).str());
        } catch (const tools::error::not_enough_unlocked_money& e) {
            std::ostringstream writer;

            writer << boost::format(tr(""not enough money to transfer, available only %s, sent amount %s"")) %
                      print_money(e.available()) %
                      print_money(e.tx_amount());
            setStatusError(writer.str());
        } catch (const tools::error::not_enough_money& e) {
            setStatusError("""");
            std::ostringstream writer;

            writer << boost::format(tr(""not enough money to transfer, overall balance only %s, sent amount %s"")) %
                      print_money(e.available()) %
                      print_money(e.tx_amount());
            setStatusError(writer.str());
        } catch (const tools::error::tx_not_possible& e) {
            setStatusError("""");
            std::ostringstream writer;

            writer << boost::format(tr(""not enough money to transfer, available only %s, transaction amount %s = %s + %s (fee)"")) %
                      print_money(e.available()) %
                      print_money(e.tx_amount() + e.fee())  %
                      print_money(e.tx_amount()) %
                      print_money(e.fee());
            setStatusError(writer.str());

        } catch (const tools::error::not_enough_outs_to_mix& e) {
            std::ostringstream writer;
            writer << tr(""not enough outputs for specified ring size"") << "" = "" << (e.mixin_count() + 1) << "":"";
            for (const std::pair<uint64_t, uint64_t> outs_for_amount : e.scanty_outs()) {
                writer << ""\\n"" << tr(""output amount"") << "" = "" << print_money(outs_for_amount.first) << "", "" << tr(""found outputs to use"") << "" = "" << outs_for_amount.second;
            }
            writer << ""\\n"" << tr(""Please sweep unmixable outputs."");
            setStatusError(writer.str());
        } catch (const tools::error::tx_not_constructed&) {
            setStatusError(tr(""transaction was not constructed""));
        } catch (const tools::error::tx_rejected& e) {
            std::ostringstream writer;
            writer << (boost::format(tr(""transaction %s was rejected by daemon with status: "")) % get_transaction_hash(e.tx())) <<  e.status();
            setStatusError(writer.str());
        } catch (const tools::error::tx_sum_overflow& e) {
            setStatusError(e.what());
        } catch (const tools::error::zero_destination&) {
            setStatusError(tr(""one of destinations is zero""));
        } catch (const tools::error::tx_too_big& e) {
            setStatusError(tr(""failed to find a suitable way to split transactions""));
        } catch (const tools::error::transfer_error& e) {
            setStatusError(string(tr(""unknown transfer error: "")) + e.what());
        } catch (const tools::error::wallet_internal_error& e) {
            setStatusError(string(tr(""internal error: "")) + e.what());
        } catch (const std::exception& e) {
            setStatusError(string(tr(""unexpected error: "")) + e.what());
        } catch (...) {
            setStatusError(tr(""unknown error""));
        }
    } while (false);

    statusWithErrorString(transaction->m_status, transaction->m_errorString);
    // Resume refresh thread
    startRefresh();
    return transaction;
}

void WalletImpl::disposeTransaction(PendingTransaction *t)
{
    delete t;
}

TransactionHistory *WalletImpl::history()
{
    return m_history;
}

AddressBook *WalletImpl::addressBook()
{
    return m_addressBook;
}

Subaddress *WalletImpl::subaddress()
{
    return m_subaddress;
}

SubaddressAccount *WalletImpl::subaddressAccount()
{
    return m_subaddressAccount;
}

void WalletImpl::setListener(WalletListener *l)
{
    // TODO thread synchronization;
    m_wallet2Callback->setListener(l);
}

uint32_t WalletImpl::defaultMixin() const
{
    return m_wallet->default_mixin();
}

void WalletImpl::setDefaultMixin(uint32_t arg)
{
    m_wallet->default_mixin(arg);
}

bool WalletImpl::setUserNote(const std::string &txid, const std::string &note)
{
    cryptonote::blobdata txid_data;
    if(!epee::string_tools::parse_hexstr_to_binbuff(txid, txid_data) || txid_data.size() != sizeof(crypto::hash))
      return false;
    const crypto::hash htxid = *reinterpret_cast<const crypto::hash*>(txid_data.data());

    m_wallet->set_tx_note(htxid, note);
    return true;
}

std::string WalletImpl::getUserNote(const std::string &txid) const
{
    cryptonote::blobdata txid_data;
    if(!epee::string_tools::parse_hexstr_to_binbuff(txid, txid_data) || txid_data.size() != sizeof(crypto::hash))
      return """";
    const crypto::hash htxid = *reinterpret_cast<const crypto::hash*>(txid_data.data());

    return m_wallet->get_tx_note(htxid);
}

std::string WalletImpl::getTxKey(const std::string &txid_str) const
{
    crypto::hash txid;
    if(!epee::string_tools::hex_to_pod(txid_str, txid))
    {
        setStatusError(tr(""Failed to parse txid""));
        return """";
    }

    crypto::secret_key tx_key;
    std::vector<crypto::secret_key> additional_tx_keys;
    if (m_wallet->get_tx_key(txid, tx_key, additional_tx_keys))
    {
        clearStatus();
        std::ostringstream oss;
        oss << epee::string_tools::pod_to_hex(tx_key);
        for (size_t i = 0; i < additional_tx_keys.size(); ++i)
            oss << epee::string_tools::pod_to_hex(additional_tx_keys[i]);
        return oss.str();
    }
    else
    {
        setStatusError(tr(""no tx keys found for this txid""));
        return """";
    }
}

bool WalletImpl::checkTxKey(const std::string &txid_str, std::string tx_key_str, const std::string &address_str, uint64_t &received, bool &in_pool, uint64_t &confirmations)
{
    crypto::hash txid;
    if (!epee::string_tools::hex_to_pod(txid_str, txid))
    {
setStatusError(tr(""Failed to parse txid""));
        return false;
    }

    crypto::secret_key tx_key;
    std::vector<crypto::secret_key> additional_tx_keys;
    if (!epee::string_tools::hex_to_pod(tx_key_str.substr(0, 64), tx_key))
    {
        setStatusError(tr(""Failed to parse tx key""));
        return false;
    }
    tx_key_str = tx_key_str.substr(64);
    while (!tx_key_str.empty())
    {
        additional_tx_keys.resize(additional_tx_keys.size() + 1);
        if (!epee::string_tools::hex_to_pod(tx_key_str.substr(0, 64), additional_tx_keys.back()))
        {
            setStatusError(tr(""Failed to parse tx key""));
            return false;
        }
        tx_key_str = tx_key_str.substr(64);
    }

    cryptonote::address_parse_info info;
    if (!cryptonote::get_account_address_from_str(info, m_wallet->nettype(), address_str))
    {
        setStatusError(tr(""Failed to parse address""));
        return false;
    }

    try
    {
        m_wallet->check_tx_key(txid, tx_key, additional_tx_keys, info.address, received, in_pool, confirmations);
        clearStatus();
        return true;
    }
    catch (const std::exception &e)
    {
        setStatusError(e.what());
        return false;
    }
}

std::string WalletImpl::getTxProof(const std::string &txid_str, const std::string &address_str, const std::string &message) const
{
    crypto::hash txid;
    if (!epee::string_tools::hex_to_pod(txid_str, txid))
    {
        setStatusError(tr(""Failed to parse txid""));
        return """";
    }

    cryptonote::address_parse_info info;
    if (!cryptonote::get_account_address_from_str(info, m_wallet->nettype(), address_str))
    {
        setStatusError(tr(""Failed to parse address""));
        return """";
    }

    try
    {
        clearStatus();
        return m_wallet->get_tx_proof(txid, info.address, info.is_subaddress, message);
    }
    catch (const std::exception &e)
    {
        setStatusError(e.what());
        return """";
    }
}

bool WalletImpl::checkTxProof(const std::string &txid_str, const std::string &address_str, const std::string &message, const std::string &signature, bool &good, uint64_t &received, bool &in_pool, uint64_t &confirmations)
{
    crypto::hash txid;
    if (!epee::string_tools::hex_to_pod(txid_str, txid))
    {
        setStatusError(tr(""Failed to parse txid""));
        return false;
    }

    cryptonote::address_parse_info info;
    if (!cryptonote::get_account_address_from_str(info, m_wallet->nettype(), address_str))
    {
        setStatusError(tr(""Failed to parse address""));
        return false;
    }

    try
    {
        good = m_wallet->check_tx_proof(txid, info.address, info.is_subaddress, message, signature, received, in_pool, confirmations);
        clearStatus();
        return true;
    }
    catch (const std::exception &e)
    {
        setStatusError(e.what());
        return false;
    }
}

std::string WalletImpl::getSpendProof(const std::string &txid_str, const std::string &message) const {
    crypto::hash txid;
    if(!epee::string_tools::hex_to_pod(txid_str, txid))
    {
        setStatusError(tr(""Failed to parse txid""));
        return """";
    }

    try
    {
        clearStatus();
        return m_wallet->get_spend_proof(txid, message);
    }
    catch (const std::exception &e)
    {
        setStatusError(e.what());
        return """";
    }
}

bool WalletImpl::checkSpendProof(const std::string &txid_str, const std::string &message, const std::string &signature, bool &good) const {
    good = false;
    crypto::hash txid;
    if(!epee::string_tools::hex_to_pod(txid_str, txid))
    {
        setStatusError(tr(""Failed to parse txid""));
        return false;
    }

    try
    {
        clearStatus();
        good = m_wallet->check_spend_proof(txid, message, signature);
        return true;
    }
    catch (const std::exception &e)
    {
        setStatusError(e.what());
        return false;
    }
}

std::string WalletImpl::getReserveProof(bool all, uint32_t account_index, uint64_t amount, const std::string &message) const {
    try
    {
        clearStatus();
        boost::optional<std::pair<uint32_t, uint64_t>> account_minreserve;
        if (!all)
        {
            account_minreserve = std::make_pair(account_index, amount);
        }
        return m_wallet->get_reserve_proof(account_minreserve, message);
    }
    catch (const std::exception &e)
    {
        setStatusError(e.what());
        return """";
    }
}

bool WalletImpl::checkReserveProof(const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &total, uint64_t &spent) const {
    cryptonote::address_parse_info info;
    if (!cryptonote::get_account_address_from_str(info, m_wallet->nettype(), address))
    {
        setStatusError(tr(""Failed to parse address""));
        return false;
    }
    if (info.is_subaddress)
    {
        setStatusError(tr(""Address must not be a subaddress""));
        return false;
    }

    good = false;
    try
    {
        clearStatus();
        good = m_wallet->check_reserve_proof(info.address, message, signature, total, spent);
        return true;
    }
    catch (const std::exception &e)
    {
        setStatusError(e.what());
        return false;
    }
}

std::string WalletImpl::signMessage(const std::string &message)
{
  return m_wallet->sign(message);
}

bool WalletImpl::verifySignedMessage(const std::string &message, const std::string &address, const std::string &signature) const
{
  cryptonote::address_parse_info info;

  if (!cryptonote::get_account_address_from_str(info, m_wallet->nettype(), address))
    return false;

  return m_wallet->verify(message, info.address, signature);
}

std::string WalletImpl::signMultisigParticipant(const std::string &message) const
{
    clearStatus();

    bool ready = false;
    if (!m_wallet->multisig(&ready) || !ready) {
        m_status = Status_Error;
        m_errorString = tr(""The wallet must be in multisig ready state"");
        return {};
    }

    try {
        return m_wallet->sign_multisig_participant(message);
    } catch (const std::exception& e) {
        m_status = Status_Error;
        m_errorString = e.what();
    }

    return {};
}

bool WalletImpl::verifyMessageWithPublicKey(const std::string &message, const std::string &publicKey, const std::string &signature) const
{
    clearStatus();

    cryptonote::blobdata pkeyData;
    if(!epee::string_tools::parse_hexstr_to_binbuff(publicKey, pkeyData) || pkeyData.size() != sizeof(crypto::public_key))
    {
        m_status = Status_Error;
        m_errorString = tr(""Given string is not a key"");
        return false;
    }

    try {
        crypto::public_key pkey = *reinterpret_cast<const crypto::public_key*>(pkeyData.data());
        return m_wallet->verify_with_public_key(message, pkey, signature);
    } catch (const std::exception& e) {
        m_status = Status_Error;
        m_errorString = e.what();
    }

    return false;
}

bool WalletImpl::connectToDaemon()
{
    bool result = m_wallet->check_connection(NULL, DEFAULT_CONNECTION_TIMEOUT_MILLIS);
    if (!result) {
        setStatusError(""Error connecting to daemon at "" + m_wallet->get_daemon_address());
    } else {
        clearStatus();
        // start refreshing here
    }
    return result;
}

Wallet::ConnectionStatus WalletImpl::connected() const
{
    uint32_t version = 0;
    m_is_connected = m_wallet->check_connection(&version, DEFAULT_CONNECTION_TIMEOUT_MILLIS);
    if (!m_is_connected)
        return Wallet::ConnectionStatus_Disconnected;
    // Version check is not implemented in light wallets nodes/wallets
    if (!m_wallet->light_wallet() && (version >> 16) != CORE_RPC_VERSION_MAJOR)
        return Wallet::ConnectionStatus_WrongVersion;
    return Wallet::ConnectionStatus_Connected;
}

void WalletImpl::setTrustedDaemon(bool arg)
{
    m_trustedDaemon = arg;
}

bool WalletImpl::trustedDaemon() const
{
    return m_trustedDaemon;
}

bool WalletImpl::watchOnly() const
{
    return m_wallet->watch_only();
}

void WalletImpl::clearStatus() const
{
    boost::lock_guard<boost::mutex> l(m_statusMutex);
    m_status = Status_Ok;
    m_errorString.clear();
}

void WalletImpl::setStatusError(const std::string& message) const
{
    setStatus(Status_Error, message);
}

void WalletImpl::setStatusCritical(const std::string& message) const
{
    setStatus(Status_Critical, message);
}

void WalletImpl::setStatus(int status, const std::string& message) const
{
    boost::lock_guard<boost::mutex> l(m_statusMutex);
    m_status = status;
    m_errorString = message;
}

void WalletImpl::refreshThreadFunc()
{
    LOG_PRINT_L3(__FUNCTION__ << "": starting refresh thread"");

    while (true) {
        boost::mutex::scoped_lock lock(m_refreshMutex);
        if (m_refreshThreadDone) {
            break;
        }
        LOG_PRINT_L3(__FUNCTION__ << "": waiting for refresh..."");
        // if auto refresh enabled, we wait for the ""m_refreshIntervalSeconds"" interval.
        // if not - we wait forever
        if (m_refreshIntervalMillis > 0) {
            boost::posix_time::milliseconds wait_for_ms(m_refreshIntervalMillis.load());
            m_refreshCV.timed_wait(lock, wait_for_ms);
        } else {
            m_refreshCV.wait(lock);
        }

        LOG_PRINT_L3(__FUNCTION__ << "": refresh lock acquired..."");
        LOG_PRINT_L3(__FUNCTION__ << "": m_refreshEnabled: "" << m_refreshEnabled);
        LOG_PRINT_L3(__FUNCTION__ << "": m_status: "" << status());
        if (m_refreshEnabled) {
            LOG_PRINT_L3(__FUNCTION__ << "": refreshing..."");
            doRefresh();
        }
    }
    LOG_PRINT_L3(__FUNCTION__ << "": refresh thread stopped"");
}

void WalletImpl::doRefresh()
{
    // synchronizing async and sync refresh calls
    boost::lock_guard<boost::mutex> guarg(m_refreshMutex2);
    try {
        // Syncing daemon and refreshing wallet simultaneously is very resource intensive.
        // Disable refresh if wallet is disconnected or daemon isn't synced.
        if (m_wallet->light_wallet() || daemonSynced()) {
            m_wallet->refresh();
            if (!m_synchronized) {
                m_synchronized = true;
            }
            // assuming if we have empty history, it wasn't initialized yet
            // for further history changes client need to update history in
            // ""on_money_received"" and ""on_money_sent"" callbacks
            if (m_history->count() == 0) {
                m_history->refresh();
            }
            m_wallet->find_and_save_rings(false);
        } else {
           LOG_PRINT_L3(__FUNCTION__ << "": skipping refresh - daemon is not synced"");
        }
    } catch (const std::exception &e) {
        setStatusError(e.what());
    }
    if (m_wallet2Callback->getListener()) {
        m_wallet2Callback->getListener()->refreshed();
    }
}


void WalletImpl::startRefresh()
{
    if (!m_refreshEnabled) {
        LOG_PRINT_L2(__FUNCTION__ << "": refresh started/resumed..."");
        m_refreshEnabled = true;
        m_refreshCV.notify_one();
    }
}



void WalletImpl::stopRefresh()
{
    if (!m_refreshThreadDone) {
        m_refreshEnabled = false;
        m_refreshThreadDone = true;
        m_refreshCV.notify_one();
        m_refreshThread.join();
    }
}

void WalletImpl::pauseRefresh()
{
    LOG_PRINT_L2(__FUNCTION__ << "": refresh paused..."");
    // TODO synchronize access
    if (!m_refreshThreadDone) {
        m_refreshEnabled = false;
    }
}


bool WalletImpl::isNewWallet() const
{
    // in case wallet created without daemon connection, closed and opened again,
    // it's the same case as if it created from scratch, i.e. we need ""fast sync""
    // with the daemon (pull hashes instead of pull blocks).
    // If wallet cache is rebuilt, creation height stored in .keys is used.
    // Watch only wallet is a copy of an existing wallet. 
    return !(blockChainHeight() > 1 || m_recoveringFromSeed || m_rebuildWalletCache) && !watchOnly();
}

bool WalletImpl::doInit(const string &daemon_address, uint64_t upper_transaction_size_limit, bool ssl)
{
    if (!m_wallet->init(daemon_address, m_daemon_login, upper_transaction_size_limit, ssl))
       return false;

    // in case new wallet, this will force fast-refresh (pulling hashes instead of blocks)
    // If daemon isn't synced a calculated block height will be used instead
    //TODO: Handle light wallet scenario where block height = 0.
    if (isNewWallet() && daemonSynced()) {
        LOG_PRINT_L2(__FUNCTION__ << "":New Wallet - fast refresh until "" << daemonBlockChainHeight());
        m_wallet->set_refresh_from_block_height(daemonBlockChainHeight());
    }

    if (m_rebuildWalletCache)
      LOG_PRINT_L2(__FUNCTION__ << "": Rebuilding wallet cache, fast refresh until block "" << m_wallet->get_refresh_from_block_height());

    if (Utils::isAddressLocal(daemon_address)) {
        this->setTrustedDaemon(true);
        m_refreshIntervalMillis = DEFAULT_REFRESH_INTERVAL_MILLIS;
    } else {
        this->setTrustedDaemon(false);
        m_refreshIntervalMillis = DEFAULT_REMOTE_NODE_REFRESH_INTERVAL_MILLIS;
    }
    return true;
}

bool WalletImpl::parse_uri(const std::string &uri, std::string &address, std::string &payment_id, uint64_t &amount, std::string &tx_description, std::string &recipient_name, std::vector<std::string> &unknown_parameters, std::string &error)
{
    return m_wallet->parse_uri(uri, address, payment_id, amount, tx_description, recipient_name, unknown_parameters, error);
}

std::string WalletImpl::getDefaultDataDir() const
{
 return tools::get_default_data_dir();
}

bool WalletImpl::rescanSpent()
{
  clearStatus();
  if (!trustedDaemon()) {
    setStatusError(tr(""Rescan spent can only be used with a trusted daemon""));
    return false;
  }
  try {
      m_wallet->rescan_spent();
  } catch (const std::exception &e) {
      LOG_ERROR(__FUNCTION__ << "" error: "" << e.what());
      setStatusError(e.what());
      return false;
  }
  return true;
}


void WalletImpl::hardForkInfo(uint8_t &version, uint64_t &earliest_height) const
{
    m_wallet->get_hard_fork_info(version, earliest_height);
}

bool WalletImpl::useForkRules(uint8_t version, int64_t early_blocks) const 
{
    return m_wallet->use_fork_rules(version,early_blocks);
}

bool WalletImpl::blackballOutputs(const std::vector<std::string> &pubkeys, bool add)
{
    std::vector<crypto::public_key> raw_pubkeys;
    raw_pubkeys.reserve(pubkeys.size());
    for (const std::string &str: pubkeys)
    {
        crypto::public_key pkey;
        if (!epee::string_tools::hex_to_pod(str, pkey))
        {
            setStatusError(tr(""Failed to parse output public key""));
            return false;
        }
        raw_pubkeys.push_back(pkey);
    }
    bool ret = m_wallet->set_blackballed_outputs(raw_pubkeys, add);
    if (!ret)
    {
        setStatusError(tr(""Failed to set blackballed outputs""));
        return false;
    }
    return true;
}

bool WalletImpl::unblackballOutput(const std::string &pubkey)
{
    crypto::public_key raw_pubkey;
    if (!epee::string_tools::hex_to_pod(pubkey, raw_pubkey))
    {
        setStatusError(tr(""Failed to parse output public key""));
        return false;
    }
    bool ret = m_wallet->unblackball_output(raw_pubkey);
    if (!ret)
    {
        setStatusError(tr(""Failed to unblackball output""));
        return false;
    }
    return true;
}

bool WalletImpl::getRing(const std::string &key_image, std::vector<uint64_t> &ring) const
{
    crypto::key_image raw_key_image;
    if (!epee::string_tools::hex_to_pod(key_image, raw_key_image))
    {
        setStatusError(tr(""Failed to parse key image""));
        return false;
    }
    bool ret = m_wallet->get_ring(raw_key_image, ring);
    if (!ret)
    {
        setStatusError(tr(""Failed to get ring""));
        return false;
    }
    return true;
}

bool WalletImpl::getRings(const std::string &txid, std::vector<std::pair<std::string, std::vector<uint64_t>>> &rings) const
{
    crypto::hash raw_txid;
    if (!epee::string_tools::hex_to_pod(txid, raw_txid))
    {
        setStatusError(tr(""Failed to parse txid""));
        return false;
    }
    std::vector<std::pair<crypto::key_image, std::vector<uint64_t>>> raw_rings;
    bool ret = m_wallet->get_rings(raw_txid, raw_rings);
    if (!ret)
    {
        setStatusError(tr(""Failed to get rings""));
        return false;
    }
    for (const auto &r: raw_rings)
    {
      rings.push_back(std::make_pair(epee::string_tools::pod_to_hex(r.first), r.second));
    }
    return true;
}

bool WalletImpl::setRing(const std::string &key_image, const std::vector<uint64_t> &ring, bool relative)
{
    crypto::key_image raw_key_image;
    if (!epee::string_tools::hex_to_pod(key_image, raw_key_image))
    {
        setStatusError(tr(""Failed to parse key image""));
        return false;
    }
    bool ret = m_wallet->set_ring(raw_key_image, ring, relative);
    if (!ret)
    {
        setStatusError(tr(""Failed to set ring""));
        return false;
    }
    return true;
}

void WalletImpl::segregatePreForkOutputs(bool segregate)
{
    m_wallet->segregate_pre_fork_outputs(segregate);
}

void WalletImpl::segregationHeight(uint64_t height)
{
    m_wallet->segregation_height(height);
}

void WalletImpl::keyReuseMitigation2(bool mitigation)
{
    m_wallet->key_reuse_mitigation2(mitigation);
}

bool WalletImpl::lockKeysFile()
{
    return m_wallet->lock_keys_file();
}

bool WalletImpl::unlockKeysFile()
{
    return m_wallet->unlock_keys_file();
}

bool WalletImpl::isKeysFileLocked()
{
    return m_wallet->is_keys_file_locked();
}
} // namespace

namespace Bitmonero = Monero;
",16263,True,3175.657939399993,median
"// Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin Core developers
// Copyright (c) 2014-2020 The Dash Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <chainparams.h>
#include <consensus/merkle.h>

#include <tinyformat.h>
#include <util.h>
#include <utilstrencodings.h>

#include <arith_uint256.h>

#include <assert.h>

#include <chainparamsseeds.h>

static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
{
    CMutableTransaction txNew;
    txNew.nVersion = 1;
    txNew.vin.resize(1);
    txNew.vout.resize(1);
    txNew.vin[0].scriptSig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
    txNew.vout[0].nValue = genesisReward;
    txNew.vout[0].scriptPubKey = genesisOutputScript;

    CBlock genesis;
    genesis.nTime    = nTime;
    genesis.nBits    = nBits;
    genesis.nNonce   = nNonce;
    genesis.nVersion = nVersion;
    genesis.vtx.push_back(MakeTransactionRef(std::move(txNew)));
    genesis.hashPrevBlock.SetNull();
    genesis.hashMerkleRoot = BlockMerkleRoot(genesis);
    return genesis;
}

static CBlock CreateDevNetGenesisBlock(const uint256 &prevBlockHash, const std::string& devNetName, uint32_t nTime, uint32_t nNonce, uint32_t nBits, const CAmount& genesisReward)
{
    assert(!devNetName.empty());

    CMutableTransaction txNew;
    txNew.nVersion = 1;
    txNew.vin.resize(1);
    txNew.vout.resize(1);
    // put height (BIP34) and devnet name into coinbase
    txNew.vin[0].scriptSig = CScript() << 1 << std::vector<unsigned char>(devNetName.begin(), devNetName.end());
    txNew.vout[0].nValue = genesisReward;
    txNew.vout[0].scriptPubKey = CScript() << OP_RETURN;

    CBlock genesis;
    genesis.nTime    = nTime;
    genesis.nBits    = nBits;
    genesis.nNonce   = nNonce;
    genesis.nVersion = 4;
    genesis.vtx.push_back(MakeTransactionRef(std::move(txNew)));
    genesis.hashPrevBlock = prevBlockHash;
    genesis.hashMerkleRoot = BlockMerkleRoot(genesis);
    return genesis;
}

static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
{
    const char* pszTimestamp = ""01/Oct/2020 StakeCubeCoin swaps to DASH codebase"";
    const CScript genesisOutputScript = CScript() << ParseHex(""040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9"") << OP_CHECKSIG;
    return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nNonce, nBits, nVersion, genesisReward);
}

void CChainParams::UpdateVersionBitsParameters(Consensus::DeploymentPos d, int64_t nStartTime, int64_t nTimeout, int64_t nWindowSize, int64_t nThreshold)
{
    consensus.vDeployments[d].nStartTime = nStartTime;
    consensus.vDeployments[d].nTimeout = nTimeout;
    if (nWindowSize != -1) {
            consensus.vDeployments[d].nWindowSize = nWindowSize;
    }
    if (nThreshold != -1) {
            consensus.vDeployments[d].nThreshold = nThreshold;
    }
}

void CChainParams::UpdateDIP3Parameters(int nActivationHeight, int nEnforcementHeight)
{
    consensus.DIP0003Height = nActivationHeight;
    consensus.DIP0003EnforcementHeight = nEnforcementHeight;
}

void CChainParams::UpdateBudgetParameters(int nMasternodePaymentsStartBlock, int nBudgetPaymentsStartBlock, int nSuperblockStartBlock)
{
    consensus.nMasternodePaymentsStartBlock = nMasternodePaymentsStartBlock;
    consensus.nBudgetPaymentsStartBlock = nBudgetPaymentsStartBlock;
    consensus.nSuperblockStartBlock = nSuperblockStartBlock;
}

void CChainParams::UpdateSubsidyAndDiffParams(int nMinimumDifficultyBlocks, int nHighSubsidyBlocks, int nHighSubsidyFactor)
{
    consensus.nMinimumDifficultyBlocks = nMinimumDifficultyBlocks;
    consensus.nHighSubsidyBlocks = nHighSubsidyBlocks;
    consensus.nHighSubsidyFactor = nHighSubsidyFactor;
}

void CChainParams::UpdateLLMQChainLocks(Consensus::LLMQType llmqType) {
    consensus.llmqTypeChainLocks = llmqType;
}

void CChainParams::UpdateLLMQTestParams(int size, int threshold) {
    auto& params = consensus.llmqs.at(Consensus::LLMQ_TEST);
    params.size = size;
    params.minSize = threshold;
    params.threshold = threshold;
    params.dkgBadVotesThreshold = threshold;
}

void CChainParams::UpdateLLMQDevnetParams(int size, int threshold)
{
    auto& params = consensus.llmqs.at(Consensus::LLMQ_DEVNET);
    params.size = size;
    params.minSize = threshold;
    params.threshold = threshold;
    params.dkgBadVotesThreshold = threshold;
}

static CBlock FindDevNetGenesisBlock(const CBlock &prevBlock, const CAmount& reward)
{
    std::string devNetName = gArgs.GetDevNetName();
    assert(!devNetName.empty());

    CBlock block = CreateDevNetGenesisBlock(prevBlock.GetHash(), devNetName.c_str(), prevBlock.nTime + 1, 0, prevBlock.nBits, reward);

    arith_uint256 bnTarget;
    bnTarget.SetCompact(block.nBits);

    for (uint32_t nNonce = 0; nNonce < UINT32_MAX; nNonce++) {
        block.nNonce = nNonce;

        uint256 hash = block.GetHash();
        if (UintToArith256(hash) <= bnTarget)
            return block;
    }

    // This is very unlikely to happen as we start the devnet with a very low difficulty. In many cases even the first
    // iteration of the above loop will give a result already
    error(""FindDevNetGenesisBlock: could not find devnet genesis block for %s"", devNetName);
    assert(false);
}

// this one is for testing only
static Consensus::LLMQParams llmq_test = {
        .type = Consensus::LLMQ_TEST,
        .name = ""llmq_test"",
        .size = 3,
        .minSize = 2,
        .threshold = 2,

        .dkgInterval = 24, // one DKG per hour
        .dkgPhaseBlocks = 2,
        .dkgMiningWindowStart = 10, // dkgPhaseBlocks * 5 = after finalization
        .dkgMiningWindowEnd = 18,
        .dkgBadVotesThreshold = 2,

        .signingActiveQuorumCount = 2, // just a few ones to allow easier testing

        .keepOldConnections = 3,
        .recoveryMembers = 3,
};

// this one is for devnets only
static Consensus::LLMQParams llmq_devnet = {
        .type = Consensus::LLMQ_DEVNET,
        .name = ""llmq_devnet"",
        .size = 10,
        .minSize = 7,
        .threshold = 6,

        .dkgInterval = 24, // one DKG per hour
        .dkgPhaseBlocks = 2,
        .dkgMiningWindowStart = 10, // dkgPhaseBlocks * 5 = after finalization
        .dkgMiningWindowEnd = 18,
        .dkgBadVotesThreshold = 7,

        .signingActiveQuorumCount = 3, // just a few ones to allow easier testing

        .keepOldConnections = 4,
        .recoveryMembers = 6,
};

static Consensus::LLMQParams llmq50_60 = {
        .type = Consensus::LLMQ_50_60,
        .name = ""llmq_50_60"",
        .size = 50,
        .minSize = 40,
        .threshold = 30,

        .dkgInterval = 24, // one DKG per hour
        .dkgPhaseBlocks = 2,
        .dkgMiningWindowStart = 10, // dkgPhaseBlocks * 5 = after finalization
        .dkgMiningWindowEnd = 18,
        .dkgBadVotesThreshold = 40,

        .signingActiveQuorumCount = 24, // a full day worth of LLMQs

        .keepOldConnections = 25,
        .recoveryMembers = 25,
};

static Consensus::LLMQParams llmq400_60 = {
        .type = Consensus::LLMQ_400_60,
        .name = ""llmq_400_60"",
        .size = 400,
        .minSize = 300,
        .threshold = 240,

        .dkgInterval = 24 * 12, // one DKG every 12 hours
        .dkgPhaseBlocks = 4,
        .dkgMiningWindowStart = 20, // dkgPhaseBlocks * 5 = after finalization
        .dkgMiningWindowEnd = 28,
        .dkgBadVotesThreshold = 300,

        .signingActiveQuorumCount = 4, // two days worth of LLMQs

        .keepOldConnections = 5,
        .recoveryMembers = 100,
};

// Used for deployment and min-proto-version signalling, so it needs a higher threshold
static Consensus::LLMQParams llmq400_85 = {
        .type = Consensus::LLMQ_400_85,
        .name = ""llmq_400_85"",
        .size = 400,
        .minSize = 350,
        .threshold = 340,

        .dkgInterval = 24 * 24, // one DKG every 24 hours
        .dkgPhaseBlocks = 4,
        .dkgMiningWindowStart = 20, // dkgPhaseBlocks * 5 = after finalization
        .dkgMiningWindowEnd = 48, // give it a larger mining window to make sure it is mined
        .dkgBadVotesThreshold = 300,

        .signingActiveQuorumCount = 4, // four days worth of LLMQs

        .keepOldConnections = 5,
        .recoveryMembers = 100,
};


// Toggle to regenerate genesis
// Not needed after release, but lets keep it for other devs :)
static bool regenerate = false;

/**
 * Main network
 */

class CMainParams : public CChainParams {
public:
    CMainParams() {
        /** General **/
        strNetworkID = ""main"";
        consensus.nSubsidyHalvingInterval = 400000U; // unused

        /** Masternodes **/
        consensus.nMasternodePaymentsStartBlock     = 200;
        consensus.nMasternodePaymentsIncreaseBlock  = 400000U; // unused
        consensus.nMasternodePaymentsIncreasePeriod = 400000U; // unused
        consensus.nMasternodeMinimumConfirmations   = 15;

        /** InstantSend **/
        consensus.nInstantSendConfirmationsRequired = 6;
        consensus.nInstantSendKeepLock = 24;

        /** Height or Time Based Activations **/
        consensus.BIP34Height   = 1; // Block v2 (activated immediately)
        consensus.BIP34Hash     = uint256();
        consensus.BIP65Height   = 1; // OP_CHECKLOCKTIMEVERIFY (activated immediately)
        consensus.BIP66Height   = 1; // Strict DER signatures (activated immediately)
        consensus.DIP0001Height = 2; // Initial Scaling of the Network (activated immediately)
        consensus.DIP0003Height = 2; // Deterministic Masternode Lists (activated immediately)
        consensus.DIP0003EnforcementHeight = 2;
        consensus.DIP0003EnforcementHash   = uint256();

        /** PoW **/
        consensus.powLimit = uint256S(""00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff""); // ~uint256(0) >> 20
        consensus.nPowTargetTimespan = 24 * 60 * 60; // 1 day
        consensus.nPowTargetSpacing = 2 * 60; // 2 minutes
        consensus.fPowAllowMinDifficultyBlocks = false;
        consensus.fPowNoRetargeting = false;
        consensus.nPowKGWHeight = 1;
        consensus.nPowDGWHeight = 2;
        consensus.nRuleChangeActivationThreshold = 1512; // 75% of 2016
        consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing

        // StakeCubeCoin: We do not *yet* use BudgetPayments, Superblocks and Governance
        consensus.nBudgetPaymentsStartBlock   = INT_MAX; // 2147483647 (= never | requires hardfork to enable)
        consensus.nBudgetPaymentsCycleBlocks  = 21600; // ~(60*24*30)/2
        consensus.nBudgetPaymentsWindowBlocks = 100;
        consensus.nSuperblockStartBlock       = 10000; // Hardfork date to re-enable SuperBlocks logic (controlling via spork instead of chain-params)
        consensus.nSuperblockStartHash        = uint256();
        consensus.nSuperblockCycle            = 21600; // ~(60*24*30)/2
        consensus.nGovernanceMinQuorum        = 10;
        consensus.nGovernanceFilterElements   = 20000;

        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit         = 28;
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime  = 1199145601; // Jan 1st, 2008
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout    = 1230811200; // Jan 1th, 2009

        // Deployment of BIP68, BIP112, and BIP113.
        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].bit               = 0;
        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime        = 1486252800; // Feb 5th, 2017
        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout          = 1517788800; // Feb 5th, 2018

        // Deployment of DIP0001
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].bit           = 1;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nStartTime    = 1508025600; // Oct 15th, 2017
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nTimeout      = 1539561600; // Oct 15th, 2018
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nWindowSize   = 100;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nThreshold    = 50;

        // Deployment of BIP147
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].bit            = 2;
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nStartTime     = 1524477600; // Apr 23th, 2018
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nTimeout       = 1556013600; // Apr 23th, 2019
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nWindowSize    = 100;
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nThreshold     = 50;

        // Deployment of DIP0003 (Deterministic Masternode Lists)
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].bit           = 3;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nStartTime    = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nTimeout      = Consensus::BIP9Deployment::NO_TIMEOUT;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nWindowSize   = 100;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nThreshold    = 50;

        // Deployment of DIP0008 (ChainLocks)
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].bit           = 4;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nStartTime    = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nTimeout      = Consensus::BIP9Deployment::NO_TIMEOUT;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nWindowSize   = 100;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nThreshold    = 50;

        // The best chain should have at least this much work.
        consensus.nMinimumChainWork = uint256S(""0x00""); // 0 TODO: Increase with future release

        // By default assume that the signatures in ancestors of this block are valid.
        consensus.defaultAssumeValid = uint256S(""0x00""); // 0 TODO: Increase with future release

        /**
         * The message start string is designed to be unlikely to occur in normal data.
         * The characters are rarely used upper ASCII, not valid as UTF-8, and produce
         * a large 32-bit integer with any alignment.
         */
        pchMessageStart[0] = 0x06;
        pchMessageStart[1] = 0x73;
        pchMessageStart[2] = 0x44;
        pchMessageStart[3] = 0x51;
        nDefaultPort = 40000;
        nPruneAfterHeight = 100000;

        genesis = CreateGenesisBlock(1601898626, 433472, 0x1e0ffff0, 1, 50 * COIN);
        consensus.hashGenesisBlock = genesis.GetHash();

        if (regenerate) {
            consensus.hashGenesisBlock = uint256S("""");
            genesis.nNonce = 0;
            arith_uint256 hashTarget = arith_uint256().SetCompact(genesis.nBits);
            if (true && (genesis.GetHash() != consensus.hashGenesisBlock)) {
                while (UintToArith256(genesis.GetHash()) > hashTarget)
                {
                    ++genesis.nNonce;
                    if (genesis.nNonce == 0)
                    {
                        ++genesis.nTime;
                    }
                }
                LogPrintf(""Mainnet:\\n"");
                LogPrintf(""-nonce: %u\\n"", genesis.nNonce);
                LogPrintf(""-time: %u\\n"", genesis.nTime);
                LogPrintf(""-hash: 0x%s\\n"", genesis.GetHash().ToString().c_str());
                LogPrintf(""-merklehash: 0x%s\\n"", genesis.hashMerkleRoot.ToString().c_str());
            }
        }
        else {
            assert(consensus.hashGenesisBlock == uint256S(""0x000001112c342e635d0e48db15505392e74b2cab902dff9243ade44939da5b47""));
            assert(genesis.hashMerkleRoot == uint256S(""0x361a210a8b44c51526bd08d50cfe2d272d9b1e65837d6e4c456d327106334e48""));
        }

        // Note that of those which support the service bits prefix, most only support a subset of
        // possible options.
        // This is fine at runtime as we'll fall back to using them as a oneshot if they don't support the
        // service bits we want, but we should get them updated to support all service bits wanted by any
        // release ASAP to avoid it where possible.
        vSeeds.emplace_back(""seed1.stakecube.net"");
        vSeeds.emplace_back(""seed2.stakecube.net"");

        // StakeCubeCoin addresses start with 's'
        base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,125);
        // StakeCubeCoin script addresses start with 'p'
        base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,117);
        // StakeCubeCoin private keys start with 'p' or 'e'
        base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,253);
        // StakeCubeCoin BIP32 pubkeys start with 'xpub' (Bitcoin defaults)
        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
        // StakeCubeCoin BIP32 prvkeys start with 'xprv' (Bitcoin defaults)
        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};

        // StakeCubeCoin BIP44 coin type is '5'
        nExtCoinType = 522;

        vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_main, pnSeed6_main + ARRAYLEN(pnSeed6_main));

        // long living quorum params
        consensus.llmqs[Consensus::LLMQ_50_60] = llmq50_60;
        consensus.llmqs[Consensus::LLMQ_400_60] = llmq400_60;
        consensus.llmqs[Consensus::LLMQ_400_85] = llmq400_85;
        consensus.llmqTypeChainLocks = Consensus::LLMQ_400_60;
        consensus.llmqTypeInstantSend = Consensus::LLMQ_50_60;

        fDefaultConsistencyChecks = false;
        fRequireStandard = true;
        fRequireRoutableExternalIP = true;
        fMineBlocksOnDemand = false;
        fAllowMultipleAddressesFromGroup = true;
        fAllowMultiplePorts = true;
        nLLMQConnectionRetryTimeout = 60;

        nPoolMinParticipants = 3;
        nPoolNewMinParticipants = 3;
        nPoolMaxParticipants = 5;
        nPoolNewMaxParticipants = 20;
        nFulfilledRequestExpireTime = 60*60; // fulfilled requests expire in 1 hour

        vSporkAddresses = {""sJbcSRccZQfmgjeW28uEEh9PswngZj1RXb""};
        nMinSporkKeys = 1;
        fBIP9CheckMasternodesUpgraded = true;

        /**
         * What makes a good checkpoint block?
         * + Is surrounded by blocks with reasonable timestamps
         *   (no blocks before with a timestamp after, none after with
         *    timestamp before)
         * + Contains no strange transactions
         */
        checkpointData = {
            {
                // Launch checkpoints
                {0,     uint256S(""0x000001112c342e635d0e48db15505392e74b2cab902dff9243ade44939da5b47"")},
                {1,     uint256S(""0x00000a3d1238b01735d6cce4f161c0f8afbf4e9da0d0a8b2cfe72e5714084dd7"")},
                // The SuperBlocks update
                {1000,  uint256S(""0x000000000000439832ca2a8c452fde2674646b39e720da9a253d3c072a2b52b9"")},
                {2000,  uint256S(""0x0000000000002833bd22fb36b0ae5d0b756627bb2648f394b198461749140a42"")},
                {3000,  uint256S(""0x000000000000c22d5d58d8c4e6db75d0b4d500ac1ba3d484e863b36514f1d1d7"")},
                {4000,  uint256S(""0x000000000000a0d6d6e7be5e1a6168bc08ebea36394a840d7b3a9a0708f37748"")},
                {5000,  uint256S(""0x0000000000005c73a59d7203ab44f08ea043d9ee1a8440d148435f17a8672c0d"")},
                {6000,  uint256S(""0x000000000000031f3adff1ae73100663cce2ff648efe82b52466394132089e35"")},
                {6438,  uint256S(""0x000000000000037f22b857984bbd520af912cbf24975c35815710bcb0d3ebb47"")},
                // The StakeCube Protocol (SCP) update
                {10000, uint256S(""00000000000002f5a3089ba562fb42939756818b4e47f53fad042f6f734c5410"")},
                {20000, uint256S(""00000000000002742de1ac4e218ccc68dba52976a07d46b4aaf2b8a09b27c020"")},
                {30000, uint256S(""000000000000038eb91445c2125d2fd5fbb6dadf5d9f07d3b55b310446773c5d"")},
                {40000, uint256S(""00000000000021718c8fc16f28e997b51cbe54cdc3a98f9b547143a41f8e85f6"")},
                {50000, uint256S(""0000000000001f3bd04b01d0f38274ea3b7c8baaa0fd2c61644cf268b8c19327"")},
                {60000, uint256S(""000000000000045f81b9960f202b6b01ee84c14c6f3a3f40b87208cb22c0352d"")},
                {70000, uint256S(""00000000000006d174130512a8b18e24a74fde341d4dcf1cd99c9e8a388e9059"")},
                {80000, uint256S(""0000000000002c62043577372f6d94aebd38960f8692809d2a06889e2299f3c9"")},
                {90000, uint256S(""00000000000004f7d71ff39d4d8deb45a353e6b9d2f2fc6050fe78d634ccc78a"")},
                {100000, uint256S(""00000000000011e634d6f2351351cfdecce8210c4fd319b2b0a57fede65548b2"")},
                {105302, uint256S(""00000000000006000db09a96981ed231c3bdabb6b12f2b113a6ae4a5af2cf292"")}
                // Some future update...
            }
        };

        chainTxData = ChainTxData{
            1615889778, // * UNIX timestamp of last known number of transactions (Block 1)
            178606,          // * total number of transactions between genesis and that timestamp
                        //   (the tx=... number in the SetBestChain debug.log lines)
            0.01        // * estimated number of transactions per second after that timestamp
        };
    }
};

/**
 * Testnet (v3)
 */
class CTestNetParams : public CChainParams {
public:
    CTestNetParams() {
        /** General **/
        strNetworkID = ""test"";
        consensus.nSubsidyHalvingInterval = 400000U; // unused

        /** Masternodes **/
        consensus.nMasternodePaymentsStartBlock     = 200;
        consensus.nMasternodePaymentsIncreaseBlock  = 400000U; // unused
        consensus.nMasternodePaymentsIncreasePeriod = 400000U; // unused
        consensus.nMasternodeMinimumConfirmations   = 15;

        /** InstantSend **/
        consensus.nInstantSendConfirmationsRequired = 2;
        consensus.nInstantSendKeepLock = 6;

        /** Height or Time Based Activations **/
        consensus.BIP34Height   = 1; // Block v2 (activated immediately)
        consensus.BIP34Hash     = uint256();
        consensus.BIP65Height   = 1; // OP_CHECKLOCKTIMEVERIFY (activated immediately)
        consensus.BIP66Height   = 1; // Strict DER signatures (activated immediately)
        consensus.DIP0001Height = 2; // Initial Scaling of the Network (activated immediately)
        consensus.DIP0003Height = 2; // Deterministic Masternode Lists (activated immediately)
        consensus.DIP0003EnforcementHeight = 2;
        consensus.DIP0003EnforcementHash   = uint256();

        /** PoW **/
        consensus.powLimit = uint256S(""00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff""); // ~uint256(0) >> 20
        consensus.nPowTargetTimespan = 24 * 60 * 60; // 1 day
        consensus.nPowTargetSpacing = 0.5 * 60; // 30 seconds
        consensus.fPowAllowMinDifficultyBlocks = false;
        consensus.fPowNoRetargeting = false;
        consensus.nPowKGWHeight = 1;
        consensus.nPowDGWHeight = 2;
        consensus.nRuleChangeActivationThreshold = 1512; // 75% of 2016
        consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing

        // StakeCubeCoin: We do not use BudgetPayments, Superblocks and Governance
        consensus.nBudgetPaymentsStartBlock   = INT_MAX; // 2147483647 (= never | requires hardfork to enable)
        consensus.nBudgetPaymentsCycleBlocks  = 21600;   // ~(60*24*30)/2
        consensus.nBudgetPaymentsWindowBlocks = 100;
        consensus.nSuperblockStartBlock       = 300;     // Activated by the time we have enough Masternodes online
        consensus.nSuperblockStartHash        = uint256();
        consensus.nSuperblockCycle            = 21600;  // ~(60*24*30)/2
        consensus.nGovernanceMinQuorum        = 10;
        consensus.nGovernanceFilterElements   = 20000;

        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit         = 28;
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime  = 1199145601; // Jan 1st, 2008
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout    = 1230811200; // Jan 1th, 2009

        // Deployment of BIP68, BIP112, and BIP113.
        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].bit               = 0;
        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime        = 1486252800; // Feb 5th, 2017
        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout          = 1517788800; // Feb 5th, 2018

        // Deployment of DIP0001
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].bit           = 1;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nStartTime    = 1508025600; // Oct 15th, 2017
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nTimeout      = 1539561600; // Oct 15th, 2018
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nWindowSize   = 100;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nThreshold    = 50;

        // Deployment of BIP147
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].bit            = 2;
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nStartTime     = 1524477600; // Apr 23th, 2018
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nTimeout       = 1556013600; // Apr 23th, 2019
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nWindowSize    = 100;
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nThreshold     = 50;

        // Deployment of DIP0003 (Deterministic Masternode Lists)
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].bit           = 3;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nStartTime    = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nTimeout      = Consensus::BIP9Deployment::NO_TIMEOUT;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nWindowSize   = 100;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nThreshold    = 50;

        // Deployment of DIP0008 (ChainLocks)
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].bit           = 4;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nStartTime    = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nTimeout      = Consensus::BIP9Deployment::NO_TIMEOUT;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nWindowSize   = 100;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nThreshold    = 50;

        // The best chain should have at least this much work.
        consensus.nMinimumChainWork = uint256S(""0x00""); // 0 TODO: Increase with future release

        // By default assume that the signatures in ancestors of this block are valid.
        consensus.defaultAssumeValid = uint256S(""0x00""); // 0 TODO: Increase with future release

        pchMessageStart[0] = 0xce;
        pchMessageStart[1] = 0xe3;
        pchMessageStart[2] = 0xca;
        pchMessageStart[3] = 0xff;
        nDefaultPort = 39995;
        nPruneAfterHeight = 1000;

        genesis = CreateGenesisBlock(1598001152UL, 585972UL, 0x1e0ffff0, 1, 50 * COIN);
        consensus.hashGenesisBlock = genesis.GetHash();

        if (regenerate) {
            consensus.hashGenesisBlock = uint256S("""");
            genesis.nNonce = 0;
            arith_uint256 hashTarget = arith_uint256().SetCompact(genesis.nBits);
            if (true && (genesis.GetHash() != consensus.hashGenesisBlock)) {
                while (UintToArith256(genesis.GetHash()) > hashTarget)
                {
                    ++genesis.nNonce;
                    if (genesis.nNonce == 0)
                    {
                        ++genesis.nTime;
                    }
                }
                LogPrintf(""Testnet:\\n"");
                LogPrintf(""-nonce: %u\\n"", genesis.nNonce);
                LogPrintf(""-time: %u\\n"", genesis.nTime);
                LogPrintf(""-hash: 0x%s\\n"", genesis.GetHash().ToString().c_str());
                LogPrintf(""-merklehash: 0x%s\\n"", genesis.hashMerkleRoot.ToString().c_str());
            }
        }
        else {
            assert(consensus.hashGenesisBlock == uint256S(""0x00000c2a7cb366c1c75154a8570ab511491662e185311460123869b917fb59ed""));
            assert(genesis.hashMerkleRoot == uint256S(""0x361a210a8b44c51526bd08d50cfe2d272d9b1e65837d6e4c456d327106334e48""));
        }

        vFixedSeeds.clear();
        vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_test, pnSeed6_test + ARRAYLEN(pnSeed6_test));

        vSeeds.clear();
        // nodes with support for servicebits filtering should be at the top
        vSeeds.emplace_back(""test-seed1.stakecube.net""); // TODO: Deploy testnet DNS seeder

        // Testnet StakeCubeCoin addresses start with 'y'
        base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,140);
        // Testnet StakeCubeCoin script addresses start with '8' or '9'
        base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,19);
        // Testnet private keys start with '9' or 'c' (Bitcoin defaults)
        base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,239);
        // Testnet StakeCubeCoin BIP32 pubkeys start with 'tpub' (Bitcoin defaults)
        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
        // Testnet StakeCubeCoin BIP32 prvkeys start with 'tprv' (Bitcoin defaults)
        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};

        // Testnet StakeCubeCoin BIP44 coin type is '1' (All coin's testnet default)
        nExtCoinType = 1;

        // long living quorum params
        consensus.llmqs[Consensus::LLMQ_50_60] = llmq50_60;
        consensus.llmqs[Consensus::LLMQ_400_60] = llmq400_60;
        consensus.llmqs[Consensus::LLMQ_400_85] = llmq400_85;
        consensus.llmqTypeChainLocks = Consensus::LLMQ_50_60;
        consensus.llmqTypeInstantSend = Consensus::LLMQ_50_60;

        fDefaultConsistencyChecks = false;
        fRequireStandard = false;
        fRequireRoutableExternalIP = true;
        fMineBlocksOnDemand = false;
        fAllowMultipleAddressesFromGroup = true;
        fAllowMultiplePorts = true;
        nLLMQConnectionRetryTimeout = 60;

        nPoolMinParticipants = 3;
        nPoolNewMinParticipants = 2;
        nPoolMaxParticipants = 5;
        nPoolNewMaxParticipants = 20;
        nFulfilledRequestExpireTime = 5*60; // fulfilled requests expire in 5 minutes

        vSporkAddresses = {""yheGKmrzUsnir4Szkbrjtjha8PMkCakWJZ""};
        nMinSporkKeys = 1;
        fBIP9CheckMasternodesUpgraded = true;

        checkpointData = { // TODO: Set more checkpoints in future release
            {
                {0, uint256S(""0x00000c2a7cb366c1c75154a8570ab511491662e185311460123869b917fb59ed"")},
            }
        };

        chainTxData = ChainTxData{
            1598001152, // * UNIX timestamp of last known number of transactions (Block 213054)
            0,          // * total number of transactions between genesis and that timestamp
                        //   (the tx=... number in the SetBestChain debug.log lines)
            0.01        // * estimated number of transactions per second after that timestamp
        };

    }
};

/**
 * Devnet
 */
class CDevNetParams : public CChainParams {
public:
    CDevNetParams() {
        strNetworkID = ""devnet"";
        consensus.nSubsidyHalvingInterval = 210240;
        consensus.nMasternodePaymentsStartBlock = 4010; // not true, but it's ok as long as it's less then nMasternodePaymentsIncreaseBlock
        consensus.nMasternodePaymentsIncreaseBlock = 4030;
        consensus.nMasternodePaymentsIncreasePeriod = 10;
        consensus.nInstantSendConfirmationsRequired = 2;
        consensus.nInstantSendKeepLock = 6;
        consensus.nBudgetPaymentsStartBlock = 4100;
        consensus.nBudgetPaymentsCycleBlocks = 50;
        consensus.nBudgetPaymentsWindowBlocks = 10;
        consensus.nSuperblockStartBlock = 4200; // NOTE: Should satisfy nSuperblockStartBlock > nBudgetPeymentsStartBlock
        consensus.nSuperblockStartHash = uint256(); // do not check this on devnet
        consensus.nSuperblockCycle = 24; // Superblocks can be issued hourly on devnet
        consensus.nGovernanceMinQuorum = 1;
        consensus.nGovernanceFilterElements = 500;
        consensus.nMasternodeMinimumConfirmations = 1;
        consensus.BIP34Height = 1; // BIP34 activated immediately on devnet
        consensus.BIP65Height = 1; // BIP65 activated immediately on devnet
        consensus.BIP66Height = 1; // BIP66 activated immediately on devnet
        consensus.DIP0001Height = 2; // DIP0001 activated immediately on devnet
        consensus.DIP0003Height = 2; // DIP0003 activated immediately on devnet
        consensus.DIP0003EnforcementHeight = 2; // DIP0003 activated immediately on devnet
        consensus.DIP0003EnforcementHash = uint256();
        consensus.powLimit = uint256S(""7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff""); // ~uint256(0) >> 1
        consensus.nPowTargetTimespan = 24 * 60 * 60; // 1 day
        consensus.nPowTargetSpacing = 2.5 * 60; // 2.5 minutes
        consensus.fPowAllowMinDifficultyBlocks = true;
        consensus.fPowNoRetargeting = false;
        consensus.nPowKGWHeight = 4001; // nPowKGWHeight >= nPowDGWHeight means ""no KGW""
        consensus.nPowDGWHeight = 4001;
        consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
        consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 1199145601; // January 1, 2008
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = 1230767999; // December 31, 2008

        // Deployment of BIP68, BIP112, and BIP113.
        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].bit = 0;
        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime = 1506556800; // September 28th, 2017
        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout = 1538092800; // September 28th, 2018

        // Deployment of DIP0001
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].bit = 1;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nStartTime = 1505692800; // Sep 18th, 2017
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nTimeout = 1537228800; // Sep 18th, 2018
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nWindowSize = 100;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nThreshold = 50; // 50% of 100

        // Deployment of BIP147
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].bit = 2;
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nStartTime = 1517792400; // Feb 5th, 2018
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nTimeout = 1549328400; // Feb 5th, 2019
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nWindowSize = 100;
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nThreshold = 50; // 50% of 100

        // Deployment of DIP0003
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].bit = 3;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nStartTime = 1535752800; // Sep 1st, 2018
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nTimeout = 1567288800; // Sep 1st, 2019
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nWindowSize = 100;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nThreshold = 50; // 50% of 100

        // Deployment of DIP0008
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].bit = 4;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nStartTime = 1553126400; // Mar 21st, 2019
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nTimeout = 1900281600; // Mar 21st, 2030
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nWindowSize = 100;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nThreshold = 50; // 50% of 100

        // The best chain should have at least this much work.
        consensus.nMinimumChainWork = uint256S(""0x000000000000000000000000000000000000000000000000000000000000000"");

        // By default assume that the signatures in ancestors of this block are valid.
        consensus.defaultAssumeValid = uint256S(""0x000000000000000000000000000000000000000000000000000000000000000"");

        pchMessageStart[0] = 0xe2;
        pchMessageStart[1] = 0xca;
        pchMessageStart[2] = 0xff;
        pchMessageStart[3] = 0xce;
        nDefaultPort = 19799;
        nPruneAfterHeight = 1000;

        genesis = CreateGenesisBlock(1417713337, 1096447, 0x207fffff, 1, 50 * COIN);
        consensus.hashGenesisBlock = genesis.GetHash();
        assert(consensus.hashGenesisBlock == uint256S(""0x000008ca1832a4baf228eb1553c03d3a2c8e02399550dd6ea8d65cec3ef23d2e""));
        assert(genesis.hashMerkleRoot == uint256S(""0xe0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7""));

        devnetGenesis = FindDevNetGenesisBlock(genesis, 50 * COIN);
        consensus.hashDevnetGenesisBlock = devnetGenesis.GetHash();

        vFixedSeeds.clear();
        vSeeds.clear();
        //vSeeds.push_back(CDNSSeedData(""dashevo.org"",  ""devnet-seed.dashevo.org""));

        // Testnet StakeCubeCoin addresses start with 'y'
        base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,140);
        // Testnet StakeCubeCoin script addresses start with '8' or '9'
        base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,19);
        // Testnet private keys start with '9' or 'c' (Bitcoin defaults)
        base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,239);
        // Testnet StakeCubeCoin BIP32 pubkeys start with 'tpub' (Bitcoin defaults)
        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
        // Testnet StakeCubeCoin BIP32 prvkeys start with 'tprv' (Bitcoin defaults)
        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};

        // Testnet StakeCubeCoin BIP44 coin type is '1' (All coin's testnet default)
        nExtCoinType = 1;

        // long living quorum params
        consensus.llmqs[Consensus::LLMQ_DEVNET] = llmq_devnet;
        consensus.llmqs[Consensus::LLMQ_50_60] = llmq50_60;
        consensus.llmqs[Consensus::LLMQ_400_60] = llmq400_60;
        consensus.llmqs[Consensus::LLMQ_400_85] = llmq400_85;
        consensus.llmqTypeChainLocks = Consensus::LLMQ_50_60;
        consensus.llmqTypeInstantSend = Consensus::LLMQ_50_60;

        fDefaultConsistencyChecks = false;
        fRequireStandard = false;
        fRequireRoutableExternalIP = true;
        fMineBlocksOnDemand = false;
        fAllowMultipleAddressesFromGroup = true;
        fAllowMultiplePorts = true;
        nLLMQConnectionRetryTimeout = 60;

        nPoolMinParticipants = 3;
        nPoolNewMinParticipants = 2;
        nPoolMaxParticipants = 5;
        nPoolNewMaxParticipants = 20;
        nFulfilledRequestExpireTime = 5*60; // fulfilled requests expire in 5 minutes

        vSporkAddresses = {""yjPtiKh2uwk3bDutTEA2q9mCtXyiZRWn55""};
        nMinSporkKeys = 1;
        // devnets are started with no blocks and no MN, so we can't check for upgraded MN (as there are none)
        fBIP9CheckMasternodesUpgraded = false;

        checkpointData = (CCheckpointData) {
            {
                { 0, uint256S(""0x000008ca1832a4baf228eb1553c03d3a2c8e02399550dd6ea8d65cec3ef23d2e"")},
                { 1, devnetGenesis.GetHash() },
            }
        };

        chainTxData = ChainTxData{
            devnetGenesis.GetBlockTime(), // * UNIX timestamp of devnet genesis block
            2,                            // * we only have 2 coinbase transactions when a devnet is started up
            0.01                          // * estimated number of transactions per second
        };
    }
};

/**
 * Regression test
 */
class CRegTestParams : public CChainParams {
public:
    CRegTestParams() {
        strNetworkID = ""regtest"";
        consensus.nSubsidyHalvingInterval = 150;
        consensus.nMasternodePaymentsStartBlock = 240;
        consensus.nMasternodePaymentsIncreaseBlock = 350;
        consensus.nMasternodePaymentsIncreasePeriod = 10;
        consensus.nInstantSendConfirmationsRequired = 2;
        consensus.nInstantSendKeepLock = 6;
        consensus.nBudgetPaymentsStartBlock = 1000;
        consensus.nBudgetPaymentsCycleBlocks = 50;
        consensus.nBudgetPaymentsWindowBlocks = 10;
        consensus.nSuperblockStartBlock = 1500;
        consensus.nSuperblockStartHash = uint256(); // do not check this on regtest
        consensus.nSuperblockCycle = 10;
        consensus.nGovernanceMinQuorum = 1;
        consensus.nGovernanceFilterElements = 100;
        consensus.nMasternodeMinimumConfirmations = 1;
        consensus.BIP34Height = 100000000; // BIP34 has not activated on regtest (far in the future so block v1 are not rejected in tests)
        consensus.BIP34Hash = uint256();
        consensus.BIP65Height = 1351; // BIP65 activated on regtest (Used in rpc activation tests)
        consensus.BIP66Height = 1251; // BIP66 activated on regtest (Used in rpc activation tests)
        consensus.DIP0001Height = 2000;
        consensus.DIP0003Height = 432;
        consensus.DIP0003EnforcementHeight = 500;
        consensus.DIP0003EnforcementHash = uint256();
        consensus.powLimit = uint256S(""7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff""); // ~uint256(0) >> 1
        consensus.nPowTargetTimespan = 24 * 60 * 60; // 1 day
        consensus.nPowTargetSpacing = 2.5 * 60; // 2.5 minutes
        consensus.fPowAllowMinDifficultyBlocks = true;
        consensus.fPowNoRetargeting = true;
        consensus.nPowKGWHeight = 15200; // same as mainnet
        consensus.nPowDGWHeight = 34140; // same as mainnet
        consensus.nRuleChangeActivationThreshold = 108; // 75% for testchains
        consensus.nMinerConfirmationWindow = 144; // Faster than normal for regtest (144 instead of 2016)
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 0;
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = 999999999999ULL;
        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].bit = 0;
        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime = 0;
        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout = 999999999999ULL;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].bit = 1;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nStartTime = 0;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nTimeout = 999999999999ULL;
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].bit = 2;
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nStartTime = 0;
        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nTimeout = 999999999999ULL;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].bit = 3;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nStartTime = 0;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nTimeout = 999999999999ULL;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].bit = 4;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nStartTime = 0;
        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nTimeout = 999999999999ULL;

        // The best chain should have at least this much work.
        consensus.nMinimumChainWork = uint256S(""0x00"");

        // By default assume that the signatures in ancestors of this block are valid.
        consensus.defaultAssumeValid = uint256S(""0x00"");

        pchMessageStart[0] = 0xfc;
        pchMessageStart[1] = 0xc1;
        pchMessageStart[2] = 0xb7;
        pchMessageStart[3] = 0xdc;
        nDefaultPort = 19899;
        nPruneAfterHeight = 1000;

        genesis = CreateGenesisBlock(1417713337, 1096447, 0x207fffff, 1, 50 * COIN);
        consensus.hashGenesisBlock = genesis.GetHash();
        assert(consensus.hashGenesisBlock == uint256S(""0x000008ca1832a4baf228eb1553c03d3a2c8e02399550dd6ea8d65cec3ef23d2e""));
        assert(genesis.hashMerkleRoot == uint256S(""0xe0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7""));

        vFixedSeeds.clear(); //!< Regtest mode doesn't have any fixed seeds.
        vSeeds.clear();      //!< Regtest mode doesn't have any DNS seeds.

        fDefaultConsistencyChecks = true;
        fRequireStandard = false;
        fRequireRoutableExternalIP = false;
        fMineBlocksOnDemand = true;
        fAllowMultipleAddressesFromGroup = true;
        fAllowMultiplePorts = true;
        nLLMQConnectionRetryTimeout = 1; // must be lower then the LLMQ signing session timeout so that tests have control over failing behavior

        nFulfilledRequestExpireTime = 5*60; // fulfilled requests expire in 5 minutes
        nPoolMinParticipants = 2;
        nPoolNewMinParticipants = 2;
        nPoolMaxParticipants = 5;
        nPoolNewMaxParticipants = 20;

        // privKey: cP4EKFyJsHT39LDqgdcB43Y3YXjNyjb5Fuas1GQSeAtjnZWmZEQK
        vSporkAddresses = {""yj949n1UH6fDhw6HtVE5VMj2iSTaSWBMcW""};
        nMinSporkKeys = 1;
        // regtest usually has no masternodes in most tests, so don't check for upgraged MNs
        fBIP9CheckMasternodesUpgraded = false;

        checkpointData = {
            {
                {0, uint256S(""0x000008ca1832a4baf228eb1553c03d3a2c8e02399550dd6ea8d65cec3ef23d2e"")},
            }
        };

        chainTxData = ChainTxData{
            0,
            0,
            0
        };

        // Regtest StakeCubeCoin addresses start with 'y'
        base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,140);
        // Regtest StakeCubeCoin script addresses start with '8' or '9'
        base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,19);
        // Regtest private keys start with '9' or 'c' (Bitcoin defaults)
        base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,239);
        // Regtest StakeCubeCoin BIP32 pubkeys start with 'tpub' (Bitcoin defaults)
        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
        // Regtest StakeCubeCoin BIP32 prvkeys start with 'tprv' (Bitcoin defaults)
        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};

        // Regtest StakeCubeCoin BIP44 coin type is '1' (All coin's testnet default)
        nExtCoinType = 1;

        // long living quorum params
        consensus.llmqs[Consensus::LLMQ_TEST] = llmq_test;
        consensus.llmqs[Consensus::LLMQ_50_60] = llmq50_60;
        consensus.llmqTypeChainLocks = Consensus::LLMQ_TEST;
        consensus.llmqTypeInstantSend = Consensus::LLMQ_TEST;
    }
};

static std::unique_ptr<CChainParams> globalChainParams;

const CChainParams &Params() {
    assert(globalChainParams);
    return *globalChainParams;
}

std::unique_ptr<CChainParams> CreateChainParams(const std::string& chain)
{
    if (chain == CBaseChainParams::MAIN)
        return std::unique_ptr<CChainParams>(new CMainParams());
    else if (chain == CBaseChainParams::TESTNET)
        return std::unique_ptr<CChainParams>(new CTestNetParams());
    else if (chain == CBaseChainParams::DEVNET) {
        return std::unique_ptr<CChainParams>(new CDevNetParams());
    } else if (chain == CBaseChainParams::REGTEST)
        return std::unique_ptr<CChainParams>(new CRegTestParams());
    throw std::runtime_error(strprintf(""%s: Unknown chain %s."", __func__, chain));
}

void SelectParams(const std::string& network)
{
    SelectBaseParams(network);
    globalChainParams = CreateChainParams(network);
}

void UpdateVersionBitsParameters(Consensus::DeploymentPos d, int64_t nStartTime, int64_t nTimeout, int64_t nWindowSize, int64_t nThreshold)
{
    globalChainParams->UpdateVersionBitsParameters(d, nStartTime, nTimeout, nWindowSize, nThreshold);
}

void UpdateDIP3Parameters(int nActivationHeight, int nEnforcementHeight)
{
    globalChainParams->UpdateDIP3Parameters(nActivationHeight, nEnforcementHeight);
}

void UpdateBudgetParameters(int nMasternodePaymentsStartBlock, int nBudgetPaymentsStartBlock, int nSuperblockStartBlock)
{
    globalChainParams->UpdateBudgetParameters(nMasternodePaymentsStartBlock, nBudgetPaymentsStartBlock, nSuperblockStartBlock);
}

void UpdateDevnetSubsidyAndDiffParams(int nMinimumDifficultyBlocks, int nHighSubsidyBlocks, int nHighSubsidyFactor)
{
    globalChainParams->UpdateSubsidyAndDiffParams(nMinimumDifficultyBlocks, nHighSubsidyBlocks, nHighSubsidyFactor);
}

void UpdateDevnetLLMQChainLocks(Consensus::LLMQType llmqType)
{
    globalChainParams->UpdateLLMQChainLocks(llmqType);
}

void UpdateLLMQTestParams(int size, int threshold)
{
    globalChainParams->UpdateLLMQTestParams(size, threshold);
}

void UpdateLLMQDevnetParams(int size, int threshold)
{
    globalChainParams->UpdateLLMQDevnetParams(size, threshold);
}
",16259,True,3819.445028005507,median
"////
    AUTOGENERATED FILE - this file was generated via
    https://github.com/jboss-container-images/jboss-kie-modules/blob/master/tools/gen-template-doc/gen_template_docs.py.
    Changes to .adoc or HTML files may be overwritten! Please change the
    generator or the input template (https://github.com/jboss-container-images/jboss-kie-modules/tree/master/tools/gen-template-doc/*.in)
////
[id='rhdm710-authoring-ha-ref']
= rhdm710-authoring-ha.yaml template

Application template for a HA persistent authoring environment, for Red Hat Decision Manager 7.10 - Deprecated



== Parameters

Templates allow you to define parameters that take on a value. That value is then substituted wherever the parameter is referenced.
References can be defined in any text field in the objects list field. See the
https://access.redhat.com/documentation/en-us/openshift_container_platform/3.11/html-single/developer_guide/#dev-guide-templates[Openshift documentation] for more information.

|=======================================================================
|Variable name |Image Environment Variable |Description |Example value |Required

|`APPLICATION_NAME` | -- | The name for the application. | myapp | True
|`CREDENTIALS_SECRET` | -- | Secret containing the KIE_ADMIN_USER and KIE_ADMIN_PWD values. | rhpam-credentials | True
|`KIE_SERVER_CONTROLLER_TOKEN` | `KIE_SERVER_CONTROLLER_TOKEN` | KIE Server controller token for bearer authentication. (Sets the org.kie.server.controller.token system property) | -- | False
|`KIE_SERVER_BYPASS_AUTH_USER` | `KIE_SERVER_BYPASS_AUTH_USER` | Allows the KIE Server to bypass the authenticated user for task-related operations, for example, queries. (Sets the org.kie.server.bypass.auth.user system property) | false | False
|`KIE_SERVER_MODE` | `KIE_SERVER_MODE` | The KIE Server mode. Valid values are 'DEVELOPMENT' or 'PRODUCTION'. In production mode, you can not deploy SNAPSHOT versions of artifacts on the KIE Server and can not change the version of an artifact in an existing container. (Sets the org.kie.server.mode system property). | `DEVELOPMENT` | False
|`KIE_MBEANS` | `KIE_MBEANS` | KIE Server mbeans enabled/disabled. (Sets the kie.mbeans and kie.scanner.mbeans system properties) | enabled | False
|`DROOLS_SERVER_FILTER_CLASSES` | `DROOLS_SERVER_FILTER_CLASSES` | KIE Server class filtering. (Sets the org.drools.server.filter.classes system property) | true | False
|`PROMETHEUS_SERVER_EXT_DISABLED` | `PROMETHEUS_SERVER_EXT_DISABLED` | If set to false, the prometheus server extension will be enabled. (Sets the org.kie.prometheus.server.ext.disabled system property) | false | False
|`DECISION_CENTRAL_HOSTNAME_HTTP` | `HOSTNAME_HTTP` | Custom hostname for http service route for Decision Central.  Leave blank for default hostname, e.g.: insecure-<application-name>-rhdmcentr-<project>.<default-domain-suffix> | -- | False
|`DECISION_CENTRAL_HOSTNAME_HTTPS` | `HOSTNAME_HTTPS` | Custom hostname for https service route for Decision Central.  Leave blank for default hostname, e.g.: <application-name>-rhdmcentr-<project>.<default-domain-suffix> | -- | False
|`KIE_SERVER_HOSTNAME_HTTP` | `HOSTNAME_HTTP` | Custom hostname for http service route for KIE Server. Leave blank for default hostname, e.g.: insecure-<application-name>-kieserver-<project>.<default-domain-suffix> | -- | False
|`KIE_SERVER_HOSTNAME_HTTPS` | `HOSTNAME_HTTPS` | Custom hostname for https service route for KIE Server. Leave blank for default hostname, e.g.: <application-name>-kieserver-<project>.<default-domain-suffix> | -- | False
|`DECISION_CENTRAL_HTTPS_SECRET` | -- | The name of the secret containing the keystore file for Decision Central. | decisioncentral-app-secret | True
|`DECISION_CENTRAL_HTTPS_KEYSTORE` | `HTTPS_KEYSTORE` | The name of the keystore file within the secret for Decision Central. | keystore.jks | False
|`DECISION_CENTRAL_HTTPS_NAME` | `HTTPS_NAME` | The name associated with the server certificate for Decision Central. | jboss | False
|`DECISION_CENTRAL_HTTPS_PASSWORD` | `HTTPS_PASSWORD` | The password for the keystore and certificate for Decision Central. | mykeystorepass | False
|`KIE_SERVER_HTTPS_SECRET` | -- | The name of the secret containing the keystore file for KIE Server. | kieserver-app-secret | True
|`KIE_SERVER_HTTPS_KEYSTORE` | `HTTPS_KEYSTORE` | The name of the keystore file within the secret for KIE Server. | keystore.jks | False
|`KIE_SERVER_HTTPS_NAME` | `HTTPS_NAME` | The name associated with the server certificate for KIE Server. | jboss | False
|`KIE_SERVER_HTTPS_PASSWORD` | `HTTPS_PASSWORD` | The password for the keystore and certificate for KIE Server. | mykeystorepass | False
|`APPFORMER_JMS_BROKER_USER` | `APPFORMER_JMS_BROKER_USER` | The user name to connect to the JMS broker. | jmsBrokerUser | True
|`APPFORMER_JMS_BROKER_PASSWORD` | `APPFORMER_JMS_BROKER_PASSWORD` | The password to connect to the JMS broker. | -- | True
|`DATAGRID_IMAGE` | -- | DataGrid image. | registry.redhat.io/jboss-datagrid-7/datagrid73-openshift:1.6 | True
|`DATAGRID_CPU_LIMIT` | -- | DataGrid Container CPU limit. | 1000m | True
|`DATAGRID_MEMORY_LIMIT` | -- | DataGrid Container memory limit. | 2Gi | True
|`DATAGRID_VOLUME_CAPACITY` | -- | Size of the persistent storage for DataGrid's runtime data. | 1Gi | True
|`AMQ_BROKER_IMAGE` | -- | AMQ Broker Image | registry.redhat.io/amq7/amq-broker:7.8 | True
|`AMQ_ROLE` | -- | User role for standard broker user. | admin | True
|`AMQ_NAME` | -- | The name of the broker. | broker | True
|`AMQ_GLOBAL_MAX_SIZE` | -- | Specifies the maximum amount of memory that message data can consume. If no value is specified, half of the system's memory is allocated. | 10 gb | False
|`AMQ_VOLUME_CAPACITY` | -- | Size of persistent storage for AMQ broker volume. | 1Gi | True
|`AMQ_REPLICAS` | -- | Number of broker replicas for a cluster | 2 | True
|`DECISION_CENTRAL_CONTAINER_REPLICAS` | -- | Decision Central Container Replicas, defines how many Decision Central containers will be started. | 2 | True
|`KIE_SERVER_CONTAINER_REPLICAS` | -- | KIE Server Container Replicas, defines how many KIE Server containers will be started. | 2 | True
|`KIE_SERVER_CONTROLLER_OPENSHIFT_GLOBAL_DISCOVERY_ENABLED` | `KIE_SERVER_CONTROLLER_OPENSHIFT_GLOBAL_DISCOVERY_ENABLED` | If set to true, turns on KIE Server global discovery feature (Sets the org.kie.server.controller.openshift.global.discovery.enabled system property) | false | False
|`KIE_SERVER_CONTROLLER_OPENSHIFT_PREFER_KIESERVER_SERVICE` | `KIE_SERVER_CONTROLLER_OPENSHIFT_PREFER_KIESERVER_SERVICE` | If OpenShift integration of Business Central is turned on, setting this parameter to true enables connection to KIE Server via an OpenShift internal Service endpoint. (Sets the org.kie.server.controller.openshift.prefer.kieserver.service system property) | true | False
|`KIE_SERVER_CONTROLLER_TEMPLATE_CACHE_TTL` | `KIE_SERVER_CONTROLLER_TEMPLATE_CACHE_TTL` | KIE ServerTemplate Cache TTL in milliseconds. (Sets the org.kie.server.controller.template.cache.ttl system property) | 60000 | False
|`IMAGE_STREAM_NAMESPACE` | -- | Namespace in which the ImageStreams for Red Hat Decision Manager images are installed. These ImageStreams are normally installed in the openshift namespace. You need to modify this parameter only if you installed the ImageStreams in a different namespace/project. | openshift | True
|`DECISION_CENTRAL_IMAGE_STREAM_NAME` | -- | The name of the image stream to use for Decision Central. Default is ""rhdm-decisioncentral-rhel8"". | rhdm-decisioncentral-rhel8 | True
|`KIE_SERVER_IMAGE_STREAM_NAME` | -- | The name of the image stream to use for KIE Server. Default is ""rhdm-kieserver-rhel8"". | rhdm-kieserver-rhel8 | True
|`IMAGE_STREAM_TAG` | -- | A named pointer to an image in an image stream. Default is ""7.10.0"". | 7.10.0 | True
|`MAVEN_MIRROR_URL` | `MAVEN_MIRROR_URL` | Maven mirror that Decision Central and KIE Server must use. If you configure a mirror, this mirror must contain all artifacts that are required for building and deploying your services. | -- | False
|`MAVEN_MIRROR_OF` | `MAVEN_MIRROR_OF` | Maven mirror configuration for KIE Server. | external:*,!repo-rhdmcentr | False
|`MAVEN_REPO_ID` | `MAVEN_REPO_ID` | The id to use for the maven repository. If set, it can be excluded from the optionally configured mirror by adding it to MAVEN_MIRROR_OF. For example: external:*,!repo-rhdmcentr,!repo-custom. If MAVEN_MIRROR_URL is set but MAVEN_MIRROR_ID is not set, an id will be generated randomly, but won't be usable in MAVEN_MIRROR_OF. | repo-custom | False
|`MAVEN_REPO_URL` | `MAVEN_REPO_URL` | Fully qualified URL to a Maven repository or service. | \\http://nexus.nexus-project.svc.cluster.local:8081/nexus/content/groups/public/ | False
|`MAVEN_REPO_USERNAME` | `MAVEN_REPO_USERNAME` | User name for accessing the Maven repository, if required. | -- | False
|`MAVEN_REPO_PASSWORD` | `MAVEN_REPO_PASSWORD` | Password to access the Maven repository, if required. | -- | False
|`GIT_HOOKS_DIR` | `GIT_HOOKS_DIR` | The directory to use for git hooks, if required. | `/opt/kie/data/git/hooks` | False
|`DECISION_CENTRAL_VOLUME_CAPACITY` | -- | Size of the persistent storage for Decision Central's runtime data. | 1Gi | True
|`DECISION_CENTRAL_JAVA_MAX_MEM_RATIO` | `JAVA_MAX_MEM_RATIO` | Decision Central Container JVM max memory ratio. `-Xmx` is set to a ratio of the memory available on the container. The default is 80, which means the upper boundary is 80% of the available memory. To skip adding the `-Xmx` option, set this value to 0. | 80 | True
|`DECISION_CENTRAL_MEMORY_LIMIT` | -- | Decision Central Container memory limit. | 4Gi | True
|`DECISION_CENTRAL_CPU_LIMIT` | -- | Decision Central Container CPU limit. | 2 | True
|`DECISION_CENTRAL_MEMORY_REQUEST` | -- | Decision Central Container memory request. | 3Gi | True
|`DECISION_CENTRAL_CPU_REQUEST` | -- | Decision Central Container CPU request. | 1500m | True
|`KIE_SERVER_MEMORY_LIMIT` | -- | KIE Server Container memory limit. | 2Gi | True
|`KIE_SERVER_MEMORY_REQUEST` | -- | KIE Server Container memory Request. | 1.5Gi | True
|`KIE_SERVER_CPU_LIMIT` | -- | KIE Server Container CPU limit. | 1 | True
|`KIE_SERVER_CPU_REQUEST` | -- | KIE Server Container CPU Request. | 750m | True
|`SSO_URL` | `SSO_URL` | RH-SSO URL. | \\https://rh-sso.example.com/auth | False
|`SSO_REALM` | `SSO_REALM` | RH-SSO Realm name. | -- | False
|`DECISION_CENTRAL_SSO_CLIENT` | `SSO_CLIENT` | Decision Central RH-SSO Client name. | -- | False
|`DECISION_CENTRAL_SSO_SECRET` | `SSO_SECRET` | Decision Central RH-SSO Client Secret. | 252793ed-7118-4ca8-8dab-5622fa97d892 | False
|`KIE_SERVER_SSO_CLIENT` | `SSO_CLIENT` | KIE Server RH-SSO Client name. | -- | False
|`KIE_SERVER_SSO_SECRET` | `SSO_SECRET` | KIE Server RH-SSO Client Secret. | 252793ed-7118-4ca8-8dab-5622fa97d892 | False
|`SSO_USERNAME` | `SSO_USERNAME` | RH-SSO Realm admin user name used to create the Client if it doesn't exist. | -- | False
|`SSO_PASSWORD` | `SSO_PASSWORD` | RH-SSO Realm Admin Password used to create the Client. | -- | False
|`SSO_DISABLE_SSL_CERTIFICATE_VALIDATION` | `SSO_DISABLE_SSL_CERTIFICATE_VALIDATION` | RH-SSO Disable SSL Certificate Validation. | false | False
|`SSO_PRINCIPAL_ATTRIBUTE` | `SSO_PRINCIPAL_ATTRIBUTE` | RH-SSO Principal Attribute to use as user name. | preferred_username | False
|`AUTH_LDAP_URL` | `AUTH_LDAP_URL` | LDAP endpoint to connect for authentication. For failover, set two or more LDAP endpoints separated by space. | ldap://myldap.example.com:389 | False
|`AUTH_LDAP_BIND_DN` | `AUTH_LDAP_BIND_DN` | Bind DN used for authentication. | uid=admin,ou=users,ou=example,ou=com | False
|`AUTH_LDAP_BIND_CREDENTIAL` | `AUTH_LDAP_BIND_CREDENTIAL` | LDAP Credentials used for authentication. | Password | False
|`AUTH_LDAP_JAAS_SECURITY_DOMAIN` | `AUTH_LDAP_JAAS_SECURITY_DOMAIN` | The JMX ObjectName of the JaasSecurityDomain used to decrypt the password. | -- | False
|`AUTH_LDAP_LOGIN_MODULE` | `AUTH_LDAP_LOGIN_MODULE` | A flag to set login module to optional. The default value is required | optional | False
|`AUTH_LDAP_BASE_CTX_DN` | `AUTH_LDAP_BASE_CTX_DN` | LDAP Base DN of the top-level context to begin the user search. | ou=users,ou=example,ou=com | False
|`AUTH_LDAP_BASE_FILTER` | `AUTH_LDAP_BASE_FILTER` | LDAP search filter used to locate the context of the user to authenticate. The input username or userDN obtained from the login module callback is substituted into the filter anywhere a {0} expression is used. A common example for the search filter is (uid={0}). | (uid={0}) | False
|`AUTH_LDAP_SEARCH_SCOPE` | `AUTH_LDAP_SEARCH_SCOPE` | The search scope to use. | `SUBTREE_SCOPE` | False
|`AUTH_LDAP_SEARCH_TIME_LIMIT` | `AUTH_LDAP_SEARCH_TIME_LIMIT` | The timeout in milliseconds for user or role searches. | 10000 | False
|`AUTH_LDAP_DISTINGUISHED_NAME_ATTRIBUTE` | `AUTH_LDAP_DISTINGUISHED_NAME_ATTRIBUTE` | The name of the attribute in the user entry that contains the DN of the user. This may be necessary if the DN of the user itself contains special characters, backslash for example, that prevent correct user mapping. If the attribute does not exist, the entry's DN is used. | distinguishedName | False
|`AUTH_LDAP_PARSE_USERNAME` | `AUTH_LDAP_PARSE_USERNAME` | A flag indicating if the DN is to be parsed for the user name. If set to true, the DN is parsed for the user name. If set to false the DN is not parsed for the user name. This option is used together with usernameBeginString and usernameEndString. | true | False
|`AUTH_LDAP_USERNAME_BEGIN_STRING` | `AUTH_LDAP_USERNAME_BEGIN_STRING` | Defines the String which is to be removed from the start of the DN to reveal the user name. This option is used together with usernameEndString and only taken into account if parseUsername is set to true. | -- | False
|`AUTH_LDAP_USERNAME_END_STRING` | `AUTH_LDAP_USERNAME_END_STRING` | Defines the String which is to be removed from the end of the DN to reveal the user name. This option is used together with usernameEndString and only taken into account if parseUsername is set to true. | -- | False
|`AUTH_LDAP_ROLE_ATTRIBUTE_ID` | `AUTH_LDAP_ROLE_ATTRIBUTE_ID` | Name of the attribute containing the user roles. | memberOf | False
|`AUTH_LDAP_ROLES_CTX_DN` | `AUTH_LDAP_ROLES_CTX_DN` | The fixed DN of the context to search for user roles. This is not the DN where the actual roles are, but the DN where the objects containing the user roles are. For example, in a Microsoft Active Directory server, this is the DN where the user account is. | ou=groups,ou=example,ou=com | False
|`AUTH_LDAP_ROLE_FILTER` | `AUTH_LDAP_ROLE_FILTER` | A search filter used to locate the roles associated with the authenticated user. The input username or userDN obtained from the login module callback is substituted into the filter anywhere a {0} expression is used. The authenticated userDN is substituted into the filter anywhere a {1} is used. An example search filter that matches on the input username is (member={0}). An alternative that matches on the authenticated userDN is (member={1}). | (memberOf={1}) | False
|`AUTH_LDAP_ROLE_RECURSION` | `AUTH_LDAP_ROLE_RECURSION` | The number of levels of recursion the role search will go below a matching context. Disable recursion by setting this to 0. | 1 | False
|`AUTH_LDAP_DEFAULT_ROLE` | `AUTH_LDAP_DEFAULT_ROLE` | A role included for all authenticated users | user | False
|`AUTH_LDAP_ROLE_NAME_ATTRIBUTE_ID` | `AUTH_LDAP_ROLE_NAME_ATTRIBUTE_ID` | Name of the attribute within the roleCtxDN context which contains the role name. If the roleAttributeIsDN property is set to true, this property is used to find the role object's name attribute. | name | False
|`AUTH_LDAP_PARSE_ROLE_NAME_FROM_DN` | `AUTH_LDAP_PARSE_ROLE_NAME_FROM_DN` | A flag indicating if the DN returned by a query contains the roleNameAttributeID. If set to true, the DN is checked for the roleNameAttributeID. If set to false, the DN is not checked for the roleNameAttributeID. This flag can improve the performance of LDAP queries. | false | False
|`AUTH_LDAP_ROLE_ATTRIBUTE_IS_DN` | `AUTH_LDAP_ROLE_ATTRIBUTE_IS_DN` | Whether or not the roleAttributeID contains the fully-qualified DN of a role object. If false, the role name is taken from the value of the roleNameAttributeId attribute of the context name. Certain directory schemas, such as Microsoft Active Directory, require this attribute to be set to true. | false | False
|`AUTH_LDAP_REFERRAL_USER_ATTRIBUTE_ID_TO_CHECK` | `AUTH_LDAP_REFERRAL_USER_ATTRIBUTE_ID_TO_CHECK` | If you are not using referrals, you can ignore this option. When using referrals, this option denotes the attribute name which contains users defined for a certain role, for example member, if the role object is inside the referral. Users are checked against the content of this attribute name. If this option is not set, the check will always fail, so role objects cannot be stored in a referral tree. | -- | False
|`AUTH_ROLE_MAPPER_ROLES_PROPERTIES` | `AUTH_ROLE_MAPPER_ROLES_PROPERTIES` | When present, the RoleMapping Login Module will be configured to use the provided file. This parameter defines the fully-qualified file path and name of a properties file or resource which maps roles to replacement roles. The format is original_role=role1,role2,role3 | -- | False
|`AUTH_ROLE_MAPPER_REPLACE_ROLE` | `AUTH_ROLE_MAPPER_REPLACE_ROLE` | Whether to add to the current roles, or replace the current roles with the mapped ones. Replaces if set to true. | -- | False
|=======================================================================



== Objects

The CLI supports various object types. A list of these object types as well as their abbreviations
can be found in the https://access.redhat.com/documentation/en-us/openshift_container_platform/3.11/html/cli_reference/cli-reference-basic-cli-operations#object-types[Openshift documentation].


=== Services

A service is an abstraction which defines a logical set of pods and a policy by which to access them. See the
https://cloud.google.com/container-engine/docs/services/[container-engine documentation] for more information.

|=============
|Service        |Port  |Name | Description

.2+| `${APPLICATION_NAME}-rhdmcentr`
|8080 | http
.2+| All the Decision Central web server's ports.
|8443 | https
.1+| `${APPLICATION_NAME}-rhdmcentr-ping`
|8888 | ping
.1+| The JGroups ping port for rhdmcentr clustering.
.1+| `${APPLICATION_NAME}-datagrid-ping`
|8888 | ping
.1+| Provides a ping service for clustered applications.
.1+| `${APPLICATION_NAME}-datagrid`
|11222 | hotrod
.1+| Provides a service for accessing the application over Hot Rod protocol.
.2+| `${APPLICATION_NAME}-kieserver`
|8080 | http
.2+| All the KIE Server web server's ports.
|8443 | https
.1+| `${APPLICATION_NAME}-amq-tcp`
|61616 | --
.1+| The broker's OpenWire port.
.1+| `ping`
|8888 | --
.1+| The JGroups ping port for amq clustering.
|=============



=== Routes

A route is a way to expose a service by giving it an externally reachable hostname such as `www.example.com`. A defined route and the endpoints
identified by its service can be consumed by a router to provide named connectivity from external clients to your applications. Each route consists
of a route name, service selector, and (optionally) security configuration. See the
https://access.redhat.com/documentation/en-us/openshift_enterprise/3.2/html/architecture/core-concepts#architecture-core-concepts-routes[Openshift documentation] for more information.

|=============
| Service    | Security | Hostname

|insecure-${APPLICATION_NAME}-rhdmcentr-http | none | `${DECISION_CENTRAL_HOSTNAME_HTTP}`
|`${APPLICATION_NAME}-rhdmcentr-https` | TLS passthrough | `${DECISION_CENTRAL_HOSTNAME_HTTPS}`
|insecure-${APPLICATION_NAME}-kieserver-http | none | `${KIE_SERVER_HOSTNAME_HTTP}`
|`${APPLICATION_NAME}-kieserver-https` | TLS passthrough | `${KIE_SERVER_HOSTNAME_HTTPS}`
|=============




=== Deployment Configurations

A deployment in OpenShift is a replication controller based on a user-defined template called a deployment configuration. Deployments are created manually or in response to triggered events.
See the https://access.redhat.com/documentation/en-us/openshift_container_platform/3.11/html/developer_guide/deployments#dev-guide-how-deployments-work[Openshift documentation] for more information.


==== Triggers

A trigger drives the creation of new deployments in response to events, both inside and outside OpenShift. See the
https://access.redhat.com/documentation/en-us/openshift_container_platform/3.11/html/developer_guide/deployments#triggers[Openshift documentation] for more information.

|============
|Deployment | Triggers

|`${APPLICATION_NAME}-rhdmcentr` | ImageChange
|`${APPLICATION_NAME}-kieserver` | ImageChange
|============



==== Replicas

A replication controller ensures that a specified number of pod ""replicas"" are running at any one time.
If there are too many, the replication controller kills some pods. If there are too few, it starts more.
See the https://cloud.google.com/container-engine/docs/replicationcontrollers/[container-engine documentation]
for more information.

|============
|Deployment | Replicas

|`${APPLICATION_NAME}-rhdmcentr` | 2
|`${APPLICATION_NAME}-kieserver` | 2
|============


==== Pod Template


===== Service Accounts

Service accounts are API objects that exist within each project. They can be created or deleted like any other API object. See the
https://access.redhat.com/documentation/en-us/openshift_container_platform/3.11/html/developer_guide/dev-guide-service-accounts#dev-managing-service-accounts[Openshift documentation] for more
information.

|============
|Deployment | Service Account

|`${APPLICATION_NAME}-rhdmcentr` | `${APPLICATION_NAME}-rhdmsvc`
|`${APPLICATION_NAME}-kieserver` | `${APPLICATION_NAME}-rhdmsvc`
|============



===== Image

|============
|Deployment | Image

|`${APPLICATION_NAME}-rhdmcentr` | `${DECISION_CENTRAL_IMAGE_STREAM_NAME}`
|`${APPLICATION_NAME}-kieserver` | `${KIE_SERVER_IMAGE_STREAM_NAME}`
|============



===== Readiness Probe


.${APPLICATION_NAME}-rhdmcentr
----
Http Get on http://localhost:8080/rest/ready
----

.${APPLICATION_NAME}-kieserver
----
Http Get on http://localhost:8080/services/rest/server/readycheck
----




===== Liveness Probe


.${APPLICATION_NAME}-rhdmcentr
----
Http Get on http://localhost:8080/rest/healthy
----

.${APPLICATION_NAME}-kieserver
----
Http Get on http://localhost:8080/services/rest/server/healthcheck
----




===== Exposed Ports

|=============
|Deployments | Name  | Port  | Protocol

.4+| `${APPLICATION_NAME}-rhdmcentr`
|jolokia | 8778 | `TCP`
|http | 8080 | `TCP`
|https | 8443 | `TCP`
|ping | 8888 | `TCP`
.3+| `${APPLICATION_NAME}-kieserver`
|jolokia | 8778 | `TCP`
|http | 8080 | `TCP`
|https | 8443 | `TCP`
|=============



===== Image Environment Variables

|=======================================================================
|Deployment |Variable name |Description |Example value

.66+| `${APPLICATION_NAME}-rhdmcentr`
|`APPLICATION_USERS_PROPERTIES` | -- | `/opt/kie/data/configuration/application-users.properties`
|`APPLICATION_ROLES_PROPERTIES` | -- | `/opt/kie/data/configuration/application-roles.properties`
|`KIE_ADMIN_USER` | Admin user name | Set according to the credentials secret
|`KIE_ADMIN_PWD` | Admin user password | Set according to the credentials secret
|`KIE_MBEANS` | KIE Server mbeans enabled/disabled. (Sets the kie.mbeans and kie.scanner.mbeans system properties) | `${KIE_MBEANS}`
|`KIE_SERVER_CONTROLLER_OPENSHIFT_ENABLED` | -- | true
|`KIE_SERVER_CONTROLLER_OPENSHIFT_GLOBAL_DISCOVERY_ENABLED` | If set to true, turns on KIE Server global discovery feature (Sets the org.kie.server.controller.openshift.global.discovery.enabled system property) | `${KIE_SERVER_CONTROLLER_OPENSHIFT_GLOBAL_DISCOVERY_ENABLED}`
|`KIE_SERVER_CONTROLLER_OPENSHIFT_PREFER_KIESERVER_SERVICE` | If OpenShift integration of Business Central is turned on, setting this parameter to true enables connection to KIE Server via an OpenShift internal Service endpoint. (Sets the org.kie.server.controller.openshift.prefer.kieserver.service system property) | `${KIE_SERVER_CONTROLLER_OPENSHIFT_PREFER_KIESERVER_SERVICE}`
|`KIE_SERVER_CONTROLLER_TEMPLATE_CACHE_TTL` | KIE ServerTemplate Cache TTL in milliseconds. (Sets the org.kie.server.controller.template.cache.ttl system property) | `${KIE_SERVER_CONTROLLER_TEMPLATE_CACHE_TTL}`
|`KIE_SERVER_CONTROLLER_TOKEN` | KIE Server controller token for bearer authentication. (Sets the org.kie.server.controller.token system property) | `${KIE_SERVER_CONTROLLER_TOKEN}`
|`WORKBENCH_ROUTE_NAME` | -- | `${APPLICATION_NAME}-rhdmcentr`
|`MAVEN_MIRROR_URL` | Maven mirror that Decision Central and KIE Server must use. If you configure a mirror, this mirror must contain all artifacts that are required for building and deploying your services. | `${MAVEN_MIRROR_URL}`
|`MAVEN_REPO_ID` | The id to use for the maven repository. If set, it can be excluded from the optionally configured mirror by adding it to MAVEN_MIRROR_OF. For example: external:*,!repo-rhdmcentr,!repo-custom. If MAVEN_MIRROR_URL is set but MAVEN_MIRROR_ID is not set, an id will be generated randomly, but won't be usable in MAVEN_MIRROR_OF. | `${MAVEN_REPO_ID}`
|`MAVEN_REPO_URL` | Fully qualified URL to a Maven repository or service. | `${MAVEN_REPO_URL}`
|`MAVEN_REPO_USERNAME` | User name for accessing the Maven repository, if required. | `${MAVEN_REPO_USERNAME}`
|`MAVEN_REPO_PASSWORD` | Password to access the Maven repository, if required. | `${MAVEN_REPO_PASSWORD}`
|`GIT_HOOKS_DIR` | The directory to use for git hooks, if required. | `${GIT_HOOKS_DIR}`
|`HTTPS_KEYSTORE_DIR` | -- | `/etc/decisioncentral-secret-volume`
|`HTTPS_KEYSTORE` | The name of the keystore file within the secret for Decision Central. | `${DECISION_CENTRAL_HTTPS_KEYSTORE}`
|`HTTPS_NAME` | The name associated with the server certificate for Decision Central. | `${DECISION_CENTRAL_HTTPS_NAME}`
|`HTTPS_PASSWORD` | The password for the keystore and certificate for Decision Central. | `${DECISION_CENTRAL_HTTPS_PASSWORD}`
|`JGROUPS_PING_PROTOCOL` | -- | openshift.DNS_PING
|`OPENSHIFT_DNS_PING_SERVICE_NAME` | -- | `${APPLICATION_NAME}-rhdmcentr-ping`
|`OPENSHIFT_DNS_PING_SERVICE_PORT` | -- | 8888
|`APPFORMER_INFINISPAN_SERVICE_NAME` | -- | `${APPLICATION_NAME}-datagrid`
|`APPFORMER_INFINISPAN_PORT` | -- | 11222
|`APPFORMER_JMS_BROKER_ADDRESS` | -- | `${APPLICATION_NAME}-amq-tcp`
|`APPFORMER_JMS_BROKER_PORT` | -- | 61616
|`APPFORMER_JMS_BROKER_USER` | The user name to connect to the JMS broker. | `${APPFORMER_JMS_BROKER_USER}`
|`APPFORMER_JMS_BROKER_PASSWORD` | The password to connect to the JMS broker. | `${APPFORMER_JMS_BROKER_PASSWORD}`
|`JAVA_MAX_MEM_RATIO` | Decision Central Container JVM max memory ratio. `-Xmx` is set to a ratio of the memory available on the container. The default is 80, which means the upper boundary is 80% of the available memory. To skip adding the `-Xmx` option, set this value to 0. | `${DECISION_CENTRAL_JAVA_MAX_MEM_RATIO}`
|`SSO_URL` | RH-SSO URL. | `${SSO_URL}`
|`SSO_OPENIDCONNECT_DEPLOYMENTS` | -- | ROOT.war
|`SSO_REALM` | RH-SSO Realm name. | `${SSO_REALM}`
|`SSO_SECRET` | Decision Central RH-SSO Client Secret. | `${DECISION_CENTRAL_SSO_SECRET}`
|`SSO_CLIENT` | Decision Central RH-SSO Client name. | `${DECISION_CENTRAL_SSO_CLIENT}`
|`SSO_USERNAME` | RH-SSO Realm admin user name used to create the Client if it doesn't exist. | `${SSO_USERNAME}`
|`SSO_PASSWORD` | RH-SSO Realm Admin Password used to create the Client. | `${SSO_PASSWORD}`
|`SSO_DISABLE_SSL_CERTIFICATE_VALIDATION` | RH-SSO Disable SSL Certificate Validation. | `${SSO_DISABLE_SSL_CERTIFICATE_VALIDATION}`
|`SSO_PRINCIPAL_ATTRIBUTE` | RH-SSO Principal Attribute to use as user name. | `${SSO_PRINCIPAL_ATTRIBUTE}`
|`HOSTNAME_HTTP` | Custom hostname for http service route for Decision Central.  Leave blank for default hostname, e.g.: insecure-<application-name>-rhdmcentr-<project>.<default-domain-suffix> | `${DECISION_CENTRAL_HOSTNAME_HTTP}`
|`HOSTNAME_HTTPS` | Custom hostname for https service route for Decision Central.  Leave blank for default hostname, e.g.: <application-name>-rhdmcentr-<project>.<default-domain-suffix> | `${DECISION_CENTRAL_HOSTNAME_HTTPS}`
|`AUTH_LDAP_URL` | LDAP endpoint to connect for authentication. For failover, set two or more LDAP endpoints separated by space. | `${AUTH_LDAP_URL}`
|`AUTH_LDAP_BIND_DN` | Bind DN used for authentication. | `${AUTH_LDAP_BIND_DN}`
|`AUTH_LDAP_BIND_CREDENTIAL` | LDAP Credentials used for authentication. | `${AUTH_LDAP_BIND_CREDENTIAL}`
|`AUTH_LDAP_JAAS_SECURITY_DOMAIN` | The JMX ObjectName of the JaasSecurityDomain used to decrypt the password. | `${AUTH_LDAP_JAAS_SECURITY_DOMAIN}`
|`AUTH_LDAP_LOGIN_MODULE` | A flag to set login module to optional. The default value is required | `${AUTH_LDAP_LOGIN_MODULE}`
|`AUTH_LDAP_BASE_CTX_DN` | LDAP Base DN of the top-level context to begin the user search. | `${AUTH_LDAP_BASE_CTX_DN}`
|`AUTH_LDAP_BASE_FILTER` | LDAP search filter used to locate the context of the user to authenticate. The input username or userDN obtained from the login module callback is substituted into the filter anywhere a {0} expression is used. A common example for the search filter is (uid={0}). | `${AUTH_LDAP_BASE_FILTER}`
|`AUTH_LDAP_SEARCH_SCOPE` | The search scope to use. | `${AUTH_LDAP_SEARCH_SCOPE}`
|`AUTH_LDAP_SEARCH_TIME_LIMIT` | The timeout in milliseconds for user or role searches. | `${AUTH_LDAP_SEARCH_TIME_LIMIT}`
|`AUTH_LDAP_DISTINGUISHED_NAME_ATTRIBUTE` | The name of the attribute in the user entry that contains the DN of the user. This may be necessary if the DN of the user itself contains special characters, backslash for example, that prevent correct user mapping. If the attribute does not exist, the entry's DN is used. | `${AUTH_LDAP_DISTINGUISHED_NAME_ATTRIBUTE}`
|`AUTH_LDAP_PARSE_USERNAME` | A flag indicating if the DN is to be parsed for the user name. If set to true, the DN is parsed for the user name. If set to false the DN is not parsed for the user name. This option is used together with usernameBeginString and usernameEndString. | `${AUTH_LDAP_PARSE_USERNAME}`
|`AUTH_LDAP_USERNAME_BEGIN_STRING` | Defines the String which is to be removed from the start of the DN to reveal the user name. This option is used together with usernameEndString and only taken into account if parseUsername is set to true. | `${AUTH_LDAP_USERNAME_BEGIN_STRING}`
|`AUTH_LDAP_USERNAME_END_STRING` | Defines the String which is to be removed from the end of the DN to reveal the user name. This option is used together with usernameEndString and only taken into account if parseUsername is set to true. | `${AUTH_LDAP_USERNAME_END_STRING}`
|`AUTH_LDAP_ROLE_ATTRIBUTE_ID` | Name of the attribute containing the user roles. | `${AUTH_LDAP_ROLE_ATTRIBUTE_ID}`
|`AUTH_LDAP_ROLES_CTX_DN` | The fixed DN of the context to search for user roles. This is not the DN where the actual roles are, but the DN where the objects containing the user roles are. For example, in a Microsoft Active Directory server, this is the DN where the user account is. | `${AUTH_LDAP_ROLES_CTX_DN}`
|`AUTH_LDAP_ROLE_FILTER` | A search filter used to locate the roles associated with the authenticated user. The input username or userDN obtained from the login module callback is substituted into the filter anywhere a {0} expression is used. The authenticated userDN is substituted into the filter anywhere a {1} is used. An example search filter that matches on the input username is (member={0}). An alternative that matches on the authenticated userDN is (member={1}). | `${AUTH_LDAP_ROLE_FILTER}`
|`AUTH_LDAP_ROLE_RECURSION` | The number of levels of recursion the role search will go below a matching context. Disable recursion by setting this to 0. | `${AUTH_LDAP_ROLE_RECURSION}`
|`AUTH_LDAP_DEFAULT_ROLE` | A role included for all authenticated users | `${AUTH_LDAP_DEFAULT_ROLE}`
|`AUTH_LDAP_ROLE_NAME_ATTRIBUTE_ID` | Name of the attribute within the roleCtxDN context which contains the role name. If the roleAttributeIsDN property is set to true, this property is used to find the role object's name attribute. | `${AUTH_LDAP_ROLE_NAME_ATTRIBUTE_ID}`
|`AUTH_LDAP_PARSE_ROLE_NAME_FROM_DN` | A flag indicating if the DN returned by a query contains the roleNameAttributeID. If set to true, the DN is checked for the roleNameAttributeID. If set to false, the DN is not checked for the roleNameAttributeID. This flag can improve the performance of LDAP queries. | `${AUTH_LDAP_PARSE_ROLE_NAME_FROM_DN}`
|`AUTH_LDAP_ROLE_ATTRIBUTE_IS_DN` | Whether or not the roleAttributeID contains the fully-qualified DN of a role object. If false, the role name is taken from the value of the roleNameAttributeId attribute of the context name. Certain directory schemas, such as Microsoft Active Directory, require this attribute to be set to true. | `${AUTH_LDAP_ROLE_ATTRIBUTE_IS_DN}`
|`AUTH_LDAP_REFERRAL_USER_ATTRIBUTE_ID_TO_CHECK` | If you are not using referrals, you can ignore this option. When using referrals, this option denotes the attribute name which contains users defined for a certain role, for example member, if the role object is inside the referral. Users are checked against the content of this attribute name. If this option is not set, the check will always fail, so role objects cannot be stored in a referral tree. | `${AUTH_LDAP_REFERRAL_USER_ATTRIBUTE_ID_TO_CHECK}`
|`AUTH_ROLE_MAPPER_ROLES_PROPERTIES` | When present, the RoleMapping Login Module will be configured to use the provided file. This parameter defines the fully-qualified file path and name of a properties file or resource which maps roles to replacement roles. The format is original_role=role1,role2,role3 | `${AUTH_ROLE_MAPPER_ROLES_PROPERTIES}`
|`AUTH_ROLE_MAPPER_REPLACE_ROLE` | Whether to add to the current roles, or replace the current roles with the mapped ones. Replaces if set to true. | `${AUTH_ROLE_MAPPER_REPLACE_ROLE}`
.65+| `${APPLICATION_NAME}-kieserver`
|`WORKBENCH_SERVICE_NAME` | -- | `${APPLICATION_NAME}-rhdmcentr`
|`KIE_ADMIN_USER` | Admin user name | Set according to the credentials secret
|`KIE_ADMIN_PWD` | Admin user password | Set according to the credentials secret
|`KIE_SERVER_MODE` | The KIE Server mode. Valid values are 'DEVELOPMENT' or 'PRODUCTION'. In production mode, you can not deploy SNAPSHOT versions of artifacts on the KIE Server and can not change the version of an artifact in an existing container. (Sets the org.kie.server.mode system property). | `${KIE_SERVER_MODE}`
|`KIE_MBEANS` | KIE Server mbeans enabled/disabled. (Sets the kie.mbeans and kie.scanner.mbeans system properties) | `${KIE_MBEANS}`
|`DROOLS_SERVER_FILTER_CLASSES` | KIE Server class filtering. (Sets the org.drools.server.filter.classes system property) | `${DROOLS_SERVER_FILTER_CLASSES}`
|`PROMETHEUS_SERVER_EXT_DISABLED` | If set to false, the prometheus server extension will be enabled. (Sets the org.kie.prometheus.server.ext.disabled system property) | `${PROMETHEUS_SERVER_EXT_DISABLED}`
|`KIE_SERVER_BYPASS_AUTH_USER` | Allows the KIE Server to bypass the authenticated user for task-related operations, for example, queries. (Sets the org.kie.server.bypass.auth.user system property) | `${KIE_SERVER_BYPASS_AUTH_USER}`
|`KIE_SERVER_CONTROLLER_SERVICE` | -- | `${APPLICATION_NAME}-rhdmcentr`
|`KIE_SERVER_CONTROLLER_PROTOCOL` | -- | ws
|`KIE_SERVER_ID` | -- | --
|`KIE_SERVER_ROUTE_NAME` | -- | insecure-${APPLICATION_NAME}-kieserver
|`KIE_SERVER_STARTUP_STRATEGY` | -- | OpenShiftStartupStrategy
|`MAVEN_MIRROR_URL` | Maven mirror that Decision Central and KIE Server must use. If you configure a mirror, this mirror must contain all artifacts that are required for building and deploying your services. | `${MAVEN_MIRROR_URL}`
|`MAVEN_MIRROR_OF` | Maven mirror configuration for KIE Server. | `${MAVEN_MIRROR_OF}`
|`MAVEN_REPOS` | -- | RHDMCENTR,EXTERNAL
|`RHDMCENTR_MAVEN_REPO_ID` | -- | repo-rhdmcentr
|`RHDMCENTR_MAVEN_REPO_SERVICE` | -- | `${APPLICATION_NAME}-rhdmcentr`
|`RHDMCENTR_MAVEN_REPO_PATH` | -- | `/maven2/`
|`RHDMCENTR_MAVEN_REPO_USERNAME` | -- | Set according to the credentials secret
|`RHDMCENTR_MAVEN_REPO_PASSWORD` | -- | Set according to the credentials secret
|`EXTERNAL_MAVEN_REPO_ID` | The id to use for the maven repository. If set, it can be excluded from the optionally configured mirror by adding it to MAVEN_MIRROR_OF. For example: external:*,!repo-rhdmcentr,!repo-custom. If MAVEN_MIRROR_URL is set but MAVEN_MIRROR_ID is not set, an id will be generated randomly, but won't be usable in MAVEN_MIRROR_OF. | `${MAVEN_REPO_ID}`
|`EXTERNAL_MAVEN_REPO_URL` | Fully qualified URL to a Maven repository or service. | `${MAVEN_REPO_URL}`
|`EXTERNAL_MAVEN_REPO_USERNAME` | User name for accessing the Maven repository, if required. | `${MAVEN_REPO_USERNAME}`
|`EXTERNAL_MAVEN_REPO_PASSWORD` | Password to access the Maven repository, if required. | `${MAVEN_REPO_PASSWORD}`
|`HTTPS_KEYSTORE_DIR` | -- | `/etc/kieserver-secret-volume`
|`HTTPS_KEYSTORE` | The name of the keystore file within the secret for KIE Server. | `${KIE_SERVER_HTTPS_KEYSTORE}`
|`HTTPS_NAME` | The name associated with the server certificate for KIE Server. | `${KIE_SERVER_HTTPS_NAME}`
|`HTTPS_PASSWORD` | The password for the keystore and certificate for KIE Server. | `${KIE_SERVER_HTTPS_PASSWORD}`
|`KUBERNETES_NAMESPACE` | -- | --
|`SSO_URL` | RH-SSO URL. | `${SSO_URL}`
|`SSO_OPENIDCONNECT_DEPLOYMENTS` | -- | ROOT.war
|`SSO_REALM` | RH-SSO Realm name. | `${SSO_REALM}`
|`SSO_SECRET` | KIE Server RH-SSO Client Secret. | `${KIE_SERVER_SSO_SECRET}`
|`SSO_CLIENT` | KIE Server RH-SSO Client name. | `${KIE_SERVER_SSO_CLIENT}`
|`SSO_USERNAME` | RH-SSO Realm admin user name used to create the Client if it doesn't exist. | `${SSO_USERNAME}`
|`SSO_PASSWORD` | RH-SSO Realm Admin Password used to create the Client. | `${SSO_PASSWORD}`
|`SSO_DISABLE_SSL_CERTIFICATE_VALIDATION` | RH-SSO Disable SSL Certificate Validation. | `${SSO_DISABLE_SSL_CERTIFICATE_VALIDATION}`
|`SSO_PRINCIPAL_ATTRIBUTE` | RH-SSO Principal Attribute to use as user name. | `${SSO_PRINCIPAL_ATTRIBUTE}`
|`HOSTNAME_HTTP` | Custom hostname for http service route for KIE Server. Leave blank for default hostname, e.g.: insecure-<application-name>-kieserver-<project>.<default-domain-suffix> | `${KIE_SERVER_HOSTNAME_HTTP}`
|`HOSTNAME_HTTPS` | Custom hostname for https service route for KIE Server. Leave blank for default hostname, e.g.: <application-name>-kieserver-<project>.<default-domain-suffix> | `${KIE_SERVER_HOSTNAME_HTTPS}`
|`AUTH_LDAP_URL` | LDAP endpoint to connect for authentication. For failover, set two or more LDAP endpoints separated by space. | `${AUTH_LDAP_URL}`
|`AUTH_LDAP_BIND_DN` | Bind DN used for authentication. | `${AUTH_LDAP_BIND_DN}`
|`AUTH_LDAP_BIND_CREDENTIAL` | LDAP Credentials used for authentication. | `${AUTH_LDAP_BIND_CREDENTIAL}`
|`AUTH_LDAP_JAAS_SECURITY_DOMAIN` | The JMX ObjectName of the JaasSecurityDomain used to decrypt the password. | `${AUTH_LDAP_JAAS_SECURITY_DOMAIN}`
|`AUTH_LDAP_LOGIN_MODULE` | A flag to set login module to optional. The default value is required | `${AUTH_LDAP_LOGIN_MODULE}`
|`AUTH_LDAP_BASE_CTX_DN` | LDAP Base DN of the top-level context to begin the user search. | `${AUTH_LDAP_BASE_CTX_DN}`
|`AUTH_LDAP_BASE_FILTER` | LDAP search filter used to locate the context of the user to authenticate. The input username or userDN obtained from the login module callback is substituted into the filter anywhere a {0} expression is used. A common example for the search filter is (uid={0}). | `${AUTH_LDAP_BASE_FILTER}`
|`AUTH_LDAP_SEARCH_SCOPE` | The search scope to use. | `${AUTH_LDAP_SEARCH_SCOPE}`
|`AUTH_LDAP_SEARCH_TIME_LIMIT` | The timeout in milliseconds for user or role searches. | `${AUTH_LDAP_SEARCH_TIME_LIMIT}`
|`AUTH_LDAP_DISTINGUISHED_NAME_ATTRIBUTE` | The name of the attribute in the user entry that contains the DN of the user. This may be necessary if the DN of the user itself contains special characters, backslash for example, that prevent correct user mapping. If the attribute does not exist, the entry's DN is used. | `${AUTH_LDAP_DISTINGUISHED_NAME_ATTRIBUTE}`
|`AUTH_LDAP_PARSE_USERNAME` | A flag indicating if the DN is to be parsed for the user name. If set to true, the DN is parsed for the user name. If set to false the DN is not parsed for the user name. This option is used together with usernameBeginString and usernameEndString. | `${AUTH_LDAP_PARSE_USERNAME}`
|`AUTH_LDAP_USERNAME_BEGIN_STRING` | Defines the String which is to be removed from the start of the DN to reveal the user name. This option is used together with usernameEndString and only taken into account if parseUsername is set to true. | `${AUTH_LDAP_USERNAME_BEGIN_STRING}`
|`AUTH_LDAP_USERNAME_END_STRING` | Defines the String which is to be removed from the end of the DN to reveal the user name. This option is used together with usernameEndString and only taken into account if parseUsername is set to true. | `${AUTH_LDAP_USERNAME_END_STRING}`
|`AUTH_LDAP_ROLE_ATTRIBUTE_ID` | Name of the attribute containing the user roles. | `${AUTH_LDAP_ROLE_ATTRIBUTE_ID}`
|`AUTH_LDAP_ROLES_CTX_DN` | The fixed DN of the context to search for user roles. This is not the DN where the actual roles are, but the DN where the objects containing the user roles are. For example, in a Microsoft Active Directory server, this is the DN where the user account is. | `${AUTH_LDAP_ROLES_CTX_DN}`
|`AUTH_LDAP_ROLE_FILTER` | A search filter used to locate the roles associated with the authenticated user. The input username or userDN obtained from the login module callback is substituted into the filter anywhere a {0} expression is used. The authenticated userDN is substituted into the filter anywhere a {1} is used. An example search filter that matches on the input username is (member={0}). An alternative that matches on the authenticated userDN is (member={1}). | `${AUTH_LDAP_ROLE_FILTER}`
|`AUTH_LDAP_ROLE_RECURSION` | The number of levels of recursion the role search will go below a matching context. Disable recursion by setting this to 0. | `${AUTH_LDAP_ROLE_RECURSION}`
|`AUTH_LDAP_DEFAULT_ROLE` | A role included for all authenticated users | `${AUTH_LDAP_DEFAULT_ROLE}`
|`AUTH_LDAP_ROLE_NAME_ATTRIBUTE_ID` | Name of the attribute within the roleCtxDN context which contains the role name. If the roleAttributeIsDN property is set to true, this property is used to find the role object's name attribute. | `${AUTH_LDAP_ROLE_NAME_ATTRIBUTE_ID}`
|`AUTH_LDAP_PARSE_ROLE_NAME_FROM_DN` | A flag indicating if the DN returned by a query contains the roleNameAttributeID. If set to true, the DN is checked for the roleNameAttributeID. If set to false, the DN is not checked for the roleNameAttributeID. This flag can improve the performance of LDAP queries. | `${AUTH_LDAP_PARSE_ROLE_NAME_FROM_DN}`
|`AUTH_LDAP_ROLE_ATTRIBUTE_IS_DN` | Whether or not the roleAttributeID contains the fully-qualified DN of a role object. If false, the role name is taken from the value of the roleNameAttributeId attribute of the context name. Certain directory schemas, such as Microsoft Active Directory, require this attribute to be set to true. | `${AUTH_LDAP_ROLE_ATTRIBUTE_IS_DN}`
|`AUTH_LDAP_REFERRAL_USER_ATTRIBUTE_ID_TO_CHECK` | If you are not using referrals, you can ignore this option. When using referrals, this option denotes the attribute name which contains users defined for a certain role, for example member, if the role object is inside the referral. Users are checked against the content of this attribute name. If this option is not set, the check will always fail, so role objects cannot be stored in a referral tree. | `${AUTH_LDAP_REFERRAL_USER_ATTRIBUTE_ID_TO_CHECK}`
|`AUTH_ROLE_MAPPER_ROLES_PROPERTIES` | When present, the RoleMapping Login Module will be configured to use the provided file. This parameter defines the fully-qualified file path and name of a properties file or resource which maps roles to replacement roles. The format is original_role=role1,role2,role3 | `${AUTH_ROLE_MAPPER_ROLES_PROPERTIES}`
|`AUTH_ROLE_MAPPER_REPLACE_ROLE` | Whether to add to the current roles, or replace the current roles with the mapped ones. Replaces if set to true. | `${AUTH_ROLE_MAPPER_REPLACE_ROLE}`
|=======================================================================



=====  Volumes

|=============
|Deployment |Name  | mountPath | Purpose | readOnly

|`${APPLICATION_NAME}-rhdmcentr` | decisioncentral-keystore-volume | `/etc/decisioncentral-secret-volume` | ssl certs | True
|`${APPLICATION_NAME}-kieserver` | kieserver-keystore-volume | `/etc/kieserver-secret-volume` | ssl certs | True
|=============


=== External Dependencies


==== Volume Claims

A `PersistentVolume` object is a storage resource in an OpenShift cluster. Storage is provisioned by an administrator
by creating `PersistentVolume` objects from sources such as GCE Persistent Disks, AWS Elastic Block Stores (EBS), and NFS mounts.
See the https://access.redhat.com/documentation/en-us/openshift_container_platform/3.11/html/developer_guide/dev-guide-persistent-volumes[Openshift documentation] for
more information.

|=============
|Name | Access Mode

|`${APPLICATION_NAME}-rhdmcentr-claim` | ReadWriteMany
|=============



==== Secrets

This template requires the following secrets to be installed for the application to run.

 * decisioncentral-app-secret
 * kieserver-app-secret



[[clustering]]
==== Clustering

Clustering in OpenShift EAP is achieved through one of two discovery mechanisms:
Kubernetes or DNS. This is done by configuring the JGroups protocol stack in
standalone-openshift.xml with either the `<openshift.KUBE_PING/>` or `<openshift.DNS_PING/>`
elements. The templates are configured to use `DNS_PING`, however `KUBE_PING`is
the default used by the image.

The discovery mechanism used is specified by the `JGROUPS_PING_PROTOCOL` environment
variable which can be set to either `openshift.DNS_PING` or `openshift.KUBE_PING`.
`openshift.KUBE_PING` is the default used by the image if no value is specified
for `JGROUPS_PING_PROTOCOL`.

For DNS_PING to work, the following steps must be taken:

. The `OPENSHIFT_DNS_PING_SERVICE_NAME` environment variable must be set to the
  name of the ping service for the cluster (see table above).  If not set, the
  server will act as if it is a single-node cluster (a ""cluster of one"").
. The `OPENSHIFT_DNS_PING_SERVICE_PORT` environment variables should be set to
  the port number on which the ping service is exposed (see table above).  The
  `DNS_PING` protocol will attempt to discern the port from the SRV records, if
  it can, otherwise it will default to 8888.
. A ping service which exposes the ping port must be defined.  This service
  should be ""headless"" (ClusterIP=None) and must have the following:
.. The port must be named for port discovery to work.
.. It must be annotated with `service.alpha.kubernetes.io/tolerate-unready-endpoints`
   set to `""true""`.  Omitting this annotation will result in each node forming
   their own ""cluster of one"" during startup, then merging their cluster into
   the other nodes' clusters after startup (as the other nodes are not detected
   until after they have started).

.Example ping service for use with DNS_PING
[source,yaml]
----
kind: Service
apiVersion: v1
spec:
    clusterIP: None
    ports:
    - name: ping
      port: 8888
    selector:
        deploymentConfig: eap-app
metadata:
    name: eap-app-ping
    annotations:
        service.alpha.kubernetes.io/tolerate-unready-endpoints: ""true""
        description: ""The JGroups ping port for clustering.""
----

For `KUBE_PING` to work, the following steps must be taken:

. The `OPENSHIFT_KUBE_PING_NAMESPACE` environment variable must be set (see table above).
  If not set, the server will act as if it is a single-node cluster (a ""cluster of one"").
. The `OPENSHIFT_KUBE_PING_LABELS` environment variables should be set (see table above).
  If not set, pods outside of your application (albeit in your namespace) will try to join.
. Authorization must be granted to the service account the pod is running under to be
  allowed to access Kubernetes' REST api. This is done on the command line.

.Policy commands
====
Using the default service account in the myproject namespace:
....
oc policy add-role-to-user view system:serviceaccount:myproject:default -n myproject
....
Using the eap-service-account in the myproject namespace:
....
oc policy add-role-to-user view system:serviceaccount:myproject:eap-service-account -n myproject
....
====


",12332,True,2673.0300580740136,median
"// Generated by using Rcpp::compileAttributes() -> do not edit by hand
// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393

#include <Rcpp.h>

using namespace Rcpp;

#ifdef RCPP_USE_GLOBAL_ROSTREAM
Rcpp::Rostream<true>&  Rcpp::Rcout = Rcpp::Rcpp_cout_get();
Rcpp::Rostream<false>& Rcpp::Rcerr = Rcpp::Rcpp_cerr_get();
#endif

// deserialize_IsoForest
SEXP deserialize_IsoForest(Rcpp::RawVector src);
RcppExport SEXP _isotree_deserialize_IsoForest(SEXP srcSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< Rcpp::RawVector >::type src(srcSEXP);
    rcpp_result_gen = Rcpp::wrap(deserialize_IsoForest(src));
    return rcpp_result_gen;
END_RCPP
}
// deserialize_ExtIsoForest
SEXP deserialize_ExtIsoForest(Rcpp::RawVector src);
RcppExport SEXP _isotree_deserialize_ExtIsoForest(SEXP srcSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< Rcpp::RawVector >::type src(srcSEXP);
    rcpp_result_gen = Rcpp::wrap(deserialize_ExtIsoForest(src));
    return rcpp_result_gen;
END_RCPP
}
// deserialize_Imputer
SEXP deserialize_Imputer(Rcpp::RawVector src);
RcppExport SEXP _isotree_deserialize_Imputer(SEXP srcSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< Rcpp::RawVector >::type src(srcSEXP);
    rcpp_result_gen = Rcpp::wrap(deserialize_Imputer(src));
    return rcpp_result_gen;
END_RCPP
}
// deserialize_Indexer
SEXP deserialize_Indexer(Rcpp::RawVector src);
RcppExport SEXP _isotree_deserialize_Indexer(SEXP srcSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< Rcpp::RawVector >::type src(srcSEXP);
    rcpp_result_gen = Rcpp::wrap(deserialize_Indexer(src));
    return rcpp_result_gen;
END_RCPP
}
// check_null_ptr_model
Rcpp::LogicalVector check_null_ptr_model(SEXP ptr_model);
RcppExport SEXP _isotree_check_null_ptr_model(SEXP ptr_modelSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< SEXP >::type ptr_model(ptr_modelSEXP);
    rcpp_result_gen = Rcpp::wrap(check_null_ptr_model(ptr_model));
    return rcpp_result_gen;
END_RCPP
}
// fit_model
Rcpp::List fit_model(Rcpp::NumericVector X_num, Rcpp::IntegerVector X_cat, Rcpp::IntegerVector ncat, Rcpp::NumericVector Xc, Rcpp::IntegerVector Xc_ind, Rcpp::IntegerVector Xc_indptr, Rcpp::NumericVector sample_weights, Rcpp::NumericVector col_weights, size_t nrows, size_t ncols_numeric, size_t ncols_categ, size_t ndim, size_t ntry, Rcpp::CharacterVector coef_type, bool coef_by_prop, bool with_replacement, bool weight_as_sample, size_t sample_size, size_t ntrees, size_t max_depth, size_t ncols_per_tree, bool limit_depth, bool penalize_range, bool standardize_data, Rcpp::CharacterVector scoring_metric, bool fast_bratio, bool calc_dist, bool standardize_dist, bool sq_dist, bool calc_depth, bool standardize_depth, bool weigh_by_kurt, double prob_pick_by_gain_pl, double prob_pick_by_gain_avg, double prob_pick_col_by_range, double prob_pick_col_by_var, double prob_pick_col_by_kurt, double min_gain, Rcpp::CharacterVector cat_split_type, Rcpp::CharacterVector new_cat_action, Rcpp::CharacterVector missing_action, bool all_perm, bool build_imputer, bool output_imputations, size_t min_imp_obs, Rcpp::CharacterVector depth_imp, Rcpp::CharacterVector weigh_imp_rows, int random_seed, int nthreads);
RcppExport SEXP _isotree_fit_model(SEXP X_numSEXP, SEXP X_catSEXP, SEXP ncatSEXP, SEXP XcSEXP, SEXP Xc_indSEXP, SEXP Xc_indptrSEXP, SEXP sample_weightsSEXP, SEXP col_weightsSEXP, SEXP nrowsSEXP, SEXP ncols_numericSEXP, SEXP ncols_categSEXP, SEXP ndimSEXP, SEXP ntrySEXP, SEXP coef_typeSEXP, SEXP coef_by_propSEXP, SEXP with_replacementSEXP, SEXP weight_as_sampleSEXP, SEXP sample_sizeSEXP, SEXP ntreesSEXP, SEXP max_depthSEXP, SEXP ncols_per_treeSEXP, SEXP limit_depthSEXP, SEXP penalize_rangeSEXP, SEXP standardize_dataSEXP, SEXP scoring_metricSEXP, SEXP fast_bratioSEXP, SEXP calc_distSEXP, SEXP standardize_distSEXP, SEXP sq_distSEXP, SEXP calc_depthSEXP, SEXP standardize_depthSEXP, SEXP weigh_by_kurtSEXP, SEXP prob_pick_by_gain_plSEXP, SEXP prob_pick_by_gain_avgSEXP, SEXP prob_pick_col_by_rangeSEXP, SEXP prob_pick_col_by_varSEXP, SEXP prob_pick_col_by_kurtSEXP, SEXP min_gainSEXP, SEXP cat_split_typeSEXP, SEXP new_cat_actionSEXP, SEXP missing_actionSEXP, SEXP all_permSEXP, SEXP build_imputerSEXP, SEXP output_imputationsSEXP, SEXP min_imp_obsSEXP, SEXP depth_impSEXP, SEXP weigh_imp_rowsSEXP, SEXP random_seedSEXP, SEXP nthreadsSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type X_num(X_numSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type X_cat(X_catSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type ncat(ncatSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type Xc(XcSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_ind(Xc_indSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_indptr(Xc_indptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type sample_weights(sample_weightsSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type col_weights(col_weightsSEXP);
    Rcpp::traits::input_parameter< size_t >::type nrows(nrowsSEXP);
    Rcpp::traits::input_parameter< size_t >::type ncols_numeric(ncols_numericSEXP);
    Rcpp::traits::input_parameter< size_t >::type ncols_categ(ncols_categSEXP);
    Rcpp::traits::input_parameter< size_t >::type ndim(ndimSEXP);
    Rcpp::traits::input_parameter< size_t >::type ntry(ntrySEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type coef_type(coef_typeSEXP);
    Rcpp::traits::input_parameter< bool >::type coef_by_prop(coef_by_propSEXP);
    Rcpp::traits::input_parameter< bool >::type with_replacement(with_replacementSEXP);
    Rcpp::traits::input_parameter< bool >::type weight_as_sample(weight_as_sampleSEXP);
    Rcpp::traits::input_parameter< size_t >::type sample_size(sample_sizeSEXP);
    Rcpp::traits::input_parameter< size_t >::type ntrees(ntreesSEXP);
    Rcpp::traits::input_parameter< size_t >::type max_depth(max_depthSEXP);
    Rcpp::traits::input_parameter< size_t >::type ncols_per_tree(ncols_per_treeSEXP);
    Rcpp::traits::input_parameter< bool >::type limit_depth(limit_depthSEXP);
    Rcpp::traits::input_parameter< bool >::type penalize_range(penalize_rangeSEXP);
    Rcpp::traits::input_parameter< bool >::type standardize_data(standardize_dataSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type scoring_metric(scoring_metricSEXP);
    Rcpp::traits::input_parameter< bool >::type fast_bratio(fast_bratioSEXP);
    Rcpp::traits::input_parameter< bool >::type calc_dist(calc_distSEXP);
    Rcpp::traits::input_parameter< bool >::type standardize_dist(standardize_distSEXP);
    Rcpp::traits::input_parameter< bool >::type sq_dist(sq_distSEXP);
    Rcpp::traits::input_parameter< bool >::type calc_depth(calc_depthSEXP);
    Rcpp::traits::input_parameter< bool >::type standardize_depth(standardize_depthSEXP);
    Rcpp::traits::input_parameter< bool >::type weigh_by_kurt(weigh_by_kurtSEXP);
    Rcpp::traits::input_parameter< double >::type prob_pick_by_gain_pl(prob_pick_by_gain_plSEXP);
    Rcpp::traits::input_parameter< double >::type prob_pick_by_gain_avg(prob_pick_by_gain_avgSEXP);
    Rcpp::traits::input_parameter< double >::type prob_pick_col_by_range(prob_pick_col_by_rangeSEXP);
    Rcpp::traits::input_parameter< double >::type prob_pick_col_by_var(prob_pick_col_by_varSEXP);
    Rcpp::traits::input_parameter< double >::type prob_pick_col_by_kurt(prob_pick_col_by_kurtSEXP);
    Rcpp::traits::input_parameter< double >::type min_gain(min_gainSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type cat_split_type(cat_split_typeSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type new_cat_action(new_cat_actionSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type missing_action(missing_actionSEXP);
    Rcpp::traits::input_parameter< bool >::type all_perm(all_permSEXP);
    Rcpp::traits::input_parameter< bool >::type build_imputer(build_imputerSEXP);
    Rcpp::traits::input_parameter< bool >::type output_imputations(output_imputationsSEXP);
    Rcpp::traits::input_parameter< size_t >::type min_imp_obs(min_imp_obsSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type depth_imp(depth_impSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type weigh_imp_rows(weigh_imp_rowsSEXP);
    Rcpp::traits::input_parameter< int >::type random_seed(random_seedSEXP);
    Rcpp::traits::input_parameter< int >::type nthreads(nthreadsSEXP);
    rcpp_result_gen = Rcpp::wrap(fit_model(X_num, X_cat, ncat, Xc, Xc_ind, Xc_indptr, sample_weights, col_weights, nrows, ncols_numeric, ncols_categ, ndim, ntry, coef_type, coef_by_prop, with_replacement, weight_as_sample, sample_size, ntrees, max_depth, ncols_per_tree, limit_depth, penalize_range, standardize_data, scoring_metric, fast_bratio, calc_dist, standardize_dist, sq_dist, calc_depth, standardize_depth, weigh_by_kurt, prob_pick_by_gain_pl, prob_pick_by_gain_avg, prob_pick_col_by_range, prob_pick_col_by_var, prob_pick_col_by_kurt, min_gain, cat_split_type, new_cat_action, missing_action, all_perm, build_imputer, output_imputations, min_imp_obs, depth_imp, weigh_imp_rows, random_seed, nthreads));
    return rcpp_result_gen;
END_RCPP
}
// fit_tree
void fit_tree(SEXP model_R_ptr, Rcpp::RawVector serialized_obj, Rcpp::RawVector serialized_imputer, SEXP indexer_R_ptr, Rcpp::RawVector serialized_indexer, Rcpp::NumericVector X_num, Rcpp::IntegerVector X_cat, Rcpp::IntegerVector ncat, Rcpp::NumericVector Xc, Rcpp::IntegerVector Xc_ind, Rcpp::IntegerVector Xc_indptr, Rcpp::NumericVector sample_weights, Rcpp::NumericVector col_weights, size_t nrows, size_t ncols_numeric, size_t ncols_categ, size_t ndim, size_t ntry, Rcpp::CharacterVector coef_type, bool coef_by_prop, size_t max_depth, size_t ncols_per_tree, bool limit_depth, bool penalize_range, bool standardize_data, bool fast_bratio, bool weigh_by_kurt, double prob_pick_by_gain_pl, double prob_pick_by_gain_avg, double prob_pick_col_by_range, double prob_pick_col_by_var, double prob_pick_col_by_kurt, double min_gain, Rcpp::CharacterVector cat_split_type, Rcpp::CharacterVector new_cat_action, Rcpp::CharacterVector missing_action, bool build_imputer, size_t min_imp_obs, SEXP imp_R_ptr, Rcpp::CharacterVector depth_imp, Rcpp::CharacterVector weigh_imp_rows, bool all_perm, Rcpp::NumericVector ref_X_num, Rcpp::IntegerVector ref_X_cat, Rcpp::NumericVector ref_Xc, Rcpp::IntegerVector ref_Xc_ind, Rcpp::IntegerVector ref_Xc_indptr, uint64_t random_seed, Rcpp::List& model_cpp_obj_update, Rcpp::List& model_params_update);
RcppExport SEXP _isotree_fit_tree(SEXP model_R_ptrSEXP, SEXP serialized_objSEXP, SEXP serialized_imputerSEXP, SEXP indexer_R_ptrSEXP, SEXP serialized_indexerSEXP, SEXP X_numSEXP, SEXP X_catSEXP, SEXP ncatSEXP, SEXP XcSEXP, SEXP Xc_indSEXP, SEXP Xc_indptrSEXP, SEXP sample_weightsSEXP, SEXP col_weightsSEXP, SEXP nrowsSEXP, SEXP ncols_numericSEXP, SEXP ncols_categSEXP, SEXP ndimSEXP, SEXP ntrySEXP, SEXP coef_typeSEXP, SEXP coef_by_propSEXP, SEXP max_depthSEXP, SEXP ncols_per_treeSEXP, SEXP limit_depthSEXP, SEXP penalize_rangeSEXP, SEXP standardize_dataSEXP, SEXP fast_bratioSEXP, SEXP weigh_by_kurtSEXP, SEXP prob_pick_by_gain_plSEXP, SEXP prob_pick_by_gain_avgSEXP, SEXP prob_pick_col_by_rangeSEXP, SEXP prob_pick_col_by_varSEXP, SEXP prob_pick_col_by_kurtSEXP, SEXP min_gainSEXP, SEXP cat_split_typeSEXP, SEXP new_cat_actionSEXP, SEXP missing_actionSEXP, SEXP build_imputerSEXP, SEXP min_imp_obsSEXP, SEXP imp_R_ptrSEXP, SEXP depth_impSEXP, SEXP weigh_imp_rowsSEXP, SEXP all_permSEXP, SEXP ref_X_numSEXP, SEXP ref_X_catSEXP, SEXP ref_XcSEXP, SEXP ref_Xc_indSEXP, SEXP ref_Xc_indptrSEXP, SEXP random_seedSEXP, SEXP model_cpp_obj_updateSEXP, SEXP model_params_updateSEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< SEXP >::type model_R_ptr(model_R_ptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::RawVector >::type serialized_obj(serialized_objSEXP);
    Rcpp::traits::input_parameter< Rcpp::RawVector >::type serialized_imputer(serialized_imputerSEXP);
    Rcpp::traits::input_parameter< SEXP >::type indexer_R_ptr(indexer_R_ptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::RawVector >::type serialized_indexer(serialized_indexerSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type X_num(X_numSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type X_cat(X_catSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type ncat(ncatSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type Xc(XcSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_ind(Xc_indSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_indptr(Xc_indptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type sample_weights(sample_weightsSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type col_weights(col_weightsSEXP);
    Rcpp::traits::input_parameter< size_t >::type nrows(nrowsSEXP);
    Rcpp::traits::input_parameter< size_t >::type ncols_numeric(ncols_numericSEXP);
    Rcpp::traits::input_parameter< size_t >::type ncols_categ(ncols_categSEXP);
    Rcpp::traits::input_parameter< size_t >::type ndim(ndimSEXP);
    Rcpp::traits::input_parameter< size_t >::type ntry(ntrySEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type coef_type(coef_typeSEXP);
    Rcpp::traits::input_parameter< bool >::type coef_by_prop(coef_by_propSEXP);
    Rcpp::traits::input_parameter< size_t >::type max_depth(max_depthSEXP);
    Rcpp::traits::input_parameter< size_t >::type ncols_per_tree(ncols_per_treeSEXP);
    Rcpp::traits::input_parameter< bool >::type limit_depth(limit_depthSEXP);
    Rcpp::traits::input_parameter< bool >::type penalize_range(penalize_rangeSEXP);
    Rcpp::traits::input_parameter< bool >::type standardize_data(standardize_dataSEXP);
    Rcpp::traits::input_parameter< bool >::type fast_bratio(fast_bratioSEXP);
    Rcpp::traits::input_parameter< bool >::type weigh_by_kurt(weigh_by_kurtSEXP);
    Rcpp::traits::input_parameter< double >::type prob_pick_by_gain_pl(prob_pick_by_gain_plSEXP);
    Rcpp::traits::input_parameter< double >::type prob_pick_by_gain_avg(prob_pick_by_gain_avgSEXP);
    Rcpp::traits::input_parameter< double >::type prob_pick_col_by_range(prob_pick_col_by_rangeSEXP);
    Rcpp::traits::input_parameter< double >::type prob_pick_col_by_var(prob_pick_col_by_varSEXP);
    Rcpp::traits::input_parameter< double >::type prob_pick_col_by_kurt(prob_pick_col_by_kurtSEXP);
    Rcpp::traits::input_parameter< double >::type min_gain(min_gainSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type cat_split_type(cat_split_typeSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type new_cat_action(new_cat_actionSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type missing_action(missing_actionSEXP);
    Rcpp::traits::input_parameter< bool >::type build_imputer(build_imputerSEXP);
    Rcpp::traits::input_parameter< size_t >::type min_imp_obs(min_imp_obsSEXP);
    Rcpp::traits::input_parameter< SEXP >::type imp_R_ptr(imp_R_ptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type depth_imp(depth_impSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type weigh_imp_rows(weigh_imp_rowsSEXP);
    Rcpp::traits::input_parameter< bool >::type all_perm(all_permSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type ref_X_num(ref_X_numSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type ref_X_cat(ref_X_catSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type ref_Xc(ref_XcSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type ref_Xc_ind(ref_Xc_indSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type ref_Xc_indptr(ref_Xc_indptrSEXP);
    Rcpp::traits::input_parameter< uint64_t >::type random_seed(random_seedSEXP);
    Rcpp::traits::input_parameter< Rcpp::List& >::type model_cpp_obj_update(model_cpp_obj_updateSEXP);
    Rcpp::traits::input_parameter< Rcpp::List& >::type model_params_update(model_params_updateSEXP);
    fit_tree(model_R_ptr, serialized_obj, serialized_imputer, indexer_R_ptr, serialized_indexer, X_num, X_cat, ncat, Xc, Xc_ind, Xc_indptr, sample_weights, col_weights, nrows, ncols_numeric, ncols_categ, ndim, ntry, coef_type, coef_by_prop, max_depth, ncols_per_tree, limit_depth, penalize_range, standardize_data, fast_bratio, weigh_by_kurt, prob_pick_by_gain_pl, prob_pick_by_gain_avg, prob_pick_col_by_range, prob_pick_col_by_var, prob_pick_col_by_kurt, min_gain, cat_split_type, new_cat_action, missing_action, build_imputer, min_imp_obs, imp_R_ptr, depth_imp, weigh_imp_rows, all_perm, ref_X_num, ref_X_cat, ref_Xc, ref_Xc_ind, ref_Xc_indptr, random_seed, model_cpp_obj_update, model_params_update);
    return R_NilValue;
END_RCPP
}
// predict_iso
void predict_iso(SEXP model_R_ptr, bool is_extended, SEXP indexer_R_ptr, Rcpp::NumericVector outp, Rcpp::IntegerMatrix tree_num, Rcpp::NumericMatrix tree_depths, Rcpp::NumericVector X_num, Rcpp::IntegerVector X_cat, Rcpp::NumericVector Xc, Rcpp::IntegerVector Xc_ind, Rcpp::IntegerVector Xc_indptr, Rcpp::NumericVector Xr, Rcpp::IntegerVector Xr_ind, Rcpp::IntegerVector Xr_indptr, size_t nrows, int nthreads, bool standardize);
RcppExport SEXP _isotree_predict_iso(SEXP model_R_ptrSEXP, SEXP is_extendedSEXP, SEXP indexer_R_ptrSEXP, SEXP outpSEXP, SEXP tree_numSEXP, SEXP tree_depthsSEXP, SEXP X_numSEXP, SEXP X_catSEXP, SEXP XcSEXP, SEXP Xc_indSEXP, SEXP Xc_indptrSEXP, SEXP XrSEXP, SEXP Xr_indSEXP, SEXP Xr_indptrSEXP, SEXP nrowsSEXP, SEXP nthreadsSEXP, SEXP standardizeSEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< SEXP >::type model_R_ptr(model_R_ptrSEXP);
    Rcpp::traits::input_parameter< bool >::type is_extended(is_extendedSEXP);
    Rcpp::traits::input_parameter< SEXP >::type indexer_R_ptr(indexer_R_ptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type outp(outpSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerMatrix >::type tree_num(tree_numSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericMatrix >::type tree_depths(tree_depthsSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type X_num(X_numSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type X_cat(X_catSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type Xc(XcSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_ind(Xc_indSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_indptr(Xc_indptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type Xr(XrSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xr_ind(Xr_indSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xr_indptr(Xr_indptrSEXP);
    Rcpp::traits::input_parameter< size_t >::type nrows(nrowsSEXP);
    Rcpp::traits::input_parameter< int >::type nthreads(nthreadsSEXP);
    Rcpp::traits::input_parameter< bool >::type standardize(standardizeSEXP);
    predict_iso(model_R_ptr, is_extended, indexer_R_ptr, outp, tree_num, tree_depths, X_num, X_cat, Xc, Xc_ind, Xc_indptr, Xr, Xr_ind, Xr_indptr, nrows, nthreads, standardize);
    return R_NilValue;
END_RCPP
}
// dist_iso
void dist_iso(SEXP model_R_ptr, SEXP indexer_R_ptr, Rcpp::NumericVector tmat, Rcpp::NumericMatrix dmat, Rcpp::NumericMatrix rmat, bool is_extended, Rcpp::NumericVector X_num, Rcpp::IntegerVector X_cat, Rcpp::NumericVector Xc, Rcpp::IntegerVector Xc_ind, Rcpp::IntegerVector Xc_indptr, size_t nrows, int nthreads, bool assume_full_distr, bool standardize_dist, bool sq_dist, size_t n_from, bool use_reference_points, bool as_kernel);
RcppExport SEXP _isotree_dist_iso(SEXP model_R_ptrSEXP, SEXP indexer_R_ptrSEXP, SEXP tmatSEXP, SEXP dmatSEXP, SEXP rmatSEXP, SEXP is_extendedSEXP, SEXP X_numSEXP, SEXP X_catSEXP, SEXP XcSEXP, SEXP Xc_indSEXP, SEXP Xc_indptrSEXP, SEXP nrowsSEXP, SEXP nthreadsSEXP, SEXP assume_full_distrSEXP, SEXP standardize_distSEXP, SEXP sq_distSEXP, SEXP n_fromSEXP, SEXP use_reference_pointsSEXP, SEXP as_kernelSEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< SEXP >::type model_R_ptr(model_R_ptrSEXP);
    Rcpp::traits::input_parameter< SEXP >::type indexer_R_ptr(indexer_R_ptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type tmat(tmatSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericMatrix >::type dmat(dmatSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericMatrix >::type rmat(rmatSEXP);
    Rcpp::traits::input_parameter< bool >::type is_extended(is_extendedSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type X_num(X_numSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type X_cat(X_catSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type Xc(XcSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_ind(Xc_indSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_indptr(Xc_indptrSEXP);
    Rcpp::traits::input_parameter< size_t >::type nrows(nrowsSEXP);
    Rcpp::traits::input_parameter< int >::type nthreads(nthreadsSEXP);
    Rcpp::traits::input_parameter< bool >::type assume_full_distr(assume_full_distrSEXP);
    Rcpp::traits::input_parameter< bool >::type standardize_dist(standardize_distSEXP);
    Rcpp::traits::input_parameter< bool >::type sq_dist(sq_distSEXP);
    Rcpp::traits::input_parameter< size_t >::type n_from(n_fromSEXP);
    Rcpp::traits::input_parameter< bool >::type use_reference_points(use_reference_pointsSEXP);
    Rcpp::traits::input_parameter< bool >::type as_kernel(as_kernelSEXP);
    dist_iso(model_R_ptr, indexer_R_ptr, tmat, dmat, rmat, is_extended, X_num, X_cat, Xc, Xc_ind, Xc_indptr, nrows, nthreads, assume_full_distr, standardize_dist, sq_dist, n_from, use_reference_points, as_kernel);
    return R_NilValue;
END_RCPP
}
// impute_iso
Rcpp::List impute_iso(SEXP model_R_ptr, SEXP imputer_R_ptr, bool is_extended, Rcpp::NumericVector X_num, Rcpp::IntegerVector X_cat, Rcpp::NumericVector Xr, Rcpp::IntegerVector Xr_ind, Rcpp::IntegerVector Xr_indptr, size_t nrows, int nthreads);
RcppExport SEXP _isotree_impute_iso(SEXP model_R_ptrSEXP, SEXP imputer_R_ptrSEXP, SEXP is_extendedSEXP, SEXP X_numSEXP, SEXP X_catSEXP, SEXP XrSEXP, SEXP Xr_indSEXP, SEXP Xr_indptrSEXP, SEXP nrowsSEXP, SEXP nthreadsSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< SEXP >::type model_R_ptr(model_R_ptrSEXP);
    Rcpp::traits::input_parameter< SEXP >::type imputer_R_ptr(imputer_R_ptrSEXP);
    Rcpp::traits::input_parameter< bool >::type is_extended(is_extendedSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type X_num(X_numSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type X_cat(X_catSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type Xr(XrSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xr_ind(Xr_indSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xr_indptr(Xr_indptrSEXP);
    Rcpp::traits::input_parameter< size_t >::type nrows(nrowsSEXP);
    Rcpp::traits::input_parameter< int >::type nthreads(nthreadsSEXP);
    rcpp_result_gen = Rcpp::wrap(impute_iso(model_R_ptr, imputer_R_ptr, is_extended, X_num, X_cat, Xr, Xr_ind, Xr_indptr, nrows, nthreads));
    return rcpp_result_gen;
END_RCPP
}
// drop_imputer
void drop_imputer(Rcpp::List lst_modify, Rcpp::List lst_modify2);
RcppExport SEXP _isotree_drop_imputer(SEXP lst_modifySEXP, SEXP lst_modify2SEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< Rcpp::List >::type lst_modify(lst_modifySEXP);
    Rcpp::traits::input_parameter< Rcpp::List >::type lst_modify2(lst_modify2SEXP);
    drop_imputer(lst_modify, lst_modify2);
    return R_NilValue;
END_RCPP
}
// drop_indexer
void drop_indexer(Rcpp::List lst_modify, Rcpp::List lst_modify2);
RcppExport SEXP _isotree_drop_indexer(SEXP lst_modifySEXP, SEXP lst_modify2SEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< Rcpp::List >::type lst_modify(lst_modifySEXP);
    Rcpp::traits::input_parameter< Rcpp::List >::type lst_modify2(lst_modify2SEXP);
    drop_indexer(lst_modify, lst_modify2);
    return R_NilValue;
END_RCPP
}
// drop_reference_points
void drop_reference_points(Rcpp::List lst_modify, Rcpp::List lst_modify2);
RcppExport SEXP _isotree_drop_reference_points(SEXP lst_modifySEXP, SEXP lst_modify2SEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< Rcpp::List >::type lst_modify(lst_modifySEXP);
    Rcpp::traits::input_parameter< Rcpp::List >::type lst_modify2(lst_modify2SEXP);
    drop_reference_points(lst_modify, lst_modify2);
    return R_NilValue;
END_RCPP
}
// subset_trees
Rcpp::List subset_trees(SEXP model_R_ptr, SEXP imputer_R_ptr, SEXP indexer_R_ptr, bool is_extended, bool has_imputer, Rcpp::IntegerVector trees_take);
RcppExport SEXP _isotree_subset_trees(SEXP model_R_ptrSEXP, SEXP imputer_R_ptrSEXP, SEXP indexer_R_ptrSEXP, SEXP is_extendedSEXP, SEXP has_imputerSEXP, SEXP trees_takeSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< SEXP >::type model_R_ptr(model_R_ptrSEXP);
    Rcpp::traits::input_parameter< SEXP >::type imputer_R_ptr(imputer_R_ptrSEXP);
    Rcpp::traits::input_parameter< SEXP >::type indexer_R_ptr(indexer_R_ptrSEXP);
    Rcpp::traits::input_parameter< bool >::type is_extended(is_extendedSEXP);
    Rcpp::traits::input_parameter< bool >::type has_imputer(has_imputerSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type trees_take(trees_takeSEXP);
    rcpp_result_gen = Rcpp::wrap(subset_trees(model_R_ptr, imputer_R_ptr, indexer_R_ptr, is_extended, has_imputer, trees_take));
    return rcpp_result_gen;
END_RCPP
}
// inplace_set_to_zero
void inplace_set_to_zero(SEXP obj);
RcppExport SEXP _isotree_inplace_set_to_zero(SEXP objSEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< SEXP >::type obj(objSEXP);
    inplace_set_to_zero(obj);
    return R_NilValue;
END_RCPP
}
// get_n_nodes
Rcpp::List get_n_nodes(SEXP model_R_ptr, bool is_extended, int nthreads);
RcppExport SEXP _isotree_get_n_nodes(SEXP model_R_ptrSEXP, SEXP is_extendedSEXP, SEXP nthreadsSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< SEXP >::type model_R_ptr(model_R_ptrSEXP);
    Rcpp::traits::input_parameter< bool >::type is_extended(is_extendedSEXP);
    Rcpp::traits::input_parameter< int >::type nthreads(nthreadsSEXP);
    rcpp_result_gen = Rcpp::wrap(get_n_nodes(model_R_ptr, is_extended, nthreads));
    return rcpp_result_gen;
END_RCPP
}
// append_trees_from_other
void append_trees_from_other(SEXP model_R_ptr, SEXP other_R_ptr, SEXP imp_R_ptr, SEXP oimp_R_ptr, SEXP ind_R_ptr, SEXP oind_R_ptr, bool is_extended, Rcpp::RawVector serialized_obj, Rcpp::RawVector serialized_imputer, Rcpp::RawVector serialized_indexer, Rcpp::List& model_cpp_obj_update, Rcpp::List& model_params_update);
RcppExport SEXP _isotree_append_trees_from_other(SEXP model_R_ptrSEXP, SEXP other_R_ptrSEXP, SEXP imp_R_ptrSEXP, SEXP oimp_R_ptrSEXP, SEXP ind_R_ptrSEXP, SEXP oind_R_ptrSEXP, SEXP is_extendedSEXP, SEXP serialized_objSEXP, SEXP serialized_imputerSEXP, SEXP serialized_indexerSEXP, SEXP model_cpp_obj_updateSEXP, SEXP model_params_updateSEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< SEXP >::type model_R_ptr(model_R_ptrSEXP);
    Rcpp::traits::input_parameter< SEXP >::type other_R_ptr(other_R_ptrSEXP);
    Rcpp::traits::input_parameter< SEXP >::type imp_R_ptr(imp_R_ptrSEXP);
    Rcpp::traits::input_parameter< SEXP >::type oimp_R_ptr(oimp_R_ptrSEXP);
    Rcpp::traits::input_parameter< SEXP >::type ind_R_ptr(ind_R_ptrSEXP);
    Rcpp::traits::input_parameter< SEXP >::type oind_R_ptr(oind_R_ptrSEXP);
    Rcpp::traits::input_parameter< bool >::type is_extended(is_extendedSEXP);
    Rcpp::traits::input_parameter< Rcpp::RawVector >::type serialized_obj(serialized_objSEXP);
    Rcpp::traits::input_parameter< Rcpp::RawVector >::type serialized_imputer(serialized_imputerSEXP);
    Rcpp::traits::input_parameter< Rcpp::RawVector >::type serialized_indexer(serialized_indexerSEXP);
    Rcpp::traits::input_parameter< Rcpp::List& >::type model_cpp_obj_update(model_cpp_obj_updateSEXP);
    Rcpp::traits::input_parameter< Rcpp::List& >::type model_params_update(model_params_updateSEXP);
    append_trees_from_other(model_R_ptr, other_R_ptr, imp_R_ptr, oimp_R_ptr, ind_R_ptr, oind_R_ptr, is_extended, serialized_obj, serialized_imputer, serialized_indexer, model_cpp_obj_update, model_params_update);
    return R_NilValue;
END_RCPP
}
// model_to_sql
Rcpp::ListOf<Rcpp::CharacterVector> model_to_sql(SEXP model_R_ptr, bool is_extended, Rcpp::CharacterVector numeric_colanmes, Rcpp::CharacterVector categ_colnames, Rcpp::ListOf<Rcpp::CharacterVector> categ_levels, bool output_tree_num, bool single_tree, size_t tree_num, int nthreads);
RcppExport SEXP _isotree_model_to_sql(SEXP model_R_ptrSEXP, SEXP is_extendedSEXP, SEXP numeric_colanmesSEXP, SEXP categ_colnamesSEXP, SEXP categ_levelsSEXP, SEXP output_tree_numSEXP, SEXP single_treeSEXP, SEXP tree_numSEXP, SEXP nthreadsSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< SEXP >::type model_R_ptr(model_R_ptrSEXP);
    Rcpp::traits::input_parameter< bool >::type is_extended(is_extendedSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type numeric_colanmes(numeric_colanmesSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type categ_colnames(categ_colnamesSEXP);
    Rcpp::traits::input_parameter< Rcpp::ListOf<Rcpp::CharacterVector> >::type categ_levels(categ_levelsSEXP);
    Rcpp::traits::input_parameter< bool >::type output_tree_num(output_tree_numSEXP);
    Rcpp::traits::input_parameter< bool >::type single_tree(single_treeSEXP);
    Rcpp::traits::input_parameter< size_t >::type tree_num(tree_numSEXP);
    Rcpp::traits::input_parameter< int >::type nthreads(nthreadsSEXP);
    rcpp_result_gen = Rcpp::wrap(model_to_sql(model_R_ptr, is_extended, numeric_colanmes, categ_colnames, categ_levels, output_tree_num, single_tree, tree_num, nthreads));
    return rcpp_result_gen;
END_RCPP
}
// model_to_sql_with_select_from
Rcpp::CharacterVector model_to_sql_with_select_from(SEXP model_R_ptr, bool is_extended, Rcpp::CharacterVector numeric_colanmes, Rcpp::CharacterVector categ_colnames, Rcpp::ListOf<Rcpp::CharacterVector> categ_levels, Rcpp::CharacterVector table_from, Rcpp::CharacterVector select_as, int nthreads);
RcppExport SEXP _isotree_model_to_sql_with_select_from(SEXP model_R_ptrSEXP, SEXP is_extendedSEXP, SEXP numeric_colanmesSEXP, SEXP categ_colnamesSEXP, SEXP categ_levelsSEXP, SEXP table_fromSEXP, SEXP select_asSEXP, SEXP nthreadsSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< SEXP >::type model_R_ptr(model_R_ptrSEXP);
    Rcpp::traits::input_parameter< bool >::type is_extended(is_extendedSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type numeric_colanmes(numeric_colanmesSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type categ_colnames(categ_colnamesSEXP);
    Rcpp::traits::input_parameter< Rcpp::ListOf<Rcpp::CharacterVector> >::type categ_levels(categ_levelsSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type table_from(table_fromSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type select_as(select_asSEXP);
    Rcpp::traits::input_parameter< int >::type nthreads(nthreadsSEXP);
    rcpp_result_gen = Rcpp::wrap(model_to_sql_with_select_from(model_R_ptr, is_extended, numeric_colanmes, categ_colnames, categ_levels, table_from, select_as, nthreads));
    return rcpp_result_gen;
END_RCPP
}
// copy_cpp_objects
Rcpp::List copy_cpp_objects(SEXP model_R_ptr, bool is_extended, SEXP imp_R_ptr, bool has_imputer, SEXP ind_R_ptr);
RcppExport SEXP _isotree_copy_cpp_objects(SEXP model_R_ptrSEXP, SEXP is_extendedSEXP, SEXP imp_R_ptrSEXP, SEXP has_imputerSEXP, SEXP ind_R_ptrSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< SEXP >::type model_R_ptr(model_R_ptrSEXP);
    Rcpp::traits::input_parameter< bool >::type is_extended(is_extendedSEXP);
    Rcpp::traits::input_parameter< SEXP >::type imp_R_ptr(imp_R_ptrSEXP);
    Rcpp::traits::input_parameter< bool >::type has_imputer(has_imputerSEXP);
    Rcpp::traits::input_parameter< SEXP >::type ind_R_ptr(ind_R_ptrSEXP);
    rcpp_result_gen = Rcpp::wrap(copy_cpp_objects(model_R_ptr, is_extended, imp_R_ptr, has_imputer, ind_R_ptr));
    return rcpp_result_gen;
END_RCPP
}
// build_tree_indices
void build_tree_indices(Rcpp::List lst_modify, bool is_extended, bool with_distances, int nthreads);
RcppExport SEXP _isotree_build_tree_indices(SEXP lst_modifySEXP, SEXP is_extendedSEXP, SEXP with_distancesSEXP, SEXP nthreadsSEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< Rcpp::List >::type lst_modify(lst_modifySEXP);
    Rcpp::traits::input_parameter< bool >::type is_extended(is_extendedSEXP);
    Rcpp::traits::input_parameter< bool >::type with_distances(with_distancesSEXP);
    Rcpp::traits::input_parameter< int >::type nthreads(nthreadsSEXP);
    build_tree_indices(lst_modify, is_extended, with_distances, nthreads);
    return R_NilValue;
END_RCPP
}
// check_node_indexer_has_distances
bool check_node_indexer_has_distances(SEXP indexer_R_ptr);
RcppExport SEXP _isotree_check_node_indexer_has_distances(SEXP indexer_R_ptrSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< SEXP >::type indexer_R_ptr(indexer_R_ptrSEXP);
    rcpp_result_gen = Rcpp::wrap(check_node_indexer_has_distances(indexer_R_ptr));
    return rcpp_result_gen;
END_RCPP
}
// set_reference_points
void set_reference_points(Rcpp::List lst_modify, Rcpp::List lst_modify2, SEXP rnames, bool is_extended, Rcpp::NumericVector X_num, Rcpp::IntegerVector X_cat, Rcpp::NumericVector Xc, Rcpp::IntegerVector Xc_ind, Rcpp::IntegerVector Xc_indptr, size_t nrows, int nthreads, bool with_distances);
RcppExport SEXP _isotree_set_reference_points(SEXP lst_modifySEXP, SEXP lst_modify2SEXP, SEXP rnamesSEXP, SEXP is_extendedSEXP, SEXP X_numSEXP, SEXP X_catSEXP, SEXP XcSEXP, SEXP Xc_indSEXP, SEXP Xc_indptrSEXP, SEXP nrowsSEXP, SEXP nthreadsSEXP, SEXP with_distancesSEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< Rcpp::List >::type lst_modify(lst_modifySEXP);
    Rcpp::traits::input_parameter< Rcpp::List >::type lst_modify2(lst_modify2SEXP);
    Rcpp::traits::input_parameter< SEXP >::type rnames(rnamesSEXP);
    Rcpp::traits::input_parameter< bool >::type is_extended(is_extendedSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type X_num(X_numSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type X_cat(X_catSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type Xc(XcSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_ind(Xc_indSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_indptr(Xc_indptrSEXP);
    Rcpp::traits::input_parameter< size_t >::type nrows(nrowsSEXP);
    Rcpp::traits::input_parameter< int >::type nthreads(nthreadsSEXP);
    Rcpp::traits::input_parameter< bool >::type with_distances(with_distancesSEXP);
    set_reference_points(lst_modify, lst_modify2, rnames, is_extended, X_num, X_cat, Xc, Xc_ind, Xc_indptr, nrows, nthreads, with_distances);
    return R_NilValue;
END_RCPP
}
// check_node_indexer_has_references
bool check_node_indexer_has_references(SEXP indexer_R_ptr);
RcppExport SEXP _isotree_check_node_indexer_has_references(SEXP indexer_R_ptrSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< SEXP >::type indexer_R_ptr(indexer_R_ptrSEXP);
    rcpp_result_gen = Rcpp::wrap(check_node_indexer_has_references(indexer_R_ptr));
    return rcpp_result_gen;
END_RCPP
}
// get_num_references
int get_num_references(SEXP indexer_R_ptr);
RcppExport SEXP _isotree_get_num_references(SEXP indexer_R_ptrSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< SEXP >::type indexer_R_ptr(indexer_R_ptrSEXP);
    rcpp_result_gen = Rcpp::wrap(get_num_references(indexer_R_ptr));
    return rcpp_result_gen;
END_RCPP
}
// get_null_R_pointer
SEXP get_null_R_pointer();
RcppExport SEXP _isotree_get_null_R_pointer() {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    rcpp_result_gen = Rcpp::wrap(get_null_R_pointer());
    return rcpp_result_gen;
END_RCPP
}
// serialize_to_file
void serialize_to_file(Rcpp::RawVector serialized_obj, Rcpp::RawVector serialized_imputer, Rcpp::RawVector serialized_indexer, bool is_extended, Rcpp::RawVector metadata, Rcpp::CharacterVector fname);
RcppExport SEXP _isotree_serialize_to_file(SEXP serialized_objSEXP, SEXP serialized_imputerSEXP, SEXP serialized_indexerSEXP, SEXP is_extendedSEXP, SEXP metadataSEXP, SEXP fnameSEXP) {
BEGIN_RCPP
    Rcpp::RNGScope rcpp_rngScope_gen;
    Rcpp::traits::input_parameter< Rcpp::RawVector >::type serialized_obj(serialized_objSEXP);
    Rcpp::traits::input_parameter< Rcpp::RawVector >::type serialized_imputer(serialized_imputerSEXP);
    Rcpp::traits::input_parameter< Rcpp::RawVector >::type serialized_indexer(serialized_indexerSEXP);
    Rcpp::traits::input_parameter< bool >::type is_extended(is_extendedSEXP);
    Rcpp::traits::input_parameter< Rcpp::RawVector >::type metadata(metadataSEXP);
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type fname(fnameSEXP);
    serialize_to_file(serialized_obj, serialized_imputer, serialized_indexer, is_extended, metadata, fname);
    return R_NilValue;
END_RCPP
}
// deserialize_from_file
Rcpp::List deserialize_from_file(Rcpp::CharacterVector fname);
RcppExport SEXP _isotree_deserialize_from_file(SEXP fnameSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::RNGScope rcpp_rngScope_gen;
    Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type fname(fnameSEXP);
    rcpp_result_gen = Rcpp::wrap(deserialize_from_file(fname));
    return rcpp_result_gen;
END_RCPP
}
// call_sort_csc_indices
void call_sort_csc_indices(Rcpp::NumericVector Xc, Rcpp::IntegerVector Xc_ind, Rcpp::IntegerVector Xc_indptr);
RcppExport SEXP _isotree_call_sort_csc_indices(SEXP XcSEXP, SEXP Xc_indSEXP, SEXP Xc_indptrSEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type Xc(XcSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_ind(Xc_indSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_indptr(Xc_indptrSEXP);
    call_sort_csc_indices(Xc, Xc_ind, Xc_indptr);
    return R_NilValue;
END_RCPP
}
// call_reconstruct_csr_sliced
void call_reconstruct_csr_sliced(Rcpp::NumericVector orig_Xr, Rcpp::IntegerVector orig_Xr_indptr, Rcpp::NumericVector rec_Xr, Rcpp::IntegerVector rec_Xr_indptr, size_t nrows);
RcppExport SEXP _isotree_call_reconstruct_csr_sliced(SEXP orig_XrSEXP, SEXP orig_Xr_indptrSEXP, SEXP rec_XrSEXP, SEXP rec_Xr_indptrSEXP, SEXP nrowsSEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type orig_Xr(orig_XrSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type orig_Xr_indptr(orig_Xr_indptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type rec_Xr(rec_XrSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type rec_Xr_indptr(rec_Xr_indptrSEXP);
    Rcpp::traits::input_parameter< size_t >::type nrows(nrowsSEXP);
    call_reconstruct_csr_sliced(orig_Xr, orig_Xr_indptr, rec_Xr, rec_Xr_indptr, nrows);
    return R_NilValue;
END_RCPP
}
// call_reconstruct_csr_with_categ
void call_reconstruct_csr_with_categ(Rcpp::NumericVector orig_Xr, Rcpp::IntegerVector orig_Xr_ind, Rcpp::IntegerVector orig_Xr_indptr, Rcpp::NumericVector rec_Xr, Rcpp::IntegerVector rec_Xr_ind, Rcpp::IntegerVector rec_Xr_indptr, Rcpp::IntegerVector rec_X_cat, Rcpp::IntegerVector cols_numeric, Rcpp::IntegerVector cols_categ, size_t nrows, size_t ncols);
RcppExport SEXP _isotree_call_reconstruct_csr_with_categ(SEXP orig_XrSEXP, SEXP orig_Xr_indSEXP, SEXP orig_Xr_indptrSEXP, SEXP rec_XrSEXP, SEXP rec_Xr_indSEXP, SEXP rec_Xr_indptrSEXP, SEXP rec_X_catSEXP, SEXP cols_numericSEXP, SEXP cols_categSEXP, SEXP nrowsSEXP, SEXP ncolsSEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type orig_Xr(orig_XrSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type orig_Xr_ind(orig_Xr_indSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type orig_Xr_indptr(orig_Xr_indptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type rec_Xr(rec_XrSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type rec_Xr_ind(rec_Xr_indSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type rec_Xr_indptr(rec_Xr_indptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type rec_X_cat(rec_X_catSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type cols_numeric(cols_numericSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type cols_categ(cols_categSEXP);
    Rcpp::traits::input_parameter< size_t >::type nrows(nrowsSEXP);
    Rcpp::traits::input_parameter< size_t >::type ncols(ncolsSEXP);
    call_reconstruct_csr_with_categ(orig_Xr, orig_Xr_ind, orig_Xr_indptr, rec_Xr, rec_Xr_ind, rec_Xr_indptr, rec_X_cat, cols_numeric, cols_categ, nrows, ncols);
    return R_NilValue;
END_RCPP
}
// deepcopy_vector
Rcpp::NumericVector deepcopy_vector(Rcpp::NumericVector inp);
RcppExport SEXP _isotree_deepcopy_vector(SEXP inpSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type inp(inpSEXP);
    rcpp_result_gen = Rcpp::wrap(deepcopy_vector(inp));
    return rcpp_result_gen;
END_RCPP
}
// call_take_cols_by_slice_csr
Rcpp::List call_take_cols_by_slice_csr(Rcpp::NumericVector Xr_, Rcpp::IntegerVector Xr_ind_, Rcpp::IntegerVector Xr_indptr, int ncols_take, bool as_dense);
RcppExport SEXP _isotree_call_take_cols_by_slice_csr(SEXP Xr_SEXP, SEXP Xr_ind_SEXP, SEXP Xr_indptrSEXP, SEXP ncols_takeSEXP, SEXP as_denseSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type Xr_(Xr_SEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xr_ind_(Xr_ind_SEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xr_indptr(Xr_indptrSEXP);
    Rcpp::traits::input_parameter< int >::type ncols_take(ncols_takeSEXP);
    Rcpp::traits::input_parameter< bool >::type as_dense(as_denseSEXP);
    rcpp_result_gen = Rcpp::wrap(call_take_cols_by_slice_csr(Xr_, Xr_ind_, Xr_indptr, ncols_take, as_dense));
    return rcpp_result_gen;
END_RCPP
}
// call_take_cols_by_index_csr
Rcpp::List call_take_cols_by_index_csr(Rcpp::NumericVector Xr, Rcpp::IntegerVector Xr_ind, Rcpp::IntegerVector Xr_indptr, Rcpp::IntegerVector cols_take, bool as_dense);
RcppExport SEXP _isotree_call_take_cols_by_index_csr(SEXP XrSEXP, SEXP Xr_indSEXP, SEXP Xr_indptrSEXP, SEXP cols_takeSEXP, SEXP as_denseSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type Xr(XrSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xr_ind(Xr_indSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xr_indptr(Xr_indptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type cols_take(cols_takeSEXP);
    Rcpp::traits::input_parameter< bool >::type as_dense(as_denseSEXP);
    rcpp_result_gen = Rcpp::wrap(call_take_cols_by_index_csr(Xr, Xr_ind, Xr_indptr, cols_take, as_dense));
    return rcpp_result_gen;
END_RCPP
}
// call_take_cols_by_slice_csc
Rcpp::List call_take_cols_by_slice_csc(Rcpp::NumericVector Xc, Rcpp::IntegerVector Xc_ind, Rcpp::IntegerVector Xc_indptr, size_t ncols_take, bool as_dense, size_t nrows);
RcppExport SEXP _isotree_call_take_cols_by_slice_csc(SEXP XcSEXP, SEXP Xc_indSEXP, SEXP Xc_indptrSEXP, SEXP ncols_takeSEXP, SEXP as_denseSEXP, SEXP nrowsSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type Xc(XcSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_ind(Xc_indSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_indptr(Xc_indptrSEXP);
    Rcpp::traits::input_parameter< size_t >::type ncols_take(ncols_takeSEXP);
    Rcpp::traits::input_parameter< bool >::type as_dense(as_denseSEXP);
    Rcpp::traits::input_parameter< size_t >::type nrows(nrowsSEXP);
    rcpp_result_gen = Rcpp::wrap(call_take_cols_by_slice_csc(Xc, Xc_ind, Xc_indptr, ncols_take, as_dense, nrows));
    return rcpp_result_gen;
END_RCPP
}
// call_take_cols_by_index_csc
Rcpp::List call_take_cols_by_index_csc(Rcpp::NumericVector Xc_, Rcpp::IntegerVector Xc_ind_, Rcpp::IntegerVector Xc_indptr, Rcpp::IntegerVector cols_take, bool as_dense, size_t nrows);
RcppExport SEXP _isotree_call_take_cols_by_index_csc(SEXP Xc_SEXP, SEXP Xc_ind_SEXP, SEXP Xc_indptrSEXP, SEXP cols_takeSEXP, SEXP as_denseSEXP, SEXP nrowsSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type Xc_(Xc_SEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_ind_(Xc_ind_SEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_indptr(Xc_indptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type cols_take(cols_takeSEXP);
    Rcpp::traits::input_parameter< bool >::type as_dense(as_denseSEXP);
    Rcpp::traits::input_parameter< size_t >::type nrows(nrowsSEXP);
    rcpp_result_gen = Rcpp::wrap(call_take_cols_by_index_csc(Xc_, Xc_ind_, Xc_indptr, cols_take, as_dense, nrows));
    return rcpp_result_gen;
END_RCPP
}
// copy_csc_cols_by_slice
void copy_csc_cols_by_slice(Rcpp::NumericVector out_Xc_, Rcpp::IntegerVector out_Xc_indptr, Rcpp::NumericVector from_Xc_, Rcpp::IntegerVector from_Xc_indptr, size_t n_copy);
RcppExport SEXP _isotree_copy_csc_cols_by_slice(SEXP out_Xc_SEXP, SEXP out_Xc_indptrSEXP, SEXP from_Xc_SEXP, SEXP from_Xc_indptrSEXP, SEXP n_copySEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type out_Xc_(out_Xc_SEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type out_Xc_indptr(out_Xc_indptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type from_Xc_(from_Xc_SEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type from_Xc_indptr(from_Xc_indptrSEXP);
    Rcpp::traits::input_parameter< size_t >::type n_copy(n_copySEXP);
    copy_csc_cols_by_slice(out_Xc_, out_Xc_indptr, from_Xc_, from_Xc_indptr, n_copy);
    return R_NilValue;
END_RCPP
}
// copy_csc_cols_by_index
void copy_csc_cols_by_index(Rcpp::NumericVector out_Xc_, Rcpp::IntegerVector out_Xc_indptr, Rcpp::NumericVector from_Xc_, Rcpp::IntegerVector from_Xc_indptr, Rcpp::IntegerVector cols_copy);
RcppExport SEXP _isotree_copy_csc_cols_by_index(SEXP out_Xc_SEXP, SEXP out_Xc_indptrSEXP, SEXP from_Xc_SEXP, SEXP from_Xc_indptrSEXP, SEXP cols_copySEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type out_Xc_(out_Xc_SEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type out_Xc_indptr(out_Xc_indptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type from_Xc_(from_Xc_SEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type from_Xc_indptr(from_Xc_indptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type cols_copy(cols_copySEXP);
    copy_csc_cols_by_index(out_Xc_, out_Xc_indptr, from_Xc_, from_Xc_indptr, cols_copy);
    return R_NilValue;
END_RCPP
}
// assign_csc_cols
Rcpp::List assign_csc_cols(Rcpp::NumericVector Xc_, Rcpp::IntegerVector Xc_ind_, Rcpp::IntegerVector Xc_indptr, Rcpp::IntegerVector X_cat_, Rcpp::IntegerVector cols_categ, Rcpp::IntegerVector cols_numeric, size_t nrows);
RcppExport SEXP _isotree_assign_csc_cols(SEXP Xc_SEXP, SEXP Xc_ind_SEXP, SEXP Xc_indptrSEXP, SEXP X_cat_SEXP, SEXP cols_categSEXP, SEXP cols_numericSEXP, SEXP nrowsSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< Rcpp::NumericVector >::type Xc_(Xc_SEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_ind_(Xc_ind_SEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type Xc_indptr(Xc_indptrSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type X_cat_(X_cat_SEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type cols_categ(cols_categSEXP);
    Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type cols_numeric(cols_numericSEXP);
    Rcpp::traits::input_parameter< size_t >::type nrows(nrowsSEXP);
    rcpp_result_gen = Rcpp::wrap(assign_csc_cols(Xc_, Xc_ind_, Xc_indptr, X_cat_, cols_categ, cols_numeric, nrows));
    return rcpp_result_gen;
END_RCPP
}
// get_empty_tmat
Rcpp::NumericVector get_empty_tmat(int nrows_);
RcppExport SEXP _isotree_get_empty_tmat(SEXP nrows_SEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< int >::type nrows_(nrows_SEXP);
    rcpp_result_gen = Rcpp::wrap(get_empty_tmat(nrows_));
    return rcpp_result_gen;
END_RCPP
}
// get_empty_int_mat
Rcpp::IntegerMatrix get_empty_int_mat(int nrows, int ncols);
RcppExport SEXP _isotree_get_empty_int_mat(SEXP nrowsSEXP, SEXP ncolsSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< int >::type nrows(nrowsSEXP);
    Rcpp::traits::input_parameter< int >::type ncols(ncolsSEXP);
    rcpp_result_gen = Rcpp::wrap(get_empty_int_mat(nrows, ncols));
    return rcpp_result_gen;
END_RCPP
}
// get_null_int_mat
Rcpp::IntegerMatrix get_null_int_mat();
RcppExport SEXP _isotree_get_null_int_mat() {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    rcpp_result_gen = Rcpp::wrap(get_null_int_mat());
    return rcpp_result_gen;
END_RCPP
}
// get_ntrees
int get_ntrees(SEXP model_R_ptr, bool is_extended);
RcppExport SEXP _isotree_get_ntrees(SEXP model_R_ptrSEXP, SEXP is_extendedSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< SEXP >::type model_R_ptr(model_R_ptrSEXP);
    Rcpp::traits::input_parameter< bool >::type is_extended(is_extendedSEXP);
    rcpp_result_gen = Rcpp::wrap(get_ntrees(model_R_ptr, is_extended));
    return rcpp_result_gen;
END_RCPP
}
// deepcopy_int
SEXP deepcopy_int(SEXP x);
RcppExport SEXP _isotree_deepcopy_int(SEXP xSEXP) {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    Rcpp::traits::input_parameter< SEXP >::type x(xSEXP);
    rcpp_result_gen = Rcpp::wrap(deepcopy_int(x));
    return rcpp_result_gen;
END_RCPP
}
// modify_R_list_inplace
void modify_R_list_inplace(SEXP lst, int ix, SEXP el);
RcppExport SEXP _isotree_modify_R_list_inplace(SEXP lstSEXP, SEXP ixSEXP, SEXP elSEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< SEXP >::type lst(lstSEXP);
    Rcpp::traits::input_parameter< int >::type ix(ixSEXP);
    Rcpp::traits::input_parameter< SEXP >::type el(elSEXP);
    modify_R_list_inplace(lst, ix, el);
    return R_NilValue;
END_RCPP
}
// addto_R_list_inplace
void addto_R_list_inplace(Rcpp::List& lst, Rcpp::String nm, SEXP el);
RcppExport SEXP _isotree_addto_R_list_inplace(SEXP lstSEXP, SEXP nmSEXP, SEXP elSEXP) {
BEGIN_RCPP
    Rcpp::traits::input_parameter< Rcpp::List& >::type lst(lstSEXP);
    Rcpp::traits::input_parameter< Rcpp::String >::type nm(nmSEXP);
    Rcpp::traits::input_parameter< SEXP >::type el(elSEXP);
    addto_R_list_inplace(lst, nm, el);
    return R_NilValue;
END_RCPP
}
// R_has_openmp
bool R_has_openmp();
RcppExport SEXP _isotree_R_has_openmp() {
BEGIN_RCPP
    Rcpp::RObject rcpp_result_gen;
    rcpp_result_gen = Rcpp::wrap(R_has_openmp());
    return rcpp_result_gen;
END_RCPP
}

static const R_CallMethodDef CallEntries[] = {
    {""_isotree_deserialize_IsoForest"", (DL_FUNC) &_isotree_deserialize_IsoForest, 1},
    {""_isotree_deserialize_ExtIsoForest"", (DL_FUNC) &_isotree_deserialize_ExtIsoForest, 1},
    {""_isotree_deserialize_Imputer"", (DL_FUNC) &_isotree_deserialize_Imputer, 1},
    {""_isotree_deserialize_Indexer"", (DL_FUNC) &_isotree_deserialize_Indexer, 1},
    {""_isotree_check_null_ptr_model"", (DL_FUNC) &_isotree_check_null_ptr_model, 1},
    {""_isotree_fit_model"", (DL_FUNC) &_isotree_fit_model, 49},
    {""_isotree_fit_tree"", (DL_FUNC) &_isotree_fit_tree, 50},
    {""_isotree_predict_iso"", (DL_FUNC) &_isotree_predict_iso, 17},
    {""_isotree_dist_iso"", (DL_FUNC) &_isotree_dist_iso, 19},
    {""_isotree_impute_iso"", (DL_FUNC) &_isotree_impute_iso, 10},
    {""_isotree_drop_imputer"", (DL_FUNC) &_isotree_drop_imputer, 2},
    {""_isotree_drop_indexer"", (DL_FUNC) &_isotree_drop_indexer, 2},
    {""_isotree_drop_reference_points"", (DL_FUNC) &_isotree_drop_reference_points, 2},
    {""_isotree_subset_trees"", (DL_FUNC) &_isotree_subset_trees, 6},
    {""_isotree_inplace_set_to_zero"", (DL_FUNC) &_isotree_inplace_set_to_zero, 1},
    {""_isotree_get_n_nodes"", (DL_FUNC) &_isotree_get_n_nodes, 3},
    {""_isotree_append_trees_from_other"", (DL_FUNC) &_isotree_append_trees_from_other, 12},
    {""_isotree_model_to_sql"", (DL_FUNC) &_isotree_model_to_sql, 9},
    {""_isotree_model_to_sql_with_select_from"", (DL_FUNC) &_isotree_model_to_sql_with_select_from, 8},
    {""_isotree_copy_cpp_objects"", (DL_FUNC) &_isotree_copy_cpp_objects, 5},
    {""_isotree_build_tree_indices"", (DL_FUNC) &_isotree_build_tree_indices, 4},
    {""_isotree_check_node_indexer_has_distances"", (DL_FUNC) &_isotree_check_node_indexer_has_distances, 1},
    {""_isotree_set_reference_points"", (DL_FUNC) &_isotree_set_reference_points, 12},
    {""_isotree_check_node_indexer_has_references"", (DL_FUNC) &_isotree_check_node_indexer_has_references, 1},
    {""_isotree_get_num_references"", (DL_FUNC) &_isotree_get_num_references, 1},
    {""_isotree_get_null_R_pointer"", (DL_FUNC) &_isotree_get_null_R_pointer, 0},
    {""_isotree_serialize_to_file"", (DL_FUNC) &_isotree_serialize_to_file, 6},
    {""_isotree_deserialize_from_file"", (DL_FUNC) &_isotree_deserialize_from_file, 1},
    {""_isotree_call_sort_csc_indices"", (DL_FUNC) &_isotree_call_sort_csc_indices, 3},
    {""_isotree_call_reconstruct_csr_sliced"", (DL_FUNC) &_isotree_call_reconstruct_csr_sliced, 5},
    {""_isotree_call_reconstruct_csr_with_categ"", (DL_FUNC) &_isotree_call_reconstruct_csr_with_categ, 11},
    {""_isotree_deepcopy_vector"", (DL_FUNC) &_isotree_deepcopy_vector, 1},
    {""_isotree_call_take_cols_by_slice_csr"", (DL_FUNC) &_isotree_call_take_cols_by_slice_csr, 5},
    {""_isotree_call_take_cols_by_index_csr"", (DL_FUNC) &_isotree_call_take_cols_by_index_csr, 5},
    {""_isotree_call_take_cols_by_slice_csc"", (DL_FUNC) &_isotree_call_take_cols_by_slice_csc, 6},
    {""_isotree_call_take_cols_by_index_csc"", (DL_FUNC) &_isotree_call_take_cols_by_index_csc, 6},
    {""_isotree_copy_csc_cols_by_slice"", (DL_FUNC) &_isotree_copy_csc_cols_by_slice, 5},
    {""_isotree_copy_csc_cols_by_index"", (DL_FUNC) &_isotree_copy_csc_cols_by_index, 5},
    {""_isotree_assign_csc_cols"", (DL_FUNC) &_isotree_assign_csc_cols, 7},
    {""_isotree_get_empty_tmat"", (DL_FUNC) &_isotree_get_empty_tmat, 1},
    {""_isotree_get_empty_int_mat"", (DL_FUNC) &_isotree_get_empty_int_mat, 2},
    {""_isotree_get_null_int_mat"", (DL_FUNC) &_isotree_get_null_int_mat, 0},
    {""_isotree_get_ntrees"", (DL_FUNC) &_isotree_get_ntrees, 2},
    {""_isotree_deepcopy_int"", (DL_FUNC) &_isotree_deepcopy_int, 1},
    {""_isotree_modify_R_list_inplace"", (DL_FUNC) &_isotree_modify_R_list_inplace, 3},
    {""_isotree_addto_R_list_inplace"", (DL_FUNC) &_isotree_addto_R_list_inplace, 3},
    {""_isotree_R_has_openmp"", (DL_FUNC) &_isotree_R_has_openmp, 0},
    {NULL, NULL, 0}
};

RcppExport void R_init_isotree(DllInfo *dll) {
    R_registerRoutines(dll, NULL, CallEntries, NULL, NULL);
    R_useDynamicSymbols(dll, FALSE);
}
",16179,True,3624.6585084455246,median
"// Copyright 2016 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com

#include ""core/fpdfapi/render/cpdf_renderstatus.h""

#include <algorithm>
#include <cmath>
#include <limits>
#include <memory>
#include <numeric>
#include <set>
#include <utility>
#include <vector>

#include ""build/build_config.h""
#include ""constants/transparency.h""
#include ""core/fpdfapi/font/cpdf_font.h""
#include ""core/fpdfapi/font/cpdf_type3char.h""
#include ""core/fpdfapi/font/cpdf_type3font.h""
#include ""core/fpdfapi/page/cpdf_docpagedata.h""
#include ""core/fpdfapi/page/cpdf_form.h""
#include ""core/fpdfapi/page/cpdf_formobject.h""
#include ""core/fpdfapi/page/cpdf_function.h""
#include ""core/fpdfapi/page/cpdf_graphicstates.h""
#include ""core/fpdfapi/page/cpdf_image.h""
#include ""core/fpdfapi/page/cpdf_imageobject.h""
#include ""core/fpdfapi/page/cpdf_occontext.h""
#include ""core/fpdfapi/page/cpdf_page.h""
#include ""core/fpdfapi/page/cpdf_pageobject.h""
#include ""core/fpdfapi/page/cpdf_pathobject.h""
#include ""core/fpdfapi/page/cpdf_shadingobject.h""
#include ""core/fpdfapi/page/cpdf_shadingpattern.h""
#include ""core/fpdfapi/page/cpdf_textobject.h""
#include ""core/fpdfapi/page/cpdf_tilingpattern.h""
#include ""core/fpdfapi/page/cpdf_transferfunc.h""
#include ""core/fpdfapi/parser/cpdf_array.h""
#include ""core/fpdfapi/parser/cpdf_document.h""
#include ""core/fpdfapi/parser/cpdf_stream.h""
#include ""core/fpdfapi/parser/fpdf_parser_utility.h""
#include ""core/fpdfapi/render/charposlist.h""
#include ""core/fpdfapi/render/cpdf_docrenderdata.h""
#include ""core/fpdfapi/render/cpdf_imagerenderer.h""
#include ""core/fpdfapi/render/cpdf_pagerendercache.h""
#include ""core/fpdfapi/render/cpdf_rendercontext.h""
#include ""core/fpdfapi/render/cpdf_renderoptions.h""
#include ""core/fpdfapi/render/cpdf_rendershading.h""
#include ""core/fpdfapi/render/cpdf_scaledrenderbuffer.h""
#include ""core/fpdfapi/render/cpdf_textrenderer.h""
#include ""core/fpdfapi/render/cpdf_type3cache.h""
#include ""core/fxcrt/autorestorer.h""
#include ""core/fxcrt/fx_safe_types.h""
#include ""core/fxcrt/fx_system.h""
#include ""core/fxge/cfx_defaultrenderdevice.h""
#include ""core/fxge/cfx_glyphbitmap.h""
#include ""core/fxge/cfx_pathdata.h""
#include ""core/fxge/dib/cfx_dibitmap.h""
#include ""core/fxge/fx_font.h""
#include ""core/fxge/renderdevicedriver_iface.h""
#include ""core/fxge/text_char_pos.h""
#include ""core/fxge/text_glyph_pos.h""
#include ""third_party/base/compiler_specific.h""
#include ""third_party/base/logging.h""
#include ""third_party/base/stl_util.h""

#ifdef _SKIA_SUPPORT_
#include ""core/fxge/skia/fx_skia_device.h""
#endif

namespace {

constexpr int kRenderMaxRecursionDepth = 64;
int g_CurrentRecursionDepth = 0;

RetainPtr<CFX_DIBitmap> DrawPatternBitmap(
    CPDF_Document* pDoc,
    CPDF_PageRenderCache* pCache,
    CPDF_TilingPattern* pPattern,
    CPDF_Form* pPatternForm,
    const CFX_Matrix& mtObject2Device,
    int width,
    int height,
    const CPDF_RenderOptions::Options& draw_options) {
  auto pBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
  if (!pBitmap->Create(width, height,
                       pPattern->colored() ? FXDIB_Argb : FXDIB_8bppMask)) {
    return nullptr;
  }
  CFX_DefaultRenderDevice bitmap_device;
  bitmap_device.Attach(pBitmap, false, nullptr, false);
  pBitmap->Clear(0);
  CFX_FloatRect cell_bbox =
      pPattern->pattern_to_form().TransformRect(pPattern->bbox());
  cell_bbox = mtObject2Device.TransformRect(cell_bbox);
  CFX_FloatRect bitmap_rect(0.0f, 0.0f, width, height);
  CFX_Matrix mtAdjust;
  mtAdjust.MatchRect(bitmap_rect, cell_bbox);

  CFX_Matrix mtPattern2Bitmap = mtObject2Device * mtAdjust;
  CPDF_RenderOptions options;
  if (!pPattern->colored())
    options.SetColorMode(CPDF_RenderOptions::kAlpha);

  options.GetOptions() = draw_options;
  options.GetOptions().bForceHalftone = true;

  CPDF_RenderContext context(pDoc, nullptr, pCache);
  context.AppendLayer(pPatternForm, &mtPattern2Bitmap);
  context.Render(&bitmap_device, &options, nullptr);
#if defined _SKIA_SUPPORT_PATHS_
  bitmap_device.Flush(true);
  pBitmap->UnPreMultiply();
#endif
  return pBitmap;
}

int GetFillRenderOptionsHelper(const CPDF_RenderOptions::Options& options,
                               const CPDF_PathObject* path_obj,
                               int fill_type,
                               bool is_stroke,
                               bool is_type3_char) {
  int fill_options = fill_type;
  if (fill_type && options.bRectAA)
    fill_options |= FXFILL_RECT_AA;
  if (options.bNoPathSmooth)
    fill_options |= FXFILL_NOPATHSMOOTH;
  if (path_obj->m_GeneralState.GetStrokeAdjust())
    fill_options |= FX_STROKE_ADJUST;
  if (is_stroke)
    fill_options |= FX_FILL_STROKE;
  if (is_type3_char)
    fill_options |= FX_FILL_TEXT_MODE;

  return fill_options;
}

bool IsAvailableMatrix(const CFX_Matrix& matrix) {
  if (matrix.a == 0 || matrix.d == 0)
    return matrix.b != 0 && matrix.c != 0;

  if (matrix.b == 0 || matrix.c == 0)
    return matrix.a != 0 && matrix.d != 0;

  return true;
}

bool MissingFillColor(const CPDF_ColorState* pColorState) {
  return !pColorState->HasRef() || pColorState->GetFillColor()->IsNull();
}

bool MissingStrokeColor(const CPDF_ColorState* pColorState) {
  return !pColorState->HasRef() || pColorState->GetStrokeColor()->IsNull();
}

bool Type3CharMissingFillColor(const CPDF_Type3Char* pChar,
                               const CPDF_ColorState* pColorState) {
  return pChar && (!pChar->colored() || MissingFillColor(pColorState));
}

bool Type3CharMissingStrokeColor(const CPDF_Type3Char* pChar,
                                 const CPDF_ColorState* pColorState) {
  return pChar && (!pChar->colored() || MissingStrokeColor(pColorState));
}

#if defined(_SKIA_SUPPORT_) || defined(_SKIA_SUPPORT_PATHS_)
class ScopedSkiaDeviceFlush {
 public:
  explicit ScopedSkiaDeviceFlush(CFX_RenderDevice* pDevice)
      : m_pDevice(pDevice) {}

  ScopedSkiaDeviceFlush(const ScopedSkiaDeviceFlush&) = delete;
  ScopedSkiaDeviceFlush& operator=(const ScopedSkiaDeviceFlush&) = delete;

  ~ScopedSkiaDeviceFlush() { m_pDevice->Flush(/*release=*/false); }

 private:
  CFX_RenderDevice* const m_pDevice;
};
#endif

}  // namespace

CPDF_RenderStatus::CPDF_RenderStatus(CPDF_RenderContext* pContext,
                                     CFX_RenderDevice* pDevice)
    : m_pContext(pContext), m_pDevice(pDevice) {}

CPDF_RenderStatus::~CPDF_RenderStatus() = default;

void CPDF_RenderStatus::Initialize(const CPDF_RenderStatus* pParentStatus,
                                   const CPDF_GraphicStates* pInitialStates) {
  m_bPrint = m_pDevice->GetDeviceType() != DeviceType::kDisplay;
  m_pPageResource.Reset(m_pContext->GetPageResources());
  if (pInitialStates && !m_pType3Char) {
    m_InitialStates.CopyStates(*pInitialStates);
    if (pParentStatus) {
      if (!m_InitialStates.m_ColorState.HasFillColor()) {
        m_InitialStates.m_ColorState.SetFillColorRef(
            pParentStatus->m_InitialStates.m_ColorState.GetFillColorRef());
        *m_InitialStates.m_ColorState.GetMutableFillColor() =
            *pParentStatus->m_InitialStates.m_ColorState.GetFillColor();
      }
      if (!m_InitialStates.m_ColorState.HasStrokeColor()) {
        m_InitialStates.m_ColorState.SetStrokeColorRef(
            pParentStatus->m_InitialStates.m_ColorState.GetFillColorRef());
        *m_InitialStates.m_ColorState.GetMutableStrokeColor() =
            *pParentStatus->m_InitialStates.m_ColorState.GetStrokeColor();
      }
    }
  } else {
    m_InitialStates.DefaultStates();
  }
}

void CPDF_RenderStatus::RenderObjectList(
    const CPDF_PageObjectHolder* pObjectHolder,
    const CFX_Matrix& mtObj2Device) {
#if defined _SKIA_SUPPORT_
  DebugVerifyDeviceIsPreMultiplied();
#endif
  CFX_FloatRect clip_rect = mtObj2Device.GetInverse().TransformRect(
      CFX_FloatRect(m_pDevice->GetClipBox()));
  for (const auto& pCurObj : *pObjectHolder) {
    if (pCurObj.get() == m_pStopObj) {
      m_bStopped = true;
      return;
    }
    if (!pCurObj)
      continue;

    if (pCurObj->GetRect().left > clip_rect.right ||
        pCurObj->GetRect().right < clip_rect.left ||
        pCurObj->GetRect().bottom > clip_rect.top ||
        pCurObj->GetRect().top < clip_rect.bottom) {
      continue;
    }
    RenderSingleObject(pCurObj.get(), mtObj2Device);
    if (m_bStopped)
      return;
  }
#if defined _SKIA_SUPPORT_
  DebugVerifyDeviceIsPreMultiplied();
#endif
}

void CPDF_RenderStatus::RenderSingleObject(CPDF_PageObject* pObj,
                                           const CFX_Matrix& mtObj2Device) {
#if defined _SKIA_SUPPORT_
  DebugVerifyDeviceIsPreMultiplied();
#endif
  AutoRestorer<int> restorer(&g_CurrentRecursionDepth);
  if (++g_CurrentRecursionDepth > kRenderMaxRecursionDepth) {
    return;
  }
  m_pCurObj = pObj;
  if (m_Options.GetOCContext() &&
      !m_Options.GetOCContext()->CheckObjectVisible(pObj)) {
    return;
  }
  ProcessClipPath(pObj->m_ClipPath, mtObj2Device);
  if (ProcessTransparency(pObj, mtObj2Device)) {
    return;
  }
  ProcessObjectNoClip(pObj, mtObj2Device);
#if defined _SKIA_SUPPORT_
  DebugVerifyDeviceIsPreMultiplied();
#endif
}

bool CPDF_RenderStatus::ContinueSingleObject(CPDF_PageObject* pObj,
                                             const CFX_Matrix& mtObj2Device,
                                             PauseIndicatorIface* pPause) {
  if (m_pImageRenderer) {
    if (m_pImageRenderer->Continue(pPause))
      return true;

    if (!m_pImageRenderer->GetResult())
      DrawObjWithBackground(pObj, mtObj2Device);
    m_pImageRenderer.reset();
    return false;
  }

  m_pCurObj = pObj;
  if (m_Options.GetOCContext() &&
      !m_Options.GetOCContext()->CheckObjectVisible(pObj)) {
    return false;
  }

  ProcessClipPath(pObj->m_ClipPath, mtObj2Device);
  if (ProcessTransparency(pObj, mtObj2Device))
    return false;

  if (!pObj->IsImage()) {
    ProcessObjectNoClip(pObj, mtObj2Device);
    return false;
  }

  m_pImageRenderer = std::make_unique<CPDF_ImageRenderer>();
  if (!m_pImageRenderer->Start(this, pObj->AsImage(), mtObj2Device, false,
                               BlendMode::kNormal)) {
    if (!m_pImageRenderer->GetResult())
      DrawObjWithBackground(pObj, mtObj2Device);
    m_pImageRenderer.reset();
    return false;
  }
  return ContinueSingleObject(pObj, mtObj2Device, pPause);
}

FX_RECT CPDF_RenderStatus::GetObjectClippedRect(
    const CPDF_PageObject* pObj,
    const CFX_Matrix& mtObj2Device) const {
  FX_RECT rect = pObj->GetTransformedBBox(mtObj2Device);
  rect.Intersect(m_pDevice->GetClipBox());
  return rect;
}

void CPDF_RenderStatus::ProcessObjectNoClip(CPDF_PageObject* pObj,
                                            const CFX_Matrix& mtObj2Device) {
#if defined _SKIA_SUPPORT_
  DebugVerifyDeviceIsPreMultiplied();
#endif
  bool bRet = false;
  switch (pObj->GetType()) {
    case CPDF_PageObject::TEXT:
      bRet = ProcessText(pObj->AsText(), mtObj2Device, nullptr);
      break;
    case CPDF_PageObject::PATH:
      bRet = ProcessPath(pObj->AsPath(), mtObj2Device);
      break;
    case CPDF_PageObject::IMAGE:
      bRet = ProcessImage(pObj->AsImage(), mtObj2Device);
      break;
    case CPDF_PageObject::SHADING:
      ProcessShading(pObj->AsShading(), mtObj2Device);
      return;
    case CPDF_PageObject::FORM:
      bRet = ProcessForm(pObj->AsForm(), mtObj2Device);
      break;
  }
  if (!bRet)
    DrawObjWithBackground(pObj, mtObj2Device);
#if defined _SKIA_SUPPORT_
  DebugVerifyDeviceIsPreMultiplied();
#endif
}

bool CPDF_RenderStatus::DrawObjWithBlend(CPDF_PageObject* pObj,
                                         const CFX_Matrix& mtObj2Device) {
  switch (pObj->GetType()) {
    case CPDF_PageObject::PATH:
      return ProcessPath(pObj->AsPath(), mtObj2Device);
    case CPDF_PageObject::IMAGE:
      return ProcessImage(pObj->AsImage(), mtObj2Device);
    case CPDF_PageObject::FORM:
      return ProcessForm(pObj->AsForm(), mtObj2Device);
    default:
      return false;
  }
}

void CPDF_RenderStatus::DrawObjWithBackground(CPDF_PageObject* pObj,
                                              const CFX_Matrix& mtObj2Device) {
  FX_RECT rect = GetObjectClippedRect(pObj, mtObj2Device);
  if (rect.IsEmpty())
    return;

  int res = (pObj->IsImage() && m_bPrint) ? 0 : 300;
  CPDF_ScaledRenderBuffer buffer;
  if (!buffer.Initialize(m_pContext.Get(), m_pDevice, rect, pObj, &m_Options,
                         res)) {
    return;
  }
  CFX_Matrix matrix = mtObj2Device * buffer.GetMatrix();
  const CPDF_Dictionary* pFormResource = nullptr;
  const CPDF_FormObject* pFormObj = pObj->AsForm();
  if (pFormObj)
    pFormResource = pFormObj->form()->GetDict()->GetDictFor(""Resources"");
  CPDF_RenderStatus status(m_pContext.Get(), buffer.GetDevice());
  status.SetOptions(m_Options);
  status.SetDeviceMatrix(buffer.GetMatrix());
  status.SetTransparency(m_Transparency);
  status.SetDropObjects(m_bDropObjects);
  status.SetFormResource(pFormResource);
  status.Initialize(nullptr, nullptr);
  status.RenderSingleObject(pObj, matrix);
  buffer.OutputToDevice();
}

bool CPDF_RenderStatus::ProcessForm(const CPDF_FormObject* pFormObj,
                                    const CFX_Matrix& mtObj2Device) {
#if defined _SKIA_SUPPORT_
  DebugVerifyDeviceIsPreMultiplied();
#endif
  const CPDF_Dictionary* pOC = pFormObj->form()->GetDict()->GetDictFor(""OC"");
  if (pOC && m_Options.GetOCContext() &&
      !m_Options.GetOCContext()->CheckOCGVisible(pOC)) {
    return true;
  }
  CFX_Matrix matrix = pFormObj->form_matrix() * mtObj2Device;
  const CPDF_Dictionary* pResources =
      pFormObj->form()->GetDict()->GetDictFor(""Resources"");
  CPDF_RenderStatus status(m_pContext.Get(), m_pDevice);
  status.SetOptions(m_Options);
  status.SetStopObject(m_pStopObj.Get());
  status.SetTransparency(m_Transparency);
  status.SetDropObjects(m_bDropObjects);
  status.SetFormResource(pResources);
  status.Initialize(this, pFormObj);
  status.m_curBlend = m_curBlend;
  {
    CFX_RenderDevice::StateRestorer restorer(m_pDevice);
    status.RenderObjectList(pFormObj->form(), matrix);
    m_bStopped = status.m_bStopped;
  }
#if defined _SKIA_SUPPORT_
  DebugVerifyDeviceIsPreMultiplied();
#endif
  return true;
}

bool CPDF_RenderStatus::ProcessPath(CPDF_PathObject* pPathObj,
                                    const CFX_Matrix& mtObj2Device) {
  // Path fill type, can be 0, FXFILL_ALTERNATE or FXFILL_WINDING.
  int FillType = pPathObj->filltype();
  bool bStroke = pPathObj->stroke();
  ProcessPathPattern(pPathObj, mtObj2Device, &FillType, &bStroke);
  if (FillType == 0 && !bStroke)
    return true;

  // If the option to convert fill paths to stroke is enabled for forced color,
  // set |FillType| to 0 and |bStroke| to true.
  CPDF_RenderOptions::Options& options = m_Options.GetOptions();
  if (m_Options.ColorModeIs(CPDF_RenderOptions::Type::kForcedColor) &&
      options.bConvertFillToStroke && (FillType != 0)) {
    bStroke = true;
    FillType = 0;
  }

  uint32_t fill_argb = FillType ? GetFillArgb(pPathObj) : 0;
  uint32_t stroke_argb = bStroke ? GetStrokeArgb(pPathObj) : 0;
  CFX_Matrix path_matrix = pPathObj->matrix() * mtObj2Device;
  if (!IsAvailableMatrix(path_matrix))
    return true;

  int fill_options = GetFillRenderOptionsHelper(options, pPathObj, FillType,
                                                bStroke, m_pType3Char);
  return m_pDevice->DrawPathWithBlend(
      pPathObj->path().GetObject(), &path_matrix,
      pPathObj->m_GraphState.GetObject(), fill_argb, stroke_argb, fill_options,
      m_curBlend);
}

RetainPtr<CPDF_TransferFunc> CPDF_RenderStatus::GetTransferFunc(
    const CPDF_Object* pObj) const {
  ASSERT(pObj);
  auto* pDocCache = CPDF_DocRenderData::FromDocument(m_pContext->GetDocument());
  return pDocCache ? pDocCache->GetTransferFunc(pObj) : nullptr;
}

FX_ARGB CPDF_RenderStatus::GetFillArgbInternal(CPDF_PageObject* pObj,
                                               bool bType3) const {
  const CPDF_ColorState* pColorState = &pObj->m_ColorState;
  if (!bType3 && Type3CharMissingFillColor(m_pType3Char.Get(), pColorState))
    return m_T3FillColor;

  if (MissingFillColor(pColorState))
    pColorState = &m_InitialStates.m_ColorState;

  FX_COLORREF colorref = pColorState->GetFillColorRef();
  if (colorref == 0xFFFFFFFF)
    return 0;

  int32_t alpha =
      static_cast<int32_t>((pObj->m_GeneralState.GetFillAlpha() * 255));
  if (pObj->m_GeneralState.GetTR()) {
    if (!pObj->m_GeneralState.GetTransferFunc()) {
      pObj->m_GeneralState.SetTransferFunc(
          GetTransferFunc(pObj->m_GeneralState.GetTR()));
    }
    if (pObj->m_GeneralState.GetTransferFunc()) {
      colorref =
          pObj->m_GeneralState.GetTransferFunc()->TranslateColor(colorref);
    }
  }
  return m_Options.TranslateObjectColor(AlphaAndColorRefToArgb(alpha, colorref),
                                        pObj->GetType(),
                                        CPDF_RenderOptions::RenderType::kFill);
}

FX_ARGB CPDF_RenderStatus::GetStrokeArgb(CPDF_PageObject* pObj) const {
  const CPDF_ColorState* pColorState = &pObj->m_ColorState;
  if (Type3CharMissingStrokeColor(m_pType3Char.Get(), pColorState))
    return m_T3FillColor;

  if (MissingStrokeColor(pColorState))
    pColorState = &m_InitialStates.m_ColorState;

  FX_COLORREF colorref = pColorState->GetStrokeColorRef();
  if (colorref == 0xFFFFFFFF)
    return 0;

  int32_t alpha = static_cast<int32_t>(pObj->m_GeneralState.GetStrokeAlpha() *
                                       255);  // not rounded.
  if (pObj->m_GeneralState.GetTR()) {
    if (!pObj->m_GeneralState.GetTransferFunc()) {
      pObj->m_GeneralState.SetTransferFunc(
          GetTransferFunc(pObj->m_GeneralState.GetTR()));
    }
    if (pObj->m_GeneralState.GetTransferFunc()) {
      colorref =
          pObj->m_GeneralState.GetTransferFunc()->TranslateColor(colorref);
    }
  }
  return m_Options.TranslateObjectColor(
      AlphaAndColorRefToArgb(alpha, colorref), pObj->GetType(),
      CPDF_RenderOptions::RenderType::kStroke);
}

void CPDF_RenderStatus::ProcessClipPath(const CPDF_ClipPath& ClipPath,
                                        const CFX_Matrix& mtObj2Device) {
  if (!ClipPath.HasRef()) {
    if (m_LastClipPath.HasRef()) {
      m_pDevice->RestoreState(true);
      m_LastClipPath.SetNull();
    }
    return;
  }
  if (m_LastClipPath == ClipPath)
    return;

  m_LastClipPath = ClipPath;
  m_pDevice->RestoreState(true);
  for (size_t i = 0; i < ClipPath.GetPathCount(); ++i) {
    const CFX_PathData* pPathData = ClipPath.GetPath(i).GetObject();
    if (!pPathData)
      continue;

    if (pPathData->GetPoints().empty()) {
      CFX_PathData EmptyPath;
      EmptyPath.AppendRect(-1, -1, 0, 0);
      m_pDevice->SetClip_PathFill(&EmptyPath, nullptr, FXFILL_WINDING);
    } else {
      m_pDevice->SetClip_PathFill(pPathData, &mtObj2Device,
                                  ClipPath.GetClipType(i));
    }
  }

  if (ClipPath.GetTextCount() == 0)
    return;

  if (!m_bPrint &&
      !(m_pDevice->GetDeviceCaps(FXDC_RENDER_CAPS) & FXRC_SOFT_CLIP)) {
    return;
  }

  std::unique_ptr<CFX_PathData> pTextClippingPath;
  for (size_t i = 0; i < ClipPath.GetTextCount(); ++i) {
    CPDF_TextObject* pText = ClipPath.GetText(i);
    if (pText) {
      if (!pTextClippingPath)
        pTextClippingPath = std::make_unique<CFX_PathData>();
      ProcessText(pText, mtObj2Device, pTextClippingPath.get());
      continue;
    }

    if (!pTextClippingPath)
      continue;

    int fill_mode = FXFILL_WINDING;
    if (m_Options.GetOptions().bNoTextSmooth)
      fill_mode |= FXFILL_NOPATHSMOOTH;
    m_pDevice->SetClip_PathFill(pTextClippingPath.get(), nullptr, fill_mode);
    pTextClippingPath.reset();
  }
}

bool CPDF_RenderStatus::ClipPattern(const CPDF_PageObject* pPageObj,
                                    const CFX_Matrix& mtObj2Device,
                                    bool bStroke) {
  if (pPageObj->IsPath())
    return SelectClipPath(pPageObj->AsPath(), mtObj2Device, bStroke);
  if (pPageObj->IsImage()) {
    m_pDevice->SetClip_Rect(pPageObj->GetTransformedBBox(mtObj2Device));
    return true;
  }
  return false;
}

bool CPDF_RenderStatus::SelectClipPath(const CPDF_PathObject* pPathObj,
                                       const CFX_Matrix& mtObj2Device,
                                       bool bStroke) {
  CFX_Matrix path_matrix = pPathObj->matrix() * mtObj2Device;
  if (bStroke) {
    return m_pDevice->SetClip_PathStroke(pPathObj->path().GetObject(),
                                         &path_matrix,
                                         pPathObj->m_GraphState.GetObject());
  }
  int fill_mode = pPathObj->filltype();
  if (m_Options.GetOptions().bNoPathSmooth) {
    fill_mode |= FXFILL_NOPATHSMOOTH;
  }
  return m_pDevice->SetClip_PathFill(pPathObj->path().GetObject(), &path_matrix,
                                     fill_mode);
}

bool CPDF_RenderStatus::ProcessTransparency(CPDF_PageObject* pPageObj,
                                            const CFX_Matrix& mtObj2Device) {
#if defined _SKIA_SUPPORT_
  DebugVerifyDeviceIsPreMultiplied();
#endif
  const BlendMode blend_type = pPageObj->m_GeneralState.GetBlendType();
  CPDF_Dictionary* pSMaskDict =
      ToDictionary(pPageObj->m_GeneralState.GetSoftMask());
  if (pSMaskDict) {
    if (pPageObj->IsImage() &&
        pPageObj->AsImage()->GetImage()->GetDict()->KeyExist(""SMask"")) {
      pSMaskDict = nullptr;
    }
  }
  const CPDF_Dictionary* pFormResource = nullptr;
  float group_alpha = 1.0f;
  CPDF_Transparency transparency = m_Transparency;
  bool bGroupTransparent = false;
  const CPDF_FormObject* pFormObj = pPageObj->AsForm();
  if (pFormObj) {
    group_alpha = pFormObj->m_GeneralState.GetFillAlpha();
    transparency = pFormObj->form()->GetTransparency();
    bGroupTransparent = transparency.IsIsolated();
    pFormResource = pFormObj->form()->GetDict()->GetDictFor(""Resources"");
  }
  bool bTextClip =
      (pPageObj->m_ClipPath.HasRef() &&
       pPageObj->m_ClipPath.GetTextCount() > 0 && !m_bPrint &&
       !(m_pDevice->GetDeviceCaps(FXDC_RENDER_CAPS) & FXRC_SOFT_CLIP));
  if (!pSMaskDict && group_alpha == 1.0f && blend_type == BlendMode::kNormal &&
      !bTextClip && !bGroupTransparent) {
    return false;
  }
  if (m_bPrint) {
    bool bRet = false;
    int rendCaps = m_pDevice->GetRenderCaps();
    if (!(transparency.IsIsolated() || pSMaskDict || bTextClip) &&
        (rendCaps & FXRC_BLEND_MODE)) {
      BlendMode oldBlend = m_curBlend;
      m_curBlend = blend_type;
      bRet = DrawObjWithBlend(pPageObj, mtObj2Device);
      m_curBlend = oldBlend;
    }
    if (!bRet) {
      DrawObjWithBackground(pPageObj, mtObj2Device);
    }
    return true;
  }
  FX_RECT rect = pPageObj->GetTransformedBBox(mtObj2Device);
  rect.Intersect(m_pDevice->GetClipBox());
  if (rect.IsEmpty())
    return true;

  int width = rect.Width();
  int height = rect.Height();
  CFX_DefaultRenderDevice bitmap_device;
  RetainPtr<CFX_DIBitmap> backdrop;
  if (!transparency.IsIsolated() &&
      (m_pDevice->GetRenderCaps() & FXRC_GET_BITS)) {
    backdrop = pdfium::MakeRetain<CFX_DIBitmap>();
    if (!m_pDevice->CreateCompatibleBitmap(backdrop, width, height))
      return true;
    m_pDevice->GetDIBits(backdrop, rect.left, rect.top);
  }
  if (!bitmap_device.Create(width, height, FXDIB_Argb, backdrop))
    return true;

  RetainPtr<CFX_DIBitmap> bitmap = bitmap_device.GetBitmap();
  bitmap->Clear(0);

  CFX_Matrix new_matrix = mtObj2Device;
  new_matrix.Translate(-rect.left, -rect.top);

  RetainPtr<CFX_DIBitmap> pTextMask;
  if (bTextClip) {
    pTextMask = pdfium::MakeRetain<CFX_DIBitmap>();
    if (!pTextMask->Create(width, height, FXDIB_8bppMask))
      return true;

    pTextMask->Clear(0);
    CFX_DefaultRenderDevice text_device;
    text_device.Attach(pTextMask, false, nullptr, false);
    for (size_t i = 0; i < pPageObj->m_ClipPath.GetTextCount(); ++i) {
      CPDF_TextObject* textobj = pPageObj->m_ClipPath.GetText(i);
      if (!textobj)
        break;

      // TODO(thestig): Should we check the return value here?
      CPDF_TextRenderer::DrawTextPath(
          &text_device, textobj->GetCharCodes(), textobj->GetCharPositions(),
          textobj->m_TextState.GetFont().Get(),
          textobj->m_TextState.GetFontSize(), textobj->GetTextMatrix(),
          &new_matrix, textobj->m_GraphState.GetObject(), 0xffffffff, 0,
          nullptr, 0);
    }
  }
  CPDF_RenderStatus bitmap_render(m_pContext.Get(), &bitmap_device);
  bitmap_render.SetOptions(m_Options);
  bitmap_render.SetStopObject(m_pStopObj.Get());
  bitmap_render.SetStdCS(true);
  bitmap_render.SetDropObjects(m_bDropObjects);
  bitmap_render.SetFormResource(pFormResource);
  bitmap_render.Initialize(nullptr, nullptr);
  bitmap_render.ProcessObjectNoClip(pPageObj, new_matrix);
#if defined _SKIA_SUPPORT_PATHS_
  bitmap_device.Flush(true);
  bitmap->UnPreMultiply();
#endif
  m_bStopped = bitmap_render.m_bStopped;
  if (pSMaskDict) {
    CFX_Matrix smask_matrix =
        *pPageObj->m_GeneralState.GetSMaskMatrix() * mtObj2Device;
    RetainPtr<CFX_DIBBase> pSMaskSource =
        LoadSMask(pSMaskDict, &rect, &smask_matrix);
    if (pSMaskSource)
      bitmap->MultiplyAlpha(pSMaskSource);
  }
  if (pTextMask) {
    bitmap->MultiplyAlpha(pTextMask);
    pTextMask.Reset();
  }
  int32_t blitAlpha = 255;
  if (group_alpha != 1.0f && transparency.IsGroup()) {
    blitAlpha = (int32_t)(group_alpha * 255);
#ifndef _SKIA_SUPPORT_
    bitmap->MultiplyAlpha(blitAlpha);
    blitAlpha = 255;
#endif
  }
  transparency = m_Transparency;
  if (pPageObj->IsForm()) {
    transparency.SetGroup();
  }
  CompositeDIBitmap(bitmap, rect.left, rect.top, 0, blitAlpha, blend_type,
                    transparency);
#if defined _SKIA_SUPPORT_
  DebugVerifyDeviceIsPreMultiplied();
#endif
  return true;
}

RetainPtr<CFX_DIBitmap> CPDF_RenderStatus::GetBackdrop(
    const CPDF_PageObject* pObj,
    const FX_RECT& rect,
    bool bBackAlphaRequired,
    int* left,
    int* top) {
  FX_RECT bbox = rect;
  bbox.Intersect(m_pDevice->GetClipBox());
  *left = bbox.left;
  *top = bbox.top;
  int width = bbox.Width();
  int height = bbox.Height();
  auto pBackdrop = pdfium::MakeRetain<CFX_DIBitmap>();
  if (bBackAlphaRequired && !m_bDropObjects)
    pBackdrop->Create(width, height, FXDIB_Argb);
  else
    m_pDevice->CreateCompatibleBitmap(pBackdrop, width, height);

  if (!pBackdrop->GetBuffer())
    return nullptr;

  bool bNeedDraw;
  if (pBackdrop->HasAlpha())
    bNeedDraw = !(m_pDevice->GetRenderCaps() & FXRC_ALPHA_OUTPUT);
  else
    bNeedDraw = !(m_pDevice->GetRenderCaps() & FXRC_GET_BITS);

  if (!bNeedDraw) {
    m_pDevice->GetDIBits(pBackdrop, *left, *top);
    return pBackdrop;
  }
  CFX_Matrix FinalMatrix = m_DeviceMatrix;
  FinalMatrix.Translate(-*left, -*top);
  pBackdrop->Clear(pBackdrop->HasAlpha() ? 0 : 0xffffffff);

  CFX_DefaultRenderDevice device;
  device.Attach(pBackdrop, false, nullptr, false);
  m_pContext->Render(&device, pObj, &m_Options, &FinalMatrix);
  return pBackdrop;
}

std::unique_ptr<CPDF_GraphicStates> CPDF_RenderStatus::CloneObjStates(
    const CPDF_GraphicStates* pSrcStates,
    bool bStroke) {
  if (!pSrcStates)
    return nullptr;

  auto pStates = std::make_unique<CPDF_GraphicStates>();
  pStates->CopyStates(*pSrcStates);
  const CPDF_Color* pObjColor = bStroke
                                    ? pSrcStates->m_ColorState.GetStrokeColor()
                                    : pSrcStates->m_ColorState.GetFillColor();
  if (!pObjColor->IsNull()) {
    pStates->m_ColorState.SetFillColorRef(
        bStroke ? pSrcStates->m_ColorState.GetStrokeColorRef()
                : pSrcStates->m_ColorState.GetFillColorRef());
    pStates->m_ColorState.SetStrokeColorRef(
        pStates->m_ColorState.GetFillColorRef());
  }
  return pStates;
}

#if defined _SKIA_SUPPORT_
void CPDF_RenderStatus::DebugVerifyDeviceIsPreMultiplied() const {
  m_pDevice->DebugVerifyBitmapIsPreMultiplied();
}
#endif

bool CPDF_RenderStatus::ProcessText(CPDF_TextObject* textobj,
                                    const CFX_Matrix& mtObj2Device,
                                    CFX_PathData* pClippingPath) {
  if (textobj->GetCharCodes().empty())
    return true;

  const TextRenderingMode text_render_mode = textobj->m_TextState.GetTextMode();
  if (text_render_mode == TextRenderingMode::MODE_INVISIBLE)
    return true;

  RetainPtr<CPDF_Font> pFont = textobj->m_TextState.GetFont();
  if (pFont->IsType3Font())
    return ProcessType3Text(textobj, mtObj2Device);

  bool bFill = false;
  bool bStroke = false;
  bool bClip = false;
  if (pClippingPath) {
    bClip = true;
  } else {
    switch (text_render_mode) {
      case TextRenderingMode::MODE_FILL:
      case TextRenderingMode::MODE_FILL_CLIP:
        bFill = true;
        break;
      case TextRenderingMode::MODE_STROKE:
      case TextRenderingMode::MODE_STROKE_CLIP:
        if (pFont->HasFace())
          bStroke = true;
        else
          bFill = true;
        break;
      case TextRenderingMode::MODE_FILL_STROKE:
      case TextRenderingMode::MODE_FILL_STROKE_CLIP:
        bFill = true;
        if (pFont->HasFace())
          bStroke = true;
        break;
      case TextRenderingMode::MODE_INVISIBLE:
        // Already handled above, but the compiler is not smart enough to
        // realize it.
        NOTREACHED();
        return true;
      case TextRenderingMode::MODE_CLIP:
        return true;
      case TextRenderingMode::MODE_UNKNOWN:
        NOTREACHED();
        return false;
    }
  }
  FX_ARGB stroke_argb = 0;
  FX_ARGB fill_argb = 0;
  bool bPattern = false;
  if (bStroke) {
    if (textobj->m_ColorState.GetStrokeColor()->IsPattern()) {
      bPattern = true;
    } else {
      stroke_argb = GetStrokeArgb(textobj);
    }
  }
  if (bFill) {
    if (textobj->m_ColorState.GetFillColor()->IsPattern()) {
      bPattern = true;
    } else {
      fill_argb = GetFillArgb(textobj);
    }
  }
  CFX_Matrix text_matrix = textobj->GetTextMatrix();
  if (!IsAvailableMatrix(text_matrix))
    return true;

  float font_size = textobj->m_TextState.GetFontSize();
  if (bPattern) {
    DrawTextPathWithPattern(textobj, mtObj2Device, pFont.Get(), font_size,
                            &text_matrix, bFill, bStroke);
    return true;
  }
  if (bClip || bStroke) {
    const CFX_Matrix* pDeviceMatrix = &mtObj2Device;
    CFX_Matrix device_matrix;
    if (bStroke) {
      const float* pCTM = textobj->m_TextState.GetCTM();
      if (pCTM[0] != 1.0f || pCTM[3] != 1.0f) {
        CFX_Matrix ctm(pCTM[0], pCTM[1], pCTM[2], pCTM[3], 0, 0);
        text_matrix *= ctm.GetInverse();
        device_matrix = ctm * mtObj2Device;
        pDeviceMatrix = &device_matrix;
      }
    }
    int flag = 0;
    if (bStroke && bFill) {
      flag |= FX_FILL_STROKE;
      flag |= FX_STROKE_TEXT_MODE;
    }
    if (textobj->m_GeneralState.GetStrokeAdjust())
      flag |= FX_STROKE_ADJUST;
    if (m_Options.GetOptions().bNoTextSmooth)
      flag |= FXFILL_NOPATHSMOOTH;
    return CPDF_TextRenderer::DrawTextPath(
        m_pDevice, textobj->GetCharCodes(), textobj->GetCharPositions(),
        pFont.Get(), font_size, text_matrix, pDeviceMatrix,
        textobj->m_GraphState.GetObject(), fill_argb, stroke_argb,
        pClippingPath, flag);
  }
  text_matrix.Concat(mtObj2Device);
  return CPDF_TextRenderer::DrawNormalText(
      m_pDevice, textobj->GetCharCodes(), textobj->GetCharPositions(),
      pFont.Get(), font_size, text_matrix, fill_argb, m_Options);
}

// TODO(npm): Font fallback for type 3 fonts? (Completely separate code!!)
bool CPDF_RenderStatus::ProcessType3Text(CPDF_TextObject* textobj,
                                         const CFX_Matrix& mtObj2Device) {
  CPDF_Type3Font* pType3Font = textobj->m_TextState.GetFont()->AsType3Font();
  if (pdfium::Contains(m_Type3FontCache, pType3Font))
    return true;

  FX_ARGB fill_argb = GetFillArgbForType3(textobj);
  int fill_alpha = FXARGB_A(fill_argb);
  if (m_bPrint && fill_alpha < 255)
    return false;

  CFX_Matrix text_matrix = textobj->GetTextMatrix();
  CFX_Matrix char_matrix = pType3Font->GetFontMatrix();
  float font_size = textobj->m_TextState.GetFontSize();
  char_matrix.Scale(font_size, font_size);

  // Must come before |glyphs|, because |glyphs| points into |refTypeCache|.
  std::set<RetainPtr<CPDF_Type3Cache>> refTypeCache;
  std::vector<TextGlyphPos> glyphs;
  if (!m_bPrint)
    glyphs.resize(textobj->GetCharCodes().size());

  for (size_t iChar = 0; iChar < textobj->GetCharCodes().size(); ++iChar) {
    uint32_t charcode = textobj->GetCharCodes()[iChar];
    if (charcode == static_cast<uint32_t>(-1))
      continue;

    CPDF_Type3Char* pType3Char = pType3Font->LoadChar(charcode);
    if (!pType3Char)
      continue;

    CFX_Matrix matrix = char_matrix;
    matrix.e += iChar > 0 ? textobj->GetCharPositions()[iChar - 1] : 0;
    matrix.Concat(text_matrix);
    matrix.Concat(mtObj2Device);
    if (!pType3Char->LoadBitmapFromSoleImageOfForm()) {
      if (!glyphs.empty()) {
        for (size_t i = 0; i < iChar; ++i) {
          const TextGlyphPos& glyph = glyphs[i];
          if (!glyph.m_pGlyph)
            continue;

          Optional<CFX_Point> point = glyph.GetOrigin({0, 0});
          if (!point.has_value())
            continue;

          m_pDevice->SetBitMask(glyph.m_pGlyph->GetBitmap(), point->x, point->y,
                                fill_argb);
        }
        glyphs.clear();
      }

      std::unique_ptr<CPDF_GraphicStates> pStates =
          CloneObjStates(textobj, false);
      CPDF_RenderOptions options = m_Options;
      options.GetOptions().bForceHalftone = true;
      options.GetOptions().bRectAA = true;

      const auto* pForm = static_cast<const CPDF_Form*>(pType3Char->form());
      const CPDF_Dictionary* pFormResource =
          pForm->GetDict()->GetDictFor(""Resources"");

      if (fill_alpha == 255) {
        CPDF_RenderStatus status(m_pContext.Get(), m_pDevice);
        status.SetOptions(options);
        status.SetTransparency(pForm->GetTransparency());
        status.SetType3Char(pType3Char);
        status.SetFillColor(fill_argb);
        status.SetDropObjects(m_bDropObjects);
        status.SetFormResource(pFormResource);
        status.Initialize(this, pStates.get());
        status.m_Type3FontCache = m_Type3FontCache;
        status.m_Type3FontCache.push_back(pType3Font);

        CFX_RenderDevice::StateRestorer restorer(m_pDevice);
        status.RenderObjectList(pForm, matrix);
      } else {
        FX_RECT rect =
            matrix.TransformRect(pForm->CalcBoundingBox()).GetOuterRect();
        if (!rect.Valid())
          continue;

        CFX_DefaultRenderDevice bitmap_device;
        if (!bitmap_device.Create(rect.Width(), rect.Height(), FXDIB_Argb,
                                  nullptr)) {
          return true;
        }
        bitmap_device.GetBitmap()->Clear(0);
        CPDF_RenderStatus status(m_pContext.Get(), &bitmap_device);
        status.SetOptions(options);
        status.SetTransparency(pForm->GetTransparency());
        status.SetType3Char(pType3Char);
        status.SetFillColor(fill_argb);
        status.SetDropObjects(m_bDropObjects);
        status.SetFormResource(pFormResource);
        status.Initialize(this, pStates.get());
        status.m_Type3FontCache = m_Type3FontCache;
        status.m_Type3FontCache.push_back(pType3Font);
        matrix.Translate(-rect.left, -rect.top);
        status.RenderObjectList(pForm, matrix);
        m_pDevice->SetDIBits(bitmap_device.GetBitmap(), rect.left, rect.top);
      }
    } else if (pType3Char->GetBitmap()) {
      if (m_bPrint) {
        CFX_Matrix image_matrix = pType3Char->matrix() * matrix;
        CPDF_ImageRenderer renderer;
        if (renderer.Start(this, pType3Char->GetBitmap(), fill_argb, 255,
                           image_matrix, FXDIB_ResampleOptions(), false,
                           BlendMode::kNormal)) {
          renderer.Continue(nullptr);
        }
        if (!renderer.GetResult())
          return false;
      } else {
        CPDF_Document* pDoc = pType3Font->GetDocument();
        RetainPtr<CPDF_Type3Cache> pCache =
            CPDF_DocRenderData::FromDocument(pDoc)->GetCachedType3(pType3Font);

        const CFX_GlyphBitmap* pBitmap = pCache->LoadGlyph(charcode, &matrix);
        if (!pBitmap)
          continue;

        refTypeCache.insert(std::move(pCache));

        CFX_Point origin(FXSYS_roundf(matrix.e), FXSYS_roundf(matrix.f));
        if (glyphs.empty()) {
          FX_SAFE_INT32 left = origin.x;
          left += pBitmap->left();
          if (!left.IsValid())
            continue;

          FX_SAFE_INT32 top = origin.y;
          top -= pBitmap->top();
          if (!top.IsValid())
            continue;

          m_pDevice->SetBitMask(pBitmap->GetBitmap(), left.ValueOrDie(),
                                top.ValueOrDie(), fill_argb);
        } else {
          glyphs[iChar].m_pGlyph = pBitmap;
          glyphs[iChar].m_Origin = origin;
        }
      }
    }
  }

  if (glyphs.empty())
    return true;

  FX_RECT rect = GetGlyphsBBox(glyphs, 0);
  auto pBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
  if (!pBitmap->Create(rect.Width(), rect.Height(), FXDIB_8bppMask))
    return true;

  pBitmap->Clear(0);
  for (const TextGlyphPos& glyph : glyphs) {
    if (!glyph.m_pGlyph)
      continue;

    Optional<CFX_Point> point = glyph.GetOrigin({rect.left, rect.top});
    if (!point.has_value())
      continue;

    pBitmap->CompositeMask(
        point->x, point->y, glyph.m_pGlyph->GetBitmap()->GetWidth(),
        glyph.m_pGlyph->GetBitmap()->GetHeight(), glyph.m_pGlyph->GetBitmap(),
        fill_argb, 0, 0, BlendMode::kNormal, nullptr, false);
  }
  m_pDevice->SetBitMask(pBitmap, rect.left, rect.top, fill_argb);
  return true;
}

void CPDF_RenderStatus::DrawTextPathWithPattern(const CPDF_TextObject* textobj,
                                                const CFX_Matrix& mtObj2Device,
                                                CPDF_Font* pFont,
                                                float font_size,
                                                const CFX_Matrix* pTextMatrix,
                                                bool bFill,
                                                bool bStroke) {
  if (!bStroke) {
    std::vector<std::unique_ptr<CPDF_TextObject>> pCopy;
    pCopy.push_back(std::unique_ptr<CPDF_TextObject>(textobj->Clone()));

    CPDF_PathObject path;
    path.set_filltype(FXFILL_WINDING);
    path.m_ClipPath.CopyClipPath(m_LastClipPath);
    path.m_ClipPath.AppendTexts(&pCopy);
    path.m_ColorState = textobj->m_ColorState;
    path.m_GeneralState = textobj->m_GeneralState;
    path.path().AppendFloatRect(textobj->GetRect());
    path.SetRect(textobj->GetRect());

    AutoRestorer<UnownedPtr<const CPDF_PageObject>> restorer2(&m_pCurObj);
    RenderSingleObject(&path, mtObj2Device);
    return;
  }

  std::vector<TextCharPos> char_pos_list = GetCharPosList(
      textobj->GetCharCodes(), textobj->GetCharPositions(), pFont, font_size);
  for (const TextCharPos& charpos : char_pos_list) {
    auto* font = charpos.m_FallbackFontPosition == -1
                     ? pFont->GetFont()
                     : pFont->GetFontFallback(charpos.m_FallbackFontPosition);
    const CFX_PathData* pPath =
        font->LoadGlyphPath(charpos.m_GlyphIndex, charpos.m_FontCharWidth);
    if (!pPath)
      continue;

    CPDF_PathObject path;
    path.m_GraphState = textobj->m_GraphState;
    path.m_ColorState = textobj->m_ColorState;

    CFX_Matrix matrix;
    if (charpos.m_bGlyphAdjust) {
      matrix = CFX_Matrix(charpos.m_AdjustMatrix[0], charpos.m_AdjustMatrix[1],
                          charpos.m_AdjustMatrix[2], charpos.m_AdjustMatrix[3],
                          0, 0);
    }
    matrix.Concat(CFX_Matrix(font_size, 0, 0, font_size, charpos.m_Origin.x,
                             charpos.m_Origin.y));
    path.set_stroke(bStroke);
    path.set_filltype(bFill ? FXFILL_WINDING : 0);
    path.path().Append(pPath, &matrix);
    path.set_matrix(*pTextMatrix);
    path.CalcBoundingBox();
    ProcessPath(&path, mtObj2Device);
  }
}

void CPDF_RenderStatus::DrawShadingPattern(CPDF_ShadingPattern* pattern,
                                           const CPDF_PageObject* pPageObj,
                                           const CFX_Matrix& mtObj2Device,
                                           bool bStroke) {
  if (!pattern->Load())
    return;

  CFX_RenderDevice::StateRestorer restorer(m_pDevice);
  if (!ClipPattern(pPageObj, mtObj2Device, bStroke))
    return;

  FX_RECT rect = GetObjectClippedRect(pPageObj, mtObj2Device);
  if (rect.IsEmpty())
    return;

  CFX_Matrix matrix = pattern->pattern_to_form() * mtObj2Device;
  int alpha =
      FXSYS_roundf(255 * (bStroke ? pPageObj->m_GeneralState.GetStrokeAlpha()
                                  : pPageObj->m_GeneralState.GetFillAlpha()));
  CPDF_RenderShading::Draw(m_pDevice, m_pContext.Get(), m_pCurObj.Get(),
                           pattern, matrix, rect, alpha, m_Options);
}

void CPDF_RenderStatus::ProcessShading(const CPDF_ShadingObject* pShadingObj,
                                       const CFX_Matrix& mtObj2Device) {
  FX_RECT rect = pShadingObj->GetTransformedBBox(mtObj2Device);
  FX_RECT clip_box = m_pDevice->GetClipBox();
  rect.Intersect(clip_box);
  if (rect.IsEmpty())
    return;

  CFX_Matrix matrix = pShadingObj->matrix() * mtObj2Device;
  CPDF_RenderShading::Draw(
      m_pDevice, m_pContext.Get(), m_pCurObj.Get(), pShadingObj->pattern(),
      matrix, rect,
      FXSYS_roundf(255 * pShadingObj->m_GeneralState.GetFillAlpha()),
      m_Options);
}

void CPDF_RenderStatus::DrawTilingPattern(CPDF_TilingPattern* pPattern,
                                          CPDF_PageObject* pPageObj,
                                          const CFX_Matrix& mtObj2Device,
                                          bool bStroke) {
  const std::unique_ptr<CPDF_Form> pPatternForm = pPattern->Load(pPageObj);
  if (!pPatternForm)
    return;

  CFX_RenderDevice::StateRestorer restorer(m_pDevice);
#if defined(_SKIA_SUPPORT_) || defined(_SKIA_SUPPORT_PATHS_)
  ScopedSkiaDeviceFlush scoped_skia_device_flush(m_pDevice);
#endif
  if (!ClipPattern(pPageObj, mtObj2Device, bStroke))
    return;

  FX_RECT clip_box = m_pDevice->GetClipBox();
  if (clip_box.IsEmpty())
    return;

  const CFX_Matrix mtPattern2Device =
      pPattern->pattern_to_form() * mtObj2Device;

  CFX_FloatRect cell_bbox = mtPattern2Device.TransformRect(pPattern->bbox());

  float ceil_height = std::ceil(cell_bbox.Height());
  float ceil_width = std::ceil(cell_bbox.Width());

  // Validate the float will fit into the int when the conversion is done.
  if (!pdfium::base::IsValueInRangeForNumericType<int>(ceil_height) ||
      !pdfium::base::IsValueInRangeForNumericType<int>(ceil_width)) {
    return;
  }

  int width = static_cast<int>(ceil_width);
  int height = static_cast<int>(ceil_height);
  if (width <= 0)
    width = 1;
  if (height <= 0)
    height = 1;

  CFX_FloatRect clip_box_p =
      mtPattern2Device.GetInverse().TransformRect(CFX_FloatRect(clip_box));
  int min_col = static_cast<int>(
      ceil((clip_box_p.left - pPattern->bbox().right) / pPattern->x_step()));
  int max_col = static_cast<int>(
      floor((clip_box_p.right - pPattern->bbox().left) / pPattern->x_step()));
  int min_row = static_cast<int>(
      ceil((clip_box_p.bottom - pPattern->bbox().top) / pPattern->y_step()));
  int max_row = static_cast<int>(
      floor((clip_box_p.top - pPattern->bbox().bottom) / pPattern->y_step()));

  // Make sure we can fit the needed width * height into an int.
  if (height > std::numeric_limits<int>::max() / width)
    return;

  if (width > clip_box.Width() || height > clip_box.Height() ||
      width * height > clip_box.Width() * clip_box.Height()) {
    std::unique_ptr<CPDF_GraphicStates> pStates;
    if (!pPattern->colored())
      pStates = CloneObjStates(pPageObj, bStroke);

    const CPDF_Dictionary* pFormDict = pPatternForm->GetDict();
    const CPDF_Dictionary* pFormResource =
        pFormDict ? pFormDict->GetDictFor(""Resources"") : nullptr;
    for (int col = min_col; col <= max_col; col++) {
      for (int row = min_row; row <= max_row; row++) {
        CFX_PointF original = mtPattern2Device.Transform(
            CFX_PointF(col * pPattern->x_step(), row * pPattern->y_step()));
        CFX_Matrix matrix = mtObj2Device;
        matrix.Translate(original.x - mtPattern2Device.e,
                         original.y - mtPattern2Device.f);
        CFX_RenderDevice::StateRestorer restorer2(m_pDevice);
        CPDF_RenderStatus status(m_pContext.Get(), m_pDevice);
        status.SetOptions(m_Options);
        status.SetTransparency(pPatternForm->GetTransparency());
        status.SetFormResource(pFormResource);
        status.SetDropObjects(m_bDropObjects);
        status.Initialize(this, pStates.get());
        status.RenderObjectList(pPatternForm.get(), matrix);
      }
    }
    return;
  }

  bool bAligned =
      pPattern->bbox().left == 0 && pPattern->bbox().bottom == 0 &&
      pPattern->bbox().right == pPattern->x_step() &&
      pPattern->bbox().top == pPattern->y_step() &&
      (mtPattern2Device.IsScaled() || mtPattern2Device.Is90Rotated());
  if (bAligned) {
    int orig_x = FXSYS_roundf(mtPattern2Device.e);
    int orig_y = FXSYS_roundf(mtPattern2Device.f);
    min_col = (clip_box.left - orig_x) / width;
    if (clip_box.left < orig_x)
      min_col--;

    max_col = (clip_box.right - orig_x) / width;
    if (clip_box.right <= orig_x)
      max_col--;

    min_row = (clip_box.top - orig_y) / height;
    if (clip_box.top < orig_y)
      min_row--;

    max_row = (clip_box.bottom - orig_y) / height;
    if (clip_box.bottom <= orig_y)
      max_row--;
  }
  float left_offset = cell_bbox.left - mtPattern2Device.e;
  float top_offset = cell_bbox.bottom - mtPattern2Device.f;
  RetainPtr<CFX_DIBitmap> pPatternBitmap;
  if (width * height < 16) {
    RetainPtr<CFX_DIBitmap> pEnlargedBitmap = DrawPatternBitmap(
        m_pContext->GetDocument(), m_pContext->GetPageCache(), pPattern,
        pPatternForm.get(), mtObj2Device, 8, 8, m_Options.GetOptions());
    pPatternBitmap = pEnlargedBitmap->StretchTo(
        width, height, FXDIB_ResampleOptions(), nullptr);
  } else {
    pPatternBitmap =
        DrawPatternBitmap(m_pContext->GetDocument(), m_pContext->GetPageCache(),
                          pPattern, pPatternForm.get(), mtObj2Device, width,
                          height, m_Options.GetOptions());
  }
  if (!pPatternBitmap)
    return;

  if (m_Options.ColorModeIs(CPDF_RenderOptions::kGray))
    pPatternBitmap->ConvertColorScale(0, 0xffffff);

  FX_ARGB fill_argb = GetFillArgb(pPageObj);
  int clip_width = clip_box.right - clip_box.left;
  int clip_height = clip_box.bottom - clip_box.top;
  auto pScreen = pdfium::MakeRetain<CFX_DIBitmap>();
  if (!pScreen->Create(clip_width, clip_height, FXDIB_Argb))
    return;

  pScreen->Clear(0);
  const uint8_t* const src_buf = pPatternBitmap->GetBuffer();
  for (int col = min_col; col <= max_col; col++) {
    for (int row = min_row; row <= max_row; row++) {
      int start_x;
      int start_y;
      if (bAligned) {
        start_x =
            FXSYS_roundf(mtPattern2Device.e) + col * width - clip_box.left;
        start_y =
            FXSYS_roundf(mtPattern2Device.f) + row * height - clip_box.top;
      } else {
        CFX_PointF original = mtPattern2Device.Transform(
            CFX_PointF(col * pPattern->x_step(), row * pPattern->y_step()));

        FX_SAFE_INT32 safeStartX = FXSYS_roundf(original.x + left_offset);
        FX_SAFE_INT32 safeStartY = FXSYS_roundf(original.y + top_offset);

        safeStartX -= clip_box.left;
        safeStartY -= clip_box.top;
        if (!safeStartX.IsValid() || !safeStartY.IsValid())
          return;

        start_x = safeStartX.ValueOrDie();
        start_y = safeStartY.ValueOrDie();
      }
      if (width == 1 && height == 1) {
        if (start_x < 0 || start_x >= clip_box.Width() || start_y < 0 ||
            start_y >= clip_box.Height()) {
          continue;
        }
        uint32_t* dest_buf = reinterpret_cast<uint32_t*>(
            pScreen->GetBuffer() + pScreen->GetPitch() * start_y + start_x * 4);
        if (pPattern->colored()) {
          const auto* src_buf32 = reinterpret_cast<const uint32_t*>(src_buf);
          *dest_buf = *src_buf32;
        } else {
          *dest_buf = (*src_buf << 24) | (fill_argb & 0xffffff);
        }
      } else {
        if (pPattern->colored()) {
          pScreen->CompositeBitmap(start_x, start_y, width, height,
                                   pPatternBitmap, 0, 0, BlendMode::kNormal,
                                   nullptr, false);
        } else {
          pScreen->CompositeMask(start_x, start_y, width, height,
                                 pPatternBitmap, fill_argb, 0, 0,
                                 BlendMode::kNormal, nullptr, false);
        }
      }
    }
  }
  CompositeDIBitmap(pScreen, clip_box.left, clip_box.top, 0, 255,
                    BlendMode::kNormal, CPDF_Transparency());
}

void CPDF_RenderStatus::DrawPathWithPattern(CPDF_PathObject* pPathObj,
                                            const CFX_Matrix& mtObj2Device,
                                            const CPDF_Color* pColor,
                                            bool bStroke) {
  CPDF_Pattern* pattern = pColor->GetPattern();
  if (!pattern)
    return;

  if (CPDF_TilingPattern* pTilingPattern = pattern->AsTilingPattern())
    DrawTilingPattern(pTilingPattern, pPathObj, mtObj2Device, bStroke);
  else if (CPDF_ShadingPattern* pShadingPattern = pattern->AsShadingPattern())
    DrawShadingPattern(pShadingPattern, pPathObj, mtObj2Device, bStroke);
}

void CPDF_RenderStatus::ProcessPathPattern(CPDF_PathObject* pPathObj,
                                           const CFX_Matrix& mtObj2Device,
                                           int* filltype,
                                           bool* bStroke) {
  ASSERT(filltype);
  ASSERT(bStroke);

  if (*filltype) {
    const CPDF_Color& FillColor = *pPathObj->m_ColorState.GetFillColor();
    if (FillColor.IsPattern()) {
      DrawPathWithPattern(pPathObj, mtObj2Device, &FillColor, false);
      *filltype = 0;
    }
  }
  if (*bStroke) {
    const CPDF_Color& StrokeColor = *pPathObj->m_ColorState.GetStrokeColor();
    if (StrokeColor.IsPattern()) {
      DrawPathWithPattern(pPathObj, mtObj2Device, &StrokeColor, true);
      *bStroke = false;
    }
  }
}

bool CPDF_RenderStatus::ProcessImage(CPDF_ImageObject* pImageObj,
                                     const CFX_Matrix& mtObj2Device) {
  CPDF_ImageRenderer render;
  if (render.Start(this, pImageObj, mtObj2Device, m_bStdCS, m_curBlend))
    render.Continue(nullptr);
  return render.GetResult();
}

void CPDF_RenderStatus::CompositeDIBitmap(
    const RetainPtr<CFX_DIBitmap>& pDIBitmap,
    int left,
    int top,
    FX_ARGB mask_argb,
    int bitmap_alpha,
    BlendMode blend_mode,
    const CPDF_Transparency& transparency) {
  if (!pDIBitmap)
    return;

  if (blend_mode == BlendMode::kNormal) {
    if (!pDIBitmap->IsAlphaMask()) {
      if (bitmap_alpha < 255) {
#ifdef _SKIA_SUPPORT_
        std::unique_ptr<CFX_ImageRenderer> dummy;
        CFX_Matrix m = CFX_RenderDevice::GetFlipMatrix(
            pDIBitmap->GetWidth(), pDIBitmap->GetHeight(), left, top);
        m_pDevice->StartDIBits(pDIBitmap, bitmap_alpha, 0, m,
                               FXDIB_ResampleOptions(), &dummy);
        return;
#else
        pDIBitmap->MultiplyAlpha(bitmap_alpha);
#endif
      }
#ifdef _SKIA_SUPPORT_
      CFX_SkiaDeviceDriver::PreMultiply(pDIBitmap);
#endif
      if (m_pDevice->SetDIBits(pDIBitmap, left, top)) {
        return;
      }
    } else {
      uint32_t fill_argb = m_Options.TranslateColor(mask_argb);
      if (bitmap_alpha < 255) {
        uint8_t* fill_argb8 = reinterpret_cast<uint8_t*>(&fill_argb);
        fill_argb8[3] *= bitmap_alpha / 255;
      }
      if (m_pDevice->SetBitMask(pDIBitmap, left, top, fill_argb)) {
        return;
      }
    }
  }
  bool bIsolated = transparency.IsIsolated();
  bool bBackAlphaRequired =
      blend_mode != BlendMode::kNormal && bIsolated && !m_bDropObjects;
  bool bGetBackGround =
      ((m_pDevice->GetRenderCaps() & FXRC_ALPHA_OUTPUT)) ||
      (!(m_pDevice->GetRenderCaps() & FXRC_ALPHA_OUTPUT) &&
       (m_pDevice->GetRenderCaps() & FXRC_GET_BITS) && !bBackAlphaRequired);
  if (bGetBackGround) {
    if (bIsolated || !transparency.IsGroup()) {
      if (!pDIBitmap->IsAlphaMask())
        m_pDevice->SetDIBitsWithBlend(pDIBitmap, left, top, blend_mode);
      return;
    }

    FX_RECT rect(left, top, left + pDIBitmap->GetWidth(),
                 top + pDIBitmap->GetHeight());
    rect.Intersect(m_pDevice->GetClipBox());
    RetainPtr<CFX_DIBitmap> pClone;
    if (m_pDevice->GetBackDrop() && m_pDevice->GetBitmap()) {
      pClone = m_pDevice->GetBackDrop()->Clone(&rect);
      if (!pClone)
        return;

      RetainPtr<CFX_DIBitmap> pForeBitmap = m_pDevice->GetBitmap();
      pClone->CompositeBitmap(0, 0, pClone->GetWidth(), pClone->GetHeight(),
                              pForeBitmap, rect.left, rect.top,
                              BlendMode::kNormal, nullptr, false);
      left = std::min(left, 0);
      top = std::min(top, 0);
      if (pDIBitmap->IsAlphaMask()) {
        pClone->CompositeMask(0, 0, pClone->GetWidth(), pClone->GetHeight(),
                              pDIBitmap, mask_argb, left, top, blend_mode,
                              nullptr, false);
      } else {
        pClone->CompositeBitmap(0, 0, pClone->GetWidth(), pClone->GetHeight(),
                                pDIBitmap, left, top, blend_mode, nullptr,
                                false);
      }
    } else {
      pClone = pDIBitmap;
    }
    if (m_pDevice->GetBackDrop()) {
      m_pDevice->SetDIBits(pClone, rect.left, rect.top);
    } else {
      if (!pDIBitmap->IsAlphaMask()) {
        m_pDevice->SetDIBitsWithBlend(pDIBitmap, rect.left, rect.top,
                                      blend_mode);
      }
    }
    return;
  }
  int back_left;
  int back_top;
  FX_RECT rect(left, top, left + pDIBitmap->GetWidth(),
               top + pDIBitmap->GetHeight());
  RetainPtr<CFX_DIBitmap> pBackdrop = GetBackdrop(
      m_pCurObj.Get(), rect, blend_mode != BlendMode::kNormal && bIsolated,
      &back_left, &back_top);
  if (!pBackdrop)
    return;

  if (pDIBitmap->IsAlphaMask()) {
    pBackdrop->CompositeMask(left - back_left, top - back_top,
                             pDIBitmap->GetWidth(), pDIBitmap->GetHeight(),
                             pDIBitmap, mask_argb, 0, 0, blend_mode, nullptr,
                             false);
  } else {
    pBackdrop->CompositeBitmap(left - back_left, top - back_top,
                               pDIBitmap->GetWidth(), pDIBitmap->GetHeight(),
                               pDIBitmap, 0, 0, blend_mode, nullptr, false);
  }

  auto pBackdrop1 = pdfium::MakeRetain<CFX_DIBitmap>();
  pBackdrop1->Create(pBackdrop->GetWidth(), pBackdrop->GetHeight(),
                     FXDIB_Rgb32);
  pBackdrop1->Clear((uint32_t)-1);
  pBackdrop1->CompositeBitmap(0, 0, pBackdrop->GetWidth(),
                              pBackdrop->GetHeight(), pBackdrop, 0, 0,
                              BlendMode::kNormal, nullptr, false);
  pBackdrop = std::move(pBackdrop1);
  m_pDevice->SetDIBits(pBackdrop, back_left, back_top);
}

RetainPtr<CFX_DIBitmap> CPDF_RenderStatus::LoadSMask(
    CPDF_Dictionary* pSMaskDict,
    FX_RECT* pClipRect,
    const CFX_Matrix* pMatrix) {
  if (!pSMaskDict)
    return nullptr;

  CPDF_Stream* pGroup = pSMaskDict->GetStreamFor(pdfium::transparency::kG);
  if (!pGroup)
    return nullptr;

  std::unique_ptr<CPDF_Function> pFunc;
  const CPDF_Object* pFuncObj =
      pSMaskDict->GetDirectObjectFor(pdfium::transparency::kTR);
  if (pFuncObj && (pFuncObj->IsDictionary() || pFuncObj->IsStream()))
    pFunc = CPDF_Function::Load(pFuncObj);

  CFX_Matrix matrix = *pMatrix;
  matrix.Translate(-pClipRect->left, -pClipRect->top);

  CPDF_Form form(m_pContext->GetDocument(), m_pContext->GetPageResources(),
                 pGroup);
  form.ParseContent();

  CFX_DefaultRenderDevice bitmap_device;
  bool bLuminosity =
      pSMaskDict->GetStringFor(pdfium::transparency::kSoftMaskSubType) !=
      pdfium::transparency::kAlpha;
  int width = pClipRect->right - pClipRect->left;
  int height = pClipRect->bottom - pClipRect->top;
  FXDIB_Format format;
#if defined(OS_MACOSX) || defined _SKIA_SUPPORT_ || defined _SKIA_SUPPORT_PATHS_
  format = bLuminosity ? FXDIB_Rgb32 : FXDIB_8bppMask;
#else
  format = bLuminosity ? FXDIB_Rgb : FXDIB_8bppMask;
#endif
  if (!bitmap_device.Create(width, height, format, nullptr))
    return nullptr;

  RetainPtr<CFX_DIBitmap> bitmap = bitmap_device.GetBitmap();
  int nCSFamily = 0;
  if (bLuminosity) {
    FX_ARGB back_color =
        GetBackColor(pSMaskDict, pGroup->GetDict(), &nCSFamily);
    bitmap->Clear(back_color);
  } else {
    bitmap->Clear(0);
  }

  const CPDF_Dictionary* pFormResource =
      form.GetDict()->GetDictFor(""Resources"");
  CPDF_RenderOptions options;
  options.SetColorMode(bLuminosity ? CPDF_RenderOptions::kNormal
                                   : CPDF_RenderOptions::kAlpha);
  CPDF_RenderStatus status(m_pContext.Get(), &bitmap_device);
  status.SetOptions(options);
  status.SetGroupFamily(nCSFamily);
  status.SetLoadMask(bLuminosity);
  status.SetStdCS(true);
  status.SetFormResource(pFormResource);
  status.SetDropObjects(m_bDropObjects);
  status.Initialize(nullptr, nullptr);
  status.RenderObjectList(&form, matrix);

  auto pMask = pdfium::MakeRetain<CFX_DIBitmap>();
  if (!pMask->Create(width, height, FXDIB_8bppMask))
    return nullptr;

  uint8_t* dest_buf = pMask->GetBuffer();
  int dest_pitch = pMask->GetPitch();
  uint8_t* src_buf = bitmap->GetBuffer();
  int src_pitch = bitmap->GetPitch();
  std::vector<uint8_t, FxAllocAllocator<uint8_t>> transfers(256);
  if (pFunc) {
    std::vector<float> results(pFunc->CountOutputs());
    for (size_t i = 0; i < transfers.size(); ++i) {
      float input = i / 255.0f;
      int nresult;
      pFunc->Call(&input, 1, results.data(), &nresult);
      transfers[i] = FXSYS_roundf(results[0] * 255);
    }
  } else {
    // Fill |transfers| with 0, 1, ... N.
    std::iota(transfers.begin(), transfers.end(), 0);
  }
  if (bLuminosity) {
    int Bpp = bitmap->GetBPP() / 8;
    for (int row = 0; row < height; row++) {
      uint8_t* dest_pos = dest_buf + row * dest_pitch;
      uint8_t* src_pos = src_buf + row * src_pitch;
      for (int col = 0; col < width; col++) {
        *dest_pos++ = transfers[FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos)];
        src_pos += Bpp;
      }
    }
  } else if (pFunc) {
    int size = dest_pitch * height;
    for (int i = 0; i < size; i++) {
      dest_buf[i] = transfers[src_buf[i]];
    }
  } else {
    memcpy(dest_buf, src_buf, dest_pitch * height);
  }
  return pMask;
}

FX_ARGB CPDF_RenderStatus::GetBackColor(const CPDF_Dictionary* pSMaskDict,
                                        const CPDF_Dictionary* pGroupDict,
                                        int* pCSFamily) {
  static constexpr FX_ARGB kDefaultColor = ArgbEncode(255, 0, 0, 0);
  const CPDF_Array* pBC = pSMaskDict->GetArrayFor(pdfium::transparency::kBC);
  if (!pBC)
    return kDefaultColor;

  const CPDF_Object* pCSObj = nullptr;
  const CPDF_Dictionary* pGroup =
      pGroupDict ? pGroupDict->GetDictFor(""Group"") : nullptr;
  if (pGroup)
    pCSObj = pGroup->GetDirectObjectFor(pdfium::transparency::kCS);
  RetainPtr<CPDF_ColorSpace> pCS =
      CPDF_DocPageData::FromDocument(m_pContext->GetDocument())
          ->GetColorSpace(pCSObj, nullptr);
  if (!pCS)
    return kDefaultColor;

  int family = pCS->GetFamily();
  if (family == PDFCS_LAB || pCS->IsSpecial() ||
      (family == PDFCS_ICCBASED && !pCS->IsNormal())) {
    return kDefaultColor;
  }

  // Store Color Space Family to use in CPDF_RenderStatus::Initialize().
  *pCSFamily = family;

  uint32_t comps = std::max(8u, pCS->CountComponents());
  size_t count = std::min<size_t>(8, pBC->size());
  std::vector<float> floats = ReadArrayElementsToVector(pBC, count);
  floats.resize(comps);

  float R;
  float G;
  float B;
  pCS->GetRGB(floats.data(), &R, &G, &B);
  return ArgbEncode(255, static_cast<int>(R * 255), static_cast<int>(G * 255),
                    static_cast<int>(B * 255));
}
",16269,True,3270.7641398355754,median
"/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include ""precompiled_dbui.hxx""

#define ITEMID_HORJUSTIFY		SID_ATTR_ALIGN_HOR_JUSTIFY
#define ITEMID_VERJUSTIFY		SID_ATTR_ALIGN_VER_JUSTIFY
//#define ITEMID_ORIENTATION     SID_ATTR_ALIGN_ORIENTATION
#define ITEMID_LINEBREAK		SID_ATTR_ALIGN_LINEBREAK
#define ITEMID_MARGIN			SID_ATTR_ALIGN_MARGIN

#include ""FieldDescControl.hxx""
#include ""FieldControls.hxx""
#include <tools/debug.hxx>
#include <tools/diagnose_ex.h>
#include ""TableDesignHelpBar.hxx""
#include <vcl/scrbar.hxx>
#include <vcl/button.hxx>
#include <vcl/svapp.hxx>
#include <vcl/fixed.hxx>
#include <vcl/msgbox.hxx>
#include <vector>
#include ""FieldDescriptions.hxx""
#include ""dlgattr.hxx""
#include <svx/numfmtsh.hxx>
#include <svx/svxids.hrc>
#include <svx/algitem.hxx>
#include <svl/itempool.hxx>
#define _ZFORLIST_DECLARE_TABLE		// ohne das bekomme ich einen Compiler-Fehler in <svl/zforlist.hxx>
#include <svl/zforlist.hxx>
#include <svl/rngitem.hxx>
#include <svl/intitem.hxx>
#include <svl/numuno.hxx>
#include <svtools/transfer.hxx>
#include <com/sun/star/lang/XUnoTunnel.hpp>
#include <com/sun/star/util/NumberFormat.hpp>
#include <com/sun/star/util/XNumberFormatPreviewer.hpp>
#include <com/sun/star/util/XNumberFormatTypes.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include ""QEnumTypes.hxx""
#include ""dbaccess_helpid.hrc""
#include <connectivity/dbtools.hxx>
#include <connectivity/dbconversion.hxx>
#include <comphelper/numbers.hxx>
#include ""UITools.hxx""
#include <memory>
#include ""dbu_control.hrc""
#include ""dbu_tbl.hrc""


using namespace dbaui;
using namespace dbtools;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::sdbc;
using namespace ::com::sun::star::util;

//==================================================================

// fuer die Controls auf der OFieldDescGenPage
#define CONTROL_SPACING_X	18	// 6
#define	CONTROL_SPACING_Y	4
#define CONTROL_WIDTH_1		160	// 100
#define CONTROL_WIDTH_2		100 // 60
#define CONTROL_WIDTH_3		250
#define CONTROL_WIDTH_4		(CONTROL_WIDTH_3 - 20 - 5)

#define SBA_DEF_RANGEFORMAT			(100 + 143) // RangeItem
#define SBA_DEF_FMTVALUE			(100 + 144) // SfxULONG, Format
#define SBA_ATTR_ALIGN_HOR_JUSTIFY	(100 + 145) //  SvxHorJustifyItem

#define HSCROLL_STEP		20


namespace
{
	// -----------------------------------------------------------------------------
	double checkDoubleForDateFormat(double _nValue,sal_Int32 _nFormatKey,const Reference< ::com::sun::star::util::XNumberFormatter>& _xNumberFormatter)
	{
		double nValue = _nValue;
		sal_Int32 nNumberFormat = ::comphelper::getNumberFormatType(_xNumberFormatter,_nFormatKey);
		if(		(nNumberFormat & ::com::sun::star::util::NumberFormat::DATE)	== ::com::sun::star::util::NumberFormat::DATE
			|| (nNumberFormat & ::com::sun::star::util::NumberFormat::DATETIME) == ::com::sun::star::util::NumberFormat::DATETIME )
		{
			nValue = DBTypeConversion::toStandardDbDate(DBTypeConversion::getNULLDate(_xNumberFormatter->getNumberFormatsSupplier()),nValue);
		}

		return nValue;
	}
	// -----------------------------------------------------------------------------
    template< typename T1, typename T2> void lcl_HideAndDeleteControl(short& _nPos,T1** _pControl,T2** _pControlText)
    {
        if ( *_pControl )
        {
            --_nPos;
	        (*_pControl)->Hide();
	        (*_pControlText)->Hide();
	        delete *_pControl;
	        delete *_pControlText;
            (*_pControl) = NULL;
            (*_pControlText) = NULL;
        }
    }

}

//==================================================================
// class OFieldDescControl
//==================================================================

DBG_NAME(OFieldDescControl)

//==================================================================
OFieldDescControl::OFieldDescControl( Window* pParent, const ResId& rResId, OTableDesignHelpBar* pHelpBar)
	:TabPage( pParent, rResId )
	,pHelp( pHelpBar )
	,pLastFocusWindow(NULL)
	,m_pActFocusWindow(NULL)
	,pDefaultText(NULL)
	,pRequiredText(NULL)
	,pAutoIncrementText(NULL)
	,pTextLenText(NULL)
	,pNumTypeText(NULL)
	,pLengthText(NULL)
	,pScaleText(NULL)
	,pFormatText(NULL)
	,pBoolDefaultText(NULL)
	,m_pColumnNameText(NULL)
	,m_pTypeText(NULL)
	,m_pAutoIncrementValueText(NULL)
	,pRequired(NULL)
	,pNumType(NULL)
	,pAutoIncrement(NULL)
	,pDefault(NULL)
	,pTextLen(NULL)
	,pLength(NULL)
	,pScale(NULL)
	,pFormatSample(NULL)
	,pBoolDefault(NULL)
	,m_pColumnName(NULL)
	,m_pType(NULL)
	,m_pAutoIncrementValue(NULL)
	,pFormat(NULL)
    ,m_pVertScroll( NULL )
    ,m_pHorzScroll( NULL )
    ,m_pPreviousType()
	,nCurChildId(1)
	,m_nPos(-1)
    ,aYes(ModuleRes(STR_VALUE_YES))
	,aNo(ModuleRes(STR_VALUE_NO))
    ,m_nOldVThumb( 0 )
    ,m_nOldHThumb( 0 )
	,m_nWidth(50)
    ,nDelayedGrabFocusEvent(0)
    ,m_bAdded(sal_False)
	,m_bRightAligned(false)
    ,pActFieldDescr(NULL)
{
	DBG_CTOR(OFieldDescControl,NULL);

	Contruct();
}
//------------------------------------------------------------------------------
OFieldDescControl::OFieldDescControl( Window* pParent, OTableDesignHelpBar* pHelpBar )
	:TabPage( pParent, WB_3DLOOK | WB_DIALOGCONTROL )
	,pHelp( pHelpBar )
	,pLastFocusWindow(NULL)
	,m_pActFocusWindow(NULL)
	,pDefaultText(NULL)
	,pRequiredText(NULL)
	,pAutoIncrementText(NULL)
	,pTextLenText(NULL)
	,pNumTypeText(NULL)
	,pLengthText(NULL)
	,pScaleText(NULL)
	,pFormatText(NULL)
	,pBoolDefaultText(NULL)
	,m_pColumnNameText(NULL)
	,m_pTypeText(NULL)
	,m_pAutoIncrementValueText(NULL)
	,pRequired(NULL)
	,pNumType(NULL)
	,pAutoIncrement(NULL)
	,pDefault(NULL)
	,pTextLen(NULL)
	,pLength(NULL)
	,pScale(NULL)
	,pFormatSample(NULL)
	,pBoolDefault(NULL)
	,m_pColumnName(NULL)
	,m_pType(NULL)
	,m_pAutoIncrementValue(NULL)
	,pFormat(NULL)
    ,m_pVertScroll( NULL )
    ,m_pHorzScroll( NULL )
    ,m_pPreviousType()
	,nCurChildId(1)
	,m_nPos(-1)
    ,aYes(ModuleRes(STR_VALUE_YES))
	,aNo(ModuleRes(STR_VALUE_NO))
    ,m_nOldVThumb( 0 )
    ,m_nOldHThumb( 0 )
	,m_nWidth(50)
    ,nDelayedGrabFocusEvent(0)
    ,m_bAdded(sal_False)
	,m_bRightAligned(false)
    ,pActFieldDescr(NULL)
{
	DBG_CTOR(OFieldDescControl,NULL);
    Contruct();
}
// -----------------------------------------------------------------------------
void OFieldDescControl::Contruct()
{
    m_pVertScroll = new ScrollBar(this, WB_VSCROLL | WB_REPEAT | WB_DRAG);
	m_pHorzScroll = new ScrollBar(this, WB_HSCROLL | WB_REPEAT | WB_DRAG);
	m_pVertScroll->SetScrollHdl(LINK(this, OFieldDescControl, OnScroll));
	m_pHorzScroll->SetScrollHdl(LINK(this, OFieldDescControl, OnScroll));
	m_pVertScroll->Show();
	m_pHorzScroll->Show();

	m_pVertScroll->EnableClipSiblings();
	m_pHorzScroll->EnableClipSiblings();

	m_pVertScroll->SetLineSize(1);
	m_pVertScroll->SetPageSize(1);
	m_pHorzScroll->SetLineSize(1);
	m_pHorzScroll->SetPageSize(1);

	m_nOldVThumb = m_nOldHThumb = 0;
}

//------------------------------------------------------------------------------
OFieldDescControl::~OFieldDescControl()
{
	DBG_DTOR(OFieldDescControl,NULL);

	{
		::std::auto_ptr<Window> aTemp(m_pVertScroll);
		m_pVertScroll	 = NULL;
	}
	{
		::std::auto_ptr<Window> aTemp(m_pHorzScroll);
		m_pHorzScroll	 = NULL;
	}
    if ( m_bAdded )
        ::dbaui::notifySystemWindow(this,this,::comphelper::mem_fun(&TaskPaneList::RemoveWindow));
	pLastFocusWindow = NULL;

	//////////////////////////////////////////////////////////////////////
	// Childs zerstoeren
	DeactivateAggregate( tpDefault );
	DeactivateAggregate( tpRequired );
	DeactivateAggregate( tpTextLen );
	DeactivateAggregate( tpNumType );
	DeactivateAggregate( tpScale );
	DeactivateAggregate( tpLength );
	DeactivateAggregate( tpFormat );
	DeactivateAggregate( tpAutoIncrement );
	DeactivateAggregate( tpBoolDefault );
	DeactivateAggregate( tpColumnName );
	DeactivateAggregate( tpType );
	DeactivateAggregate( tpAutoIncrementValue );

	if(nDelayedGrabFocusEvent)
		Application::RemoveUserEvent(nDelayedGrabFocusEvent);
}

//------------------------------------------------------------------------------
String OFieldDescControl::BoolStringPersistent(const String& rUIString) const
{
	static String aZero('0');
	static String aOne('1');

	if (rUIString == aNo)
		return aZero;
	if (rUIString == aYes)
		return aOne;
	return String();
}

//------------------------------------------------------------------------------
String OFieldDescControl::BoolStringUI(const String& rPersistentString) const
{
	static String aZero('0');
	static String aOne('1');
	static String aNone(ModuleRes(STR_VALUE_NONE));

	// FS - 66161 - 14.05.1999 - aeltere Versionen haben eventuell einen sprachabhaengigen String als Default gespeichert
	if (rPersistentString.Equals(aYes) || rPersistentString.Equals(aNo))
		return rPersistentString;

	if (rPersistentString == aZero)
		return aNo;
	if (rPersistentString == aOne)
		return aYes;

	return aNone;
}

//------------------------------------------------------------------------------
void OFieldDescControl::Init()
{
	Reference< ::com::sun::star::util::XNumberFormatter > xFormatter = GetFormatter();
	::dbaui::setEvalDateFormatForFormatter(xFormatter);
}

//------------------------------------------------------------------------------
IMPL_LINK(OFieldDescControl, OnScroll, ScrollBar*, /*pBar*/)
{
	ScrollAllAggregates();
	return 0;
}
// -----------------------------------------------------------------------------
namespace
{
	void getMaxXPosition(Window* _pWindow,long& _rnMaxXPosition)
	{
		if (_pWindow)
		{
			long nTemp = _pWindow->GetSizePixel().Width() + _pWindow->GetPosPixel().X();
			_rnMaxXPosition = ::std::max(_rnMaxXPosition, nTemp);
		}
	}
}
//------------------------------------------------------------------------------
void OFieldDescControl::CheckScrollBars()
{
	// ein paar Berechnungen zur neuen Position der ScrollBars
	Size szOverallSize = GetSizePixel();
	long nHScrollHeight = m_pHorzScroll->GetSizePixel().Height();
	long nVScrollWidth = m_pVertScroll->GetSizePixel().Width();

	long nNewHWidth = szOverallSize.Width() - nVScrollWidth;
	long nNewVHeight = szOverallSize.Height() - nHScrollHeight;

	sal_Bool bNeedHScrollBar(sal_False), bNeedVScrollBar(sal_False);

	// die Bereiche anpassen
	// brauche ich ScrollBars eigentlich ?
	// horizontal :
	long lMaxXPosition = 0;
	Control* ppAggregates[] = { pRequired, pNumType, pAutoIncrement, pDefault, pTextLen, pLength, pScale, pFormat, m_pColumnName, m_pType,m_pAutoIncrementValue};
	for (sal_uInt16 i=0; i<sizeof(ppAggregates)/sizeof(ppAggregates[0]); ++i)
		getMaxXPosition(ppAggregates[i],lMaxXPosition);

	if (m_pHorzScroll)
		lMaxXPosition += m_pHorzScroll->GetThumbPos() * HSCROLL_STEP;

	long lMaxXAvailable = szOverallSize.Width();
	bNeedHScrollBar = lMaxXPosition > lMaxXAvailable;
		// aendert sich vielleicht noch

	// vertikal
	// wieviel Controls habe ich
	sal_uInt16 nActive = CountActiveAggregates();
	// welches ist das letzte, was ganz drauf passt ?
	sal_uInt16 nLastVisible;
    const sal_Int32 nControlHeight = GetMaxControlHeight();
    const sal_Int32 nControl_Spacing_y = LogicToPixel(Size(0, CONTROL_SPACING_Y),MAP_APPFONT).Height();
	if (bNeedHScrollBar)
		nLastVisible = static_cast<sal_uInt16>((szOverallSize.Height() - nControl_Spacing_y - nHScrollHeight) / (nControl_Spacing_y + nControlHeight));
	else
		nLastVisible = static_cast<sal_uInt16>((szOverallSize.Height() - nControl_Spacing_y) / (nControl_Spacing_y + nControlHeight));
	bNeedVScrollBar = nActive>nLastVisible;

	if (bNeedVScrollBar)
	{
		// in die urspruengliche Berechnung von lMaxXAvailable ist nicht mit eingegangen, dass ich eine VScrollBar habe, also muss ich
		// das nachholen
		lMaxXAvailable -= nVScrollWidth;
		if (!bNeedHScrollBar && (lMaxXPosition > lMaxXAvailable))
		{
			// durch die vertikale brauche ich jetzt ploetzlich doch eine horizontale
			bNeedHScrollBar = sal_True;
			// nLastVisible anpassen
			nLastVisible = static_cast<sal_uInt16>((szOverallSize.Height() - nControl_Spacing_y - nHScrollHeight) / (nControl_Spacing_y + nControlHeight));
				// bNeedVScrollBar aendert sich nicht : es ist schon auf sal_True und nLastVisible wird hoechstens kleiner
		}
	}

	// jetzt kann ich sie wirklich positionieren und ihre Parameter setzen
	if (bNeedVScrollBar)
	{
		m_pVertScroll->Show();
		m_pVertScroll->SetRangeMax(nActive - nLastVisible);
//		m_pVertScroll->SetThumbPos(0);

		m_pVertScroll->SetPosSizePixel( Point(nNewHWidth, 0), Size(nVScrollWidth, szOverallSize.Height()) );
	}
	else
	{
		m_pVertScroll->Hide();
		m_pVertScroll->SetRangeMax(0);
		m_pVertScroll->SetThumbPos(0);
	}

	if (bNeedHScrollBar)
	{
		m_pHorzScroll->Show();
		m_pHorzScroll->SetRangeMax((lMaxXPosition - lMaxXAvailable + HSCROLL_STEP - 1 )/HSCROLL_STEP);
//		m_pHorzScroll->SetThumbPos(0);

		m_pHorzScroll->SetPosSizePixel( Point(0, nNewVHeight), Size(bNeedVScrollBar ? nNewHWidth : szOverallSize.Width(), nHScrollHeight) );
	}
	else
	{
		m_pHorzScroll->Hide();
		m_pHorzScroll->SetRangeMax(0);
		m_pHorzScroll->SetThumbPos(0);
	}
}

//------------------------------------------------------------------------------
void OFieldDescControl::Resize()
{
	CheckScrollBars();
	ScrollAllAggregates();
}

//------------------------------------------------------------------------------
inline void OFieldDescControl::ScrollAggregate(Control* pText, Control* pInput, Control* pButton, long nDeltaX, long nDeltaY)
{
	if  (!pText)
		return;
	pText->SetPosPixel(pText->GetPosPixel() + Point(nDeltaX, nDeltaY));
	pInput->SetPosPixel(pInput->GetPosPixel() + Point(nDeltaX, nDeltaY));
	if (pButton)
		pButton->SetPosPixel(pButton->GetPosPixel() + Point(nDeltaX, nDeltaY));
}

//------------------------------------------------------------------------------
void OFieldDescControl::ScrollAllAggregates()
{
	long nDeltaX = 0, nDeltaY = 0;
	if (m_nOldHThumb != m_pHorzScroll->GetThumbPos())
	{
		nDeltaX = (m_nOldHThumb - m_pHorzScroll->GetThumbPos()) * HSCROLL_STEP;
		m_nOldHThumb = m_pHorzScroll->GetThumbPos();
	}

	if (m_nOldVThumb != m_pVertScroll->GetThumbPos())
	{
        const sal_Int32 nControlHeight = GetMaxControlHeight();
        const sal_Int32 nControl_Spacing_y = LogicToPixel(Size(0, CONTROL_SPACING_Y),MAP_APPFONT).Height();
		nDeltaY = (m_nOldVThumb - m_pVertScroll->GetThumbPos()) * (nControl_Spacing_y + nControlHeight);
		m_nOldVThumb = m_pVertScroll->GetThumbPos();
	}

	if (nDeltaX || nDeltaY)
	{
		Control* ppAggregates[]		= {	  pRequired, pNumType
										, pAutoIncrement, pDefault
										, pTextLen, pLength
										, pScale, m_pColumnName
										, m_pType, m_pAutoIncrementValue};
		Control* ppAggregatesText[]	= {	  pRequiredText, pNumTypeText
										, pAutoIncrementText, pDefaultText
										, pTextLenText, pLengthText
										, pScaleText, m_pColumnNameText
										, m_pTypeText, m_pAutoIncrementValueText};
		OSL_ENSURE(sizeof(ppAggregates)/sizeof(ppAggregates[0]) == sizeof(ppAggregatesText)/sizeof(ppAggregatesText[0]),""Lists are not identical!"");

		for (sal_uInt16 i=0; i<sizeof(ppAggregates)/sizeof(ppAggregates[0]); ++i)
			ScrollAggregate(ppAggregatesText[i],ppAggregates[i],NULL,nDeltaX, nDeltaY);

		ScrollAggregate(pFormatText,pFormatSample,pFormat,nDeltaX, nDeltaY);
	}
}

//------------------------------------------------------------------------------
sal_uInt16 OFieldDescControl::CountActiveAggregates() const
{
	Control* ppAggregates[] = { pRequired, pNumType, pAutoIncrement, pDefault, pTextLen, pLength, pScale, pFormat, m_pColumnName, m_pType,m_pAutoIncrementValue};
	sal_uInt16 nVisibleAggregates = 0;
	for (sal_uInt16 i=0; i<sizeof(ppAggregates)/sizeof(ppAggregates[0]); ++i)
		if (ppAggregates[i])
			++nVisibleAggregates;
	return nVisibleAggregates;
}
//------------------------------------------------------------------------------
sal_Int32 OFieldDescControl::GetMaxControlHeight() const
{
    Size aHeight;
    Control* ppAggregates[] = { pRequired, pNumType, pAutoIncrement, pDefault, pTextLen, pLength, pScale, pFormat, m_pColumnName, m_pType,m_pAutoIncrementValue};
	for (sal_uInt16 i=0; i<sizeof(ppAggregates)/sizeof(ppAggregates[0]); ++i)
    {
		if ( ppAggregates[i] )
        {
            const Size aTemp( ppAggregates[i]->GetOptimalSize(WINDOWSIZE_PREFERRED) );
            if ( aTemp.Height() > aHeight.Height() )
                aHeight.Height() = aTemp.Height();
        } // if ( ppAggregates[i] )
    }

    return aHeight.Height();
}
//------------------------------------------------------------------------------
void OFieldDescControl::SetReadOnly( sal_Bool bReadOnly )
{
	DBG_CHKTHIS(OFieldDescControl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Controls enablen/disablen
	Control* ppAggregates[]		= {	  pRequired, pNumType
										, pAutoIncrement, pDefault
										, pTextLen, pLength
										, pScale, m_pColumnName
										, m_pType, m_pAutoIncrementValue
										, pFormat};
	Control* ppAggregatesText[]	= {	  pRequiredText, pNumTypeText
										, pAutoIncrementText, pDefaultText
										, pTextLenText, pLengthText
										, pScaleText, m_pColumnNameText
										, m_pTypeText, m_pAutoIncrementValueText
										, pFormatText};

	OSL_ENSURE(sizeof(ppAggregates)/sizeof(ppAggregates[0]) == sizeof(ppAggregatesText)/sizeof(ppAggregatesText[0]),""Lists are not identical!"");

	for (sal_uInt16 i=0; i<sizeof(ppAggregates)/sizeof(ppAggregates[0]); ++i)
	{
		if ( ppAggregatesText[i] )
			ppAggregatesText[i]->Enable( !bReadOnly );
		if ( ppAggregates[i] )
			ppAggregates[i]->Enable( !bReadOnly );
	}
}

//------------------------------------------------------------------------------
String OFieldDescControl::GetControlText( sal_uInt16 nControlId )
{
	DBG_CHKTHIS(OFieldDescControl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Texte der Controls auslesen
	switch( nControlId )
	{
		case FIELD_PROPERTY_BOOL_DEFAULT:
			if (pBoolDefault)
				return pBoolDefault->GetSelectEntry();
			break;
		case FIELD_PROPERTY_DEFAULT:
			if (pDefault)
				return pDefault->GetText();
			break;
		case FIELD_PROPERTY_REQUIRED:
			if (pRequired)
				return pRequired->GetSelectEntry();
			break;
		case FIELD_PROPERTY_TEXTLEN:
			if (pTextLen)
				return String::CreateFromInt64(pTextLen->GetValue());
		case FIELD_PROPERTY_NUMTYPE:
			if (pNumType)
				return pNumType->GetSelectEntry();
			break;
		case FIELD_PROPERTY_AUTOINC:
			if (pAutoIncrement)
				return pAutoIncrement->GetSelectEntry();
			break;
		case FIELD_PROPERTY_LENGTH:
			if (pLength)
				return pLength->GetText();
			break;
		case FIELD_PROPERTY_SCALE:
			if (pScale)
				return pScale->GetText();
			break;
		case FIELD_PROPERTY_FORMAT:
			if (pFormatSample)
				return pFormatSample->GetText();
			break;
		case FIELD_PRPOERTY_COLUMNNAME:
			if(m_pColumnName)
				return m_pColumnName->GetText();
		case FIELD_PRPOERTY_TYPE:
			if(m_pType)
				return m_pType->GetSelectEntry();
			break;
		case FIELD_PRPOERTY_AUTOINCREMENT:
			if(m_pAutoIncrementValue)
				return m_pAutoIncrementValue->GetText();
	}

	return String();
}

//------------------------------------------------------------------------------
void OFieldDescControl::SetControlText( sal_uInt16 nControlId, const String& rText )
{
	DBG_CHKTHIS(OFieldDescControl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Texte der Controls setzen
	switch( nControlId )
	{
		case FIELD_PROPERTY_BOOL_DEFAULT:
			if (pBoolDefault)
			{
				String sOld = pBoolDefault->GetSelectEntry();
				pBoolDefault->SelectEntry(rText);
				if (!sOld.Equals(rText))
					LINK(this, OFieldDescControl, ChangeHdl).Call(pBoolDefault);
			}
			break;
		case FIELD_PROPERTY_DEFAULT:
			if (pDefault)
			{
				pDefault->SetText(rText);
				UpdateFormatSample(pActFieldDescr);
			}
			break;

		case FIELD_PROPERTY_REQUIRED:
			if (pRequired)
				pRequired->SelectEntry(rText);
			break;


		case FIELD_PROPERTY_TEXTLEN:
			if (pTextLen)
				pTextLen->SetText(rText);
			break;

		case FIELD_PROPERTY_NUMTYPE:
			if (pNumType)
				pNumType->SelectEntry(rText);
			break;

		case FIELD_PROPERTY_AUTOINC:
			if (pAutoIncrement)
			{
				String sOld = pAutoIncrement->GetSelectEntry();
				pAutoIncrement->SelectEntry(rText);
				if (!sOld.Equals(rText))
					LINK(this, OFieldDescControl, ChangeHdl).Call(pAutoIncrement);
			}
			break;

		case FIELD_PROPERTY_LENGTH:
			if (pLength)
				pLength->SetText(rText);
			break;

		case FIELD_PROPERTY_SCALE:
			if (pScale)
				pScale->SetText(rText);
			break;

		case FIELD_PROPERTY_FORMAT:
			if (pActFieldDescr)
				UpdateFormatSample(pActFieldDescr);
			break;
		case FIELD_PRPOERTY_COLUMNNAME:
			if(m_pColumnName)
				m_pColumnName->SetText(rText);
			break;
		case FIELD_PRPOERTY_TYPE:
			if(m_pType)
				m_pType->SelectEntry(rText);
			break;
		case FIELD_PRPOERTY_AUTOINCREMENT:
			if(m_pAutoIncrementValue)
				m_pAutoIncrementValue->SetText(rText);
			break;
	}
}

//------------------------------------------------------------------------
IMPL_LINK( OFieldDescControl, FormatClickHdl, Button *, /*pButton*/ )
{
	DBG_CHKTHIS(OFieldDescControl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Temporaere Column erzeugen, mit der Datenaustausch mit Dialog erfolgt
	if( !pActFieldDescr )
		return 0;

	sal_Int32 nOldFormatKey(pActFieldDescr->GetFormatKey());
	SvxCellHorJustify rOldJustify = pActFieldDescr->GetHorJustify();
	Reference< XNumberFormatsSupplier >  xSupplier = GetFormatter()->getNumberFormatsSupplier();
    SvNumberFormatsSupplierObj* pSupplierImpl = SvNumberFormatsSupplierObj::getImplementation( xSupplier );

	SvNumberFormatter* pFormatter = pSupplierImpl->GetNumberFormatter();
	sal_uInt16 nFlags;
	if(::dbaui::callColumnFormatDialog(this,pFormatter,pActFieldDescr->GetType(),nOldFormatKey,rOldJustify,nFlags,sal_True))
	{
		sal_Bool bModified = sal_False;
		if(nOldFormatKey != pActFieldDescr->GetFormatKey())
		{
			pActFieldDescr->SetFormatKey( nOldFormatKey );
			bModified = sal_True;
		}
		if(rOldJustify != pActFieldDescr->GetHorJustify())
		{
			pActFieldDescr->SetHorJustify( rOldJustify );
			bModified = sal_True;
		}

		if(bModified)
		{
			SetModified(sal_True);
			UpdateFormatSample(pActFieldDescr);
		}
	}
	return 0;
}

// -----------------------------------------------------------------------
void OFieldDescControl::SetModified(sal_Bool /*bModified*/) 
{
}
//------------------------------------------------------------------------
IMPL_LINK( OFieldDescControl, ChangeHdl, ListBox *, pListBox )
{
	DBG_CHKTHIS(OFieldDescControl,NULL);
	if ( !pActFieldDescr )
		return 0;

    if ( pListBox->GetSavedValue() != pListBox->GetSelectEntryPos() )
	    SetModified(sal_True);

	// Sonderbehandlund f""ur Bool Felder
	if(pListBox == pRequired && pBoolDefault )
	{
		// wenn pRequired auf sal_True gesetzt ist, dann darf das sal_Bool Feld nicht den Eintrag <<keiner>> besitzen
		String sDef = BoolStringUI(::comphelper::getString(pActFieldDescr->GetControlDefault()));

		if(pRequired->GetSelectEntryPos() == 0) // JA
		{
			pBoolDefault->RemoveEntry(String(ModuleRes(STR_VALUE_NONE)));
			if (!sDef.Equals(aYes) && !sDef.Equals(aNo))
				pBoolDefault->SelectEntryPos(1);  // nein als Default
			else
				pBoolDefault->SelectEntry(sDef);
		}
		else if(pBoolDefault->GetEntryCount() < 3)
		{
			pBoolDefault->InsertEntry(String(ModuleRes(STR_VALUE_NONE)));
			pBoolDefault->SelectEntry(sDef);
		}
	}

	// nur fuer AutoIncrement eine Sonderbehandlung
	if (pListBox == pAutoIncrement)
	{
		if(pListBox->GetSelectEntryPos() == 1)
		{ // no
			DeactivateAggregate( tpAutoIncrementValue );
			if(pActFieldDescr->IsPrimaryKey())
				DeactivateAggregate( tpRequired );
			else if( pActFieldDescr->getTypeInfo()->bNullable )
			{
				ActivateAggregate( tpRequired );
				if(pRequired)
				{
					if( pActFieldDescr->IsNullable() )
						pRequired->SelectEntryPos( 1 ); // no
					else
						pRequired->SelectEntryPos( 0 ); // yes
				}
			}
			ActivateAggregate( tpDefault );
		}
		else
		{
			DeactivateAggregate( tpRequired );
			DeactivateAggregate( tpDefault );
			ActivateAggregate( tpAutoIncrementValue );
		}
		// und jetzt alle nach oben schieben
		ArrangeAggregates();
	}

	if(pListBox == m_pType)
	{
		TOTypeInfoSP pTypeInfo = getTypeInfo(m_pType->GetSelectEntryPos());
		pActFieldDescr->FillFromTypeInfo(pTypeInfo,sal_True,sal_False); // SetType(pTypeInfo);

		DisplayData(pActFieldDescr);
		CellModified(-1, m_pType->GetPos());
	}

	return 0;
}
//------------------------------------------------------------------------------
// alle Control neu anordnen, so dass sie in fester Reihenfolge und wirklich
// OBEN auf der DescriptionPage stehen
void OFieldDescControl::ArrangeAggregates()
{
	DBG_CHKTHIS(OFieldDescControl,NULL);
	// die Beschreibung eines Controls
	struct AGGREGATE_DESCRIPTION
	{
		Control*	pctrlInputControl;	// das eigentliche Control zur Eingabe
		Control*	pctrlTextControl;	// das Label dazu
		sal_uInt16		nPosSizeArgument;	// das zweite Argument fuer SetPosSize
	};
	AGGREGATE_DESCRIPTION adAggregates[] = {
		{ m_pColumnName, m_pColumnNameText, 1},
		{ m_pType, m_pTypeText, 1},
		{ pAutoIncrement, pAutoIncrementText, 1 },
		{ m_pAutoIncrementValue, m_pAutoIncrementValueText, 3 },
		{ pNumType, pNumTypeText, 1 },
		{ pRequired, pRequiredText, 1 },
		{ pTextLen, pTextLenText, 1 },
		{ pLength, pLengthText, 1 },
		{ pScale, pScaleText, 1 },
		{ pDefault, pDefaultText, 3 },
		{ pFormatSample, pFormatText, 4 },
		{ pBoolDefault, pBoolDefaultText, 1 },
	};

	long nMaxWidth = 0;
	for (size_t i=0; i<sizeof(adAggregates)/sizeof(adAggregates[0]); i++)
	{
		if (adAggregates[i].pctrlTextControl)
		{
			nMaxWidth = ::std::max<long>(OutputDevice::GetTextWidth(adAggregates[i].pctrlTextControl->GetText()),nMaxWidth);
		}
	}

	OSL_ENSURE(nMaxWidth != 0,""Invalid width!"");

	// und los ...
	int nCurrentControlPos = 0;
	Control* pZOrderPredecessor = NULL;
	for (size_t i=0; i<sizeof(adAggregates)/sizeof(adAggregates[0]); i++)
	{
		if (adAggregates[i].pctrlInputControl)
		{
			SetPosSize(&adAggregates[i].pctrlTextControl, nCurrentControlPos, 0);
			SetPosSize(&adAggregates[i].pctrlInputControl, nCurrentControlPos, adAggregates[i].nPosSizeArgument);

			// die Z-Order so, dass die Controls auch wirklich in derselben Reihenfolge durchwandert werden koennen, in der sie
			// hier angeordnet wurden
            adAggregates[i].pctrlTextControl->SetZOrder(pZOrderPredecessor, pZOrderPredecessor ? WINDOW_ZORDER_BEHIND : WINDOW_ZORDER_FIRST);
			adAggregates[i].pctrlInputControl->SetZOrder(adAggregates[i].pctrlTextControl, WINDOW_ZORDER_BEHIND );
			pZOrderPredecessor = adAggregates[i].pctrlInputControl;

			if (adAggregates[i].pctrlInputControl == pFormatSample)
			{
				pFormat->SetZOrder(pZOrderPredecessor, WINDOW_ZORDER_BEHIND);
				pZOrderPredecessor = pFormat;
			}

			++nCurrentControlPos;
		}
	}

	// eine Sonderbehandlung fuer die Format-Controls
	if (pFormat)
	{
		Point ptSamplePos(pFormatSample->GetPosPixel());
		Size szSampleSize(pFormatSample->GetSizePixel());
		pFormat->SetPosPixel(Point(ptSamplePos.X() + szSampleSize.Width() + 5, ptSamplePos.Y()));
	}

	// als letztes noch die ScrollBars in der ZOrder ganz nach oben
	m_pVertScroll->SetZOrder(NULL, WINDOW_ZORDER_FIRST);
	m_pHorzScroll->SetZOrder(NULL, WINDOW_ZORDER_FIRST);
}

//------------------------------------------------------------------------------
void OFieldDescControl::ActivateAggregate( EControlType eType )
{
	DBG_CHKTHIS(OFieldDescControl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Controls erzeugen
	switch( eType )
	{
	case tpDefault:
		if( pDefault )
			return;
		m_nPos++;
        pDefaultText = CreateText(STR_DEFAULT_VALUE);
		pDefault = new OPropEditCtrl( this, STR_HELP_DEFAULT_VALUE, FIELD_PROPERTY_DEFAULT, WB_BORDER );
        InitializeControl(pDefault,HID_TAB_ENT_DEFAULT,false);
		break;
	case tpAutoIncrementValue:
		if( m_pAutoIncrementValue || !isAutoIncrementValueEnabled() )
			return;
		m_nPos++;
        m_pAutoIncrementValueText = CreateText(STR_AUTOINCREMENT_VALUE);
		m_pAutoIncrementValue = new OPropEditCtrl( this, STR_HELP_AUTOINCREMENT_VALUE, FIELD_PRPOERTY_AUTOINCREMENT, WB_BORDER );
		m_pAutoIncrementValue->SetText( getAutoIncrementValue() );
        InitializeControl(m_pAutoIncrementValue,HID_TAB_AUTOINCREMENTVALUE,false);
		break;

	case tpRequired:
	{
		if( pRequired )
			return;
		Reference< XDatabaseMetaData> xMetaData = getMetaData();

		if(xMetaData.is() && xMetaData->supportsNonNullableColumns())
		{
			m_nPos++;
            pRequiredText = CreateText(STR_FIELD_REQUIRED);
			pRequired = new OPropListBoxCtrl( this, STR_HELP_FIELD_REQUIRED, FIELD_PROPERTY_REQUIRED, WB_DROPDOWN);

			pRequired->InsertEntry( aYes );
			pRequired->InsertEntry( aNo );
			pRequired->SelectEntryPos(1);
			
            InitializeControl(pRequired,HID_TAB_ENT_REQUIRED,true);
		}
	}
	break;
	case tpAutoIncrement:
	{
		if( pAutoIncrement )
			return;
		m_nPos++;
        pAutoIncrementText = CreateText(STR_FIELD_AUTOINCREMENT);
		pAutoIncrement = new OPropListBoxCtrl( this, STR_HELP_AUTOINCREMENT, FIELD_PROPERTY_AUTOINC, WB_DROPDOWN );
		pAutoIncrement->InsertEntry( aYes );
		pAutoIncrement->InsertEntry( aNo );
		pAutoIncrement->SelectEntryPos(0);
        InitializeControl(pAutoIncrement,HID_TAB_ENT_AUTOINCREMENT,true);
	}
	break;
	case tpTextLen:
		if( pTextLen )
			return;
		m_nPos++;
        pTextLenText = CreateText(STR_TEXT_LENGTH);
        pTextLen = CreateNumericControl(STR_HELP_TEXT_LENGTH, FIELD_PROPERTY_TEXTLEN,HID_TAB_ENT_TEXT_LEN);
		break;

	case tpType:
		if( m_pType)
			return;
		m_nPos++;
        m_pTypeText = CreateText(STR_TAB_FIELD_DATATYPE);
		m_pType = new OPropListBoxCtrl( this, STR_HELP_AUTOINCREMENT, FIELD_PRPOERTY_TYPE, WB_DROPDOWN );
		m_pType->SetDropDownLineCount(20);
		{
			const OTypeInfoMap* pTypeInfo = getTypeInfo();
			OTypeInfoMap::const_iterator aIter = pTypeInfo->begin();
            OTypeInfoMap::const_iterator aEnd = pTypeInfo->end();
			for(;aIter != aEnd;++aIter)
				m_pType->InsertEntry( aIter->second->aUIName );
		}
		m_pType->SelectEntryPos(0);
        InitializeControl(m_pType,HID_TAB_ENT_TYPE,true);
		break;
	case tpColumnName:
		if( m_pColumnName )
			return;
		m_nPos++;
        {
            sal_uInt32 nMax = EDIT_NOLIMIT;
            ::rtl::OUString aTmpString;
            try
            {
			    Reference< XDatabaseMetaData> xMetaData = getMetaData();
                if ( xMetaData.is() )
                {
			        nMax =  xMetaData->getMaxColumnNameLength();
                    aTmpString = xMetaData->getExtraNameCharacters();
                }
            }
            catch(Exception&)
            {
                DBG_UNHANDLED_EXCEPTION();
            }
            m_pColumnNameText = CreateText(STR_TAB_FIELD_NAME);
			m_pColumnName = new OPropColumnEditCtrl( this,
							                        aTmpString,
													STR_HELP_DEFAULT_VALUE,
													FIELD_PRPOERTY_COLUMNNAME,
													WB_BORDER );
			m_pColumnName->SetMaxTextLen(xub_StrLen( nMax ? nMax : EDIT_NOLIMIT));
			m_pColumnName->setCheck( isSQL92CheckEnabled(getConnection()) );
		}

        InitializeControl(m_pColumnName,HID_TAB_ENT_COLUMNNAME,false);
		break;
	case tpNumType:
		if( pNumType )
			return;
		m_nPos++;
        pNumTypeText = CreateText(STR_NUMERIC_TYPE);

		pNumType = new OPropListBoxCtrl( this, STR_HELP_NUMERIC_TYPE, FIELD_PROPERTY_NUMTYPE, WB_DROPDOWN );
		pNumType->SetDropDownLineCount(5);

		pNumType->InsertEntry( String::CreateFromAscii(""Byte"") );
		pNumType->InsertEntry( String::CreateFromAscii(""SmallInt"") );
		pNumType->InsertEntry( String::CreateFromAscii(""Integer"") );
		pNumType->InsertEntry( String::CreateFromAscii(""Single"") );
		pNumType->InsertEntry( String::CreateFromAscii(""Double"") );
		pNumType->SelectEntryPos(2);
        InitializeControl(pNumType,HID_TAB_ENT_NUMTYP,true);
		break;

	case tpLength:
		if( pLength )
			return;
		m_nPos++;
        pLengthText = CreateText(STR_LENGTH);
        pLength = CreateNumericControl(STR_HELP_LENGTH, FIELD_PROPERTY_LENGTH,HID_TAB_ENT_LEN);
		break;

	case tpScale:
		if( pScale )
			return;
		m_nPos++;
        pScaleText = CreateText(STR_SCALE);
        pScale = CreateNumericControl(STR_HELP_SCALE, FIELD_PROPERTY_SCALE,HID_TAB_ENT_SCALE);
		break;

	case tpFormat:
		if (!pFormat)
		{
			m_nPos++;
            pFormatText = CreateText(STR_FORMAT);

			pFormatSample = new OPropEditCtrl( this, STR_HELP_FORMAT_CODE, -1, WB_BORDER );
			pFormatSample->SetReadOnly(sal_True);
			pFormatSample->Enable(sal_False);
            InitializeControl(pFormatSample,HID_TAB_ENT_FORMAT_SAMPLE,false);

			pFormat = new PushButton( this, ModuleRes(PB_FORMAT) );
            const sal_Int32 nControlHeight = GetMaxControlHeight();
			pFormat->SetSizePixel(Size(nControlHeight, nControlHeight));
			pFormat->SetClickHdl( LINK( this, OFieldDescControl, FormatClickHdl ) );
            InitializeControl(pFormat,HID_TAB_ENT_FORMAT,false);
		}

		UpdateFormatSample(pActFieldDescr);
		break;
	case tpBoolDefault:
		if (pBoolDefault)
			return;

		m_nPos++;
        pBoolDefaultText = CreateText(STR_DEFAULT_VALUE);
		pBoolDefault = new OPropListBoxCtrl( this, STR_HELP_BOOL_DEFAULT, FIELD_PROPERTY_BOOL_DEFAULT, WB_DROPDOWN );
		pBoolDefault->SetDropDownLineCount(3);
		pBoolDefault->InsertEntry(String(ModuleRes(STR_VALUE_NONE)));
		pBoolDefault->InsertEntry(aYes);
		pBoolDefault->InsertEntry(aNo);

        InitializeControl(pBoolDefault,HID_TAB_ENT_BOOL_DEFAULT,false);
		break;
	}
}
// -----------------------------------------------------------------------------
void OFieldDescControl::InitializeControl(Control* _pControl,const ::rtl::OString& _sHelpId,bool _bAddChangeHandler)
{
    _pControl->SetHelpId(_sHelpId);
    if ( _bAddChangeHandler )
	    ((OPropListBoxCtrl*)_pControl)->SetSelectHdl(LINK(this,OFieldDescControl,ChangeHdl));

	_pControl->SetGetFocusHdl(LINK(this, OFieldDescControl, OnControlFocusGot));
	_pControl->SetLoseFocusHdl(LINK(this, OFieldDescControl, OnControlFocusLost));
	_pControl->EnableClipSiblings();
}
// -----------------------------------------------------------------------------
FixedText* OFieldDescControl::CreateText(sal_uInt16 _nTextRes)
{
    FixedText* pFixedText = new FixedText( this );
	pFixedText->SetText( ModuleRes(_nTextRes) );
    pFixedText->EnableClipSiblings();
    return pFixedText;
}
// -----------------------------------------------------------------------------
OPropNumericEditCtrl* OFieldDescControl::CreateNumericControl(sal_uInt16 _nHelpStr,short _nProperty,const rtl::OString& _sHelpId)
{
    OPropNumericEditCtrl* pControl = new OPropNumericEditCtrl( this, _nHelpStr, _nProperty, WB_BORDER );
	pControl->SetDecimalDigits(0);
	pControl->SetMin(0);
	pControl->SetMax(0x7FFFFFFF);	// soll draussen geaendert werden, wenn noetig
	pControl->SetStrictFormat(sal_True);

    InitializeControl(pControl,_sHelpId,false);

    return pControl;
}
//------------------------------------------------------------------------------
void OFieldDescControl::DeactivateAggregate( EControlType eType )
{
	DBG_CHKTHIS(OFieldDescControl,NULL);
    pLastFocusWindow = NULL;
	//////////////////////////////////////////////////////////////////////
	// Controls zerstoeren
	switch( eType )
	{
	case tpDefault:
        lcl_HideAndDeleteControl(m_nPos,&pDefault,&pDefaultText);
		break;

	case tpAutoIncrementValue:
        lcl_HideAndDeleteControl(m_nPos,&m_pAutoIncrementValue,&m_pAutoIncrementValueText);
		break;

	case tpColumnName:
        lcl_HideAndDeleteControl(m_nPos,&m_pColumnName,&m_pColumnNameText);
		break;

	case tpType:
        lcl_HideAndDeleteControl(m_nPos,&m_pType,&m_pTypeText);
		break;

	case tpAutoIncrement:
        lcl_HideAndDeleteControl(m_nPos,&pAutoIncrement,&pAutoIncrementText);
		break;

	case tpRequired:
        lcl_HideAndDeleteControl(m_nPos,&pRequired,&pRequiredText);
		break;

	case tpTextLen:
        lcl_HideAndDeleteControl(m_nPos,&pTextLen,&pTextLenText);
		break;

	case tpNumType:
        lcl_HideAndDeleteControl(m_nPos,&pNumType,&pNumTypeText);
		break;

	case tpLength:
		lcl_HideAndDeleteControl(m_nPos,&pLength,&pLengthText);
		break;

	case tpScale:
		lcl_HideAndDeleteControl(m_nPos,&pScale,&pScaleText);
		break;

	case tpFormat:
        // TODO: we have to check if we have to increment m_nPos again
        lcl_HideAndDeleteControl(m_nPos,&pFormat,&pFormatText);
        if ( pFormatSample )
        {
		    pFormatSample->Hide();
		    delete pFormatSample;
		    pFormatSample = NULL;
        }
		break;
	case tpBoolDefault:
		lcl_HideAndDeleteControl(m_nPos,&pBoolDefault,&pBoolDefaultText);
		break;
	}
}

//------------------------------------------------------------------------------
void OFieldDescControl::SetPosSize( Control** ppControl, long nRow, sal_uInt16 nCol )
{
	DBG_CHKTHIS(OFieldDescControl,NULL);
	
	//////////////////////////////////////////////////////////////////////
	// Groesse ermitteln
    const sal_Int32 nControlHeight = GetMaxControlHeight();
	Size aSize(0,nControlHeight);
    if ( isRightAligned() && nCol )
        aSize.Width() = LogicToPixel(Size(m_nWidth, 0),MAP_APPFONT).Width();
    else
    {
	    switch( nCol )
	    {
	    case 0:
        default:
		    aSize.Width()  = CONTROL_WIDTH_1;
		    break;
	    case 1:
			aSize.Width()  = CONTROL_WIDTH_2;
		    break;
	    case 3:
			aSize.Width()  = CONTROL_WIDTH_3;
		    break;
	    case 4:
			aSize.Width()  = CONTROL_WIDTH_4;
		    break;
	    } // switch( nCol )
    }


	//////////////////////////////////////////////////////////////////////
	// Position ermitteln
	Point aPosition;
	switch( nCol )
	{
	case 0:
		aPosition.X() = 0;
		aPosition.Y() = 1;
		break;
	case 1:
	case 3:
	case 4:
		if ( isRightAligned() )
		{
			Size aOwnSize = GetSizePixel();
			aPosition.X() = aOwnSize.Width() - aSize.Width();
		}
		else
			aPosition.X() = CONTROL_WIDTH_1 + CONTROL_SPACING_X;
		break;
	default:
		aPosition.X() = 0;
	}

    (*ppControl)->SetSizePixel( aSize );
    aSize = (*ppControl)->GetSizePixel( );

    const sal_Int32 nControl_Spacing_y = LogicToPixel(Size(0, CONTROL_SPACING_Y),MAP_APPFONT).Height();
	aPosition.Y() += ((nRow+1)*nControl_Spacing_y) +
					(nRow*nControlHeight);
	
	//////////////////////////////////////////////////////////////////////
	// Control anzeigen
	(*ppControl)->SetPosSizePixel( aPosition, aSize );
    aSize = (*ppControl)->GetSizePixel();
    
	(*ppControl)->Show();
}
//------------------------------------------------------------------------------
void OFieldDescControl::DisplayData(OFieldDescription* pFieldDescr )
{
	DBG_CHKTHIS(OFieldDescControl,NULL);
	pActFieldDescr = pFieldDescr;
	if(!pFieldDescr)
	{
		DeactivateAggregate( tpDefault );
		DeactivateAggregate( tpRequired );
		DeactivateAggregate( tpTextLen );
		DeactivateAggregate( tpNumType );
		DeactivateAggregate( tpScale );
		DeactivateAggregate( tpLength );
		DeactivateAggregate( tpFormat );
		DeactivateAggregate( tpAutoIncrement );
		DeactivateAggregate( tpBoolDefault );
		DeactivateAggregate( tpColumnName );
		DeactivateAggregate( tpType );
		DeactivateAggregate( tpAutoIncrementValue );
		m_pPreviousType = TOTypeInfoSP();
		//////////////////////////////////////////////////////////////////////
		// Zeiger des gespeicherten Focus zuruecksetzen
		pLastFocusWindow = NULL;
        if ( m_bAdded )
        {
		    ::dbaui::notifySystemWindow(this,this,::comphelper::mem_fun(&TaskPaneList::RemoveWindow));
            m_bAdded = sal_False;
        }
		return;
	}

    if ( !m_bAdded )
    {
	    ::dbaui::notifySystemWindow(this,this,::comphelper::mem_fun(&TaskPaneList::AddWindow));
        m_bAdded = sal_True;
    }

	TOTypeInfoSP pFieldType;
	if( pFieldDescr )
		pFieldType = pFieldDescr->getTypeInfo();

	ActivateAggregate( tpColumnName );
	ActivateAggregate( tpType );

	OSL_ENSURE(pFieldType.get(),""We need a type information here!"");
	//////////////////////////////////////////////////////////////////////
	// Wenn sich der Typ geaendert hat, Controls austauschen
	if( m_pPreviousType != pFieldType )
	{
		//////////////////////////////////////////////////////////////////////
		// Zeiger des gespeicherten Focus zuruecksetzen
		pLastFocusWindow = NULL;

		//////////////////////////////////////////////////////////////////////
		// Controls, die nicht mehr angezeigt werden duerfen
		DeactivateAggregate( tpNumType );

		//////////////////////////////////////////////////////////////////////
		// determine which controls we should show and which not

		// 1. the required control
		if ( pFieldType->bNullable )
			ActivateAggregate( tpRequired );
		else
			DeactivateAggregate( tpRequired );

		// 2. the autoincrement
		if ( pFieldType->bAutoIncrement )
		{
			DeactivateAggregate( tpRequired );
			DeactivateAggregate( tpDefault );
			ActivateAggregate( tpAutoIncrement );
			ActivateAggregate( tpAutoIncrementValue );
		}
		else
		{
			DeactivateAggregate( tpAutoIncrement );
			DeactivateAggregate( tpAutoIncrementValue );
			if(pFieldType->bNullable)
				ActivateAggregate( tpRequired );
			else
				DeactivateAggregate( tpRequired );
			ActivateAggregate( tpDefault );
		}
		// 3. the scale and precision
		if (pFieldType->nPrecision)
		{
			ActivateAggregate( tpLength );
			pLength->SetMax(::std::max<sal_Int32>(pFieldType->nPrecision,pFieldDescr->GetPrecision()));
			pLength->SetSpecialReadOnly(pFieldType->aCreateParams.getLength()==0);
		}
		else
			DeactivateAggregate( tpLength );

		if (pFieldType->nMaximumScale)
		{
			ActivateAggregate( tpScale );
			pScale->SetMax(::std::max<sal_Int32>(pFieldType->nMaximumScale,pFieldDescr->GetScale()));
			pScale->SetMin(pFieldType->nMinimumScale);
            static const ::rtl::OUString s_sPRECISION(RTL_CONSTASCII_USTRINGPARAM(""PRECISION""));
			pScale->SetSpecialReadOnly(pFieldType->aCreateParams.getLength() == 0 || pFieldType->aCreateParams == s_sPRECISION);
		}
		else
			DeactivateAggregate( tpScale );

		// and now look for type specific things
		switch( pFieldType->nType )
		{
			case DataType::CHAR:
			case DataType::VARCHAR:
			case DataType::LONGVARCHAR:
				DeactivateAggregate( tpLength );
				DeactivateAggregate( tpBoolDefault );

				ActivateAggregate( tpDefault );
				ActivateAggregate( tpFormat );
				if (pFieldType->nPrecision)
				{
					ActivateAggregate( tpTextLen );
					pTextLen->SetMax(::std::max<sal_Int32>(pFieldType->nPrecision,pFieldDescr->GetPrecision()));
					pTextLen->SetSpecialReadOnly(pFieldType->aCreateParams.getLength()==0);
				}
				else
					DeactivateAggregate( tpTextLen );
				break;
			case DataType::DATE:
			case DataType::TIME:
			case DataType::TIMESTAMP:
				DeactivateAggregate( tpLength ); // we don't need a length for date types
				DeactivateAggregate( tpTextLen );
				DeactivateAggregate( tpBoolDefault );

				ActivateAggregate( tpDefault );
				ActivateAggregate( tpFormat );
				break;
			case DataType::BIT:
				if ( pFieldType->aCreateParams.getLength() )
				{
					DeactivateAggregate( tpFormat );
					DeactivateAggregate( tpTextLen );
					DeactivateAggregate( tpBoolDefault );
					break;
				}
				// run through
			case DataType::BOOLEAN:
				DeactivateAggregate( tpTextLen );
				DeactivateAggregate( tpFormat );
				DeactivateAggregate( tpDefault );

				ActivateAggregate( tpBoolDefault );
				break;
			case DataType::DECIMAL:
			case DataType::NUMERIC:
			case DataType::BIGINT:
			case DataType::FLOAT:
			case DataType::DOUBLE:
			case DataType::TINYINT:
			case DataType::SMALLINT:
			case DataType::INTEGER:
			case DataType::REAL:
				DeactivateAggregate( tpTextLen );
				DeactivateAggregate( tpBoolDefault );

				ActivateAggregate( tpFormat );
				break;
			case DataType::BINARY:
			case DataType::VARBINARY:
				DeactivateAggregate( tpDefault );
				DeactivateAggregate( tpRequired );
				DeactivateAggregate( tpTextLen );
				DeactivateAggregate( tpBoolDefault );

				ActivateAggregate( tpFormat );
				break;
			case DataType::LONGVARBINARY:
			case DataType::SQLNULL:
			case DataType::OBJECT:
			case DataType::DISTINCT:
			case DataType::STRUCT:
			case DataType::ARRAY:
			case DataType::BLOB:
			case DataType::CLOB:
			case DataType::REF:
			case DataType::OTHER:
				DeactivateAggregate( tpFormat );
				DeactivateAggregate( tpTextLen );
				DeactivateAggregate( tpBoolDefault );

				break;
			default:
				OSL_ENSURE(0,""Unknown type"");
		}
		m_pPreviousType = pFieldType;
	}
	if(pFieldDescr)
	{
		if(pFieldDescr->IsPrimaryKey())
		{
			DeactivateAggregate( tpRequired );
		}
		else if ( !pAutoIncrement && pFieldType.get() )
		{
			if ( pFieldType->bNullable )
				ActivateAggregate( tpRequired );
			else
				DeactivateAggregate( tpRequired );
		}
	}
	//////////////////////////////////////////////////////////////////////
	// Controls initialisieren
	if( pAutoIncrement )
	{
		if ( pFieldDescr->IsAutoIncrement() )
		{
			pAutoIncrement->SelectEntryPos( 0 ); // yes
            ActivateAggregate( tpAutoIncrementValue );
			if ( m_pAutoIncrementValue )
				m_pAutoIncrementValue->SetText(pFieldDescr->GetAutoIncrementValue());
			DeactivateAggregate( tpRequired );
			DeactivateAggregate( tpDefault );
		}
		else
		{
			// disable autoincrement value because it should only be visible when autoincrement is to true
			DeactivateAggregate( tpAutoIncrementValue );
			pAutoIncrement->SelectEntryPos( 1 );		// no
			ActivateAggregate( tpDefault );
			// hat Auswirkungen auf pRequired
			if(!pFieldDescr->IsPrimaryKey())
				ActivateAggregate( tpRequired );
		}
	}

	if( pDefault )
	{
		pDefault->SetText( getControlDefault(pFieldDescr) );
		pDefault->ClearModifyFlag();
	}

	if( pBoolDefault )
	{
		// wenn pRequired auf sal_True gesetzt ist, dann darf das sal_Bool Feld nicht den Eintrag <<keiner>> besitzen
		::rtl::OUString sValue; 
		pFieldDescr->GetControlDefault() >>= sValue;
		String sDef = BoolStringUI(sValue);

		// sicher stellen das <<keiner>> nur vorhanden ist, wenn das Feld NULL sein darf
		if ( ( pFieldType.get() && !pFieldType->bNullable ) || !pFieldDescr->IsNullable() )
		{
			pFieldDescr->SetIsNullable(ColumnValue::NO_NULLS); // der Typ sagt das

			pBoolDefault->RemoveEntry(String(ModuleRes(STR_VALUE_NONE)));
			if ( !sDef.Equals(aYes) && !sDef.Equals(aNo) )
				pBoolDefault->SelectEntryPos(1);  // nein als Default
			else
				pBoolDefault->SelectEntry(sDef);

			pFieldDescr->SetControlDefault(makeAny(::rtl::OUString(BoolStringPersistent(pBoolDefault->GetSelectEntry()))));
		}
		else if(pBoolDefault->GetEntryCount() < 3)
		{
			pBoolDefault->InsertEntry(String(ModuleRes(STR_VALUE_NONE)));
			pBoolDefault->SelectEntry(sDef);
		}
		else
			pBoolDefault->SelectEntry(sDef);
	}

	if( pRequired )
	{
		if( pFieldDescr->IsNullable() )
			pRequired->SelectEntryPos( 1 );	// no
		else
			pRequired->SelectEntryPos( 0 );	// yes
	}

	if( pTextLen )
	{
		pTextLen->SetText( String::CreateFromInt32(pFieldDescr->GetPrecision()) );
		pTextLen->ClearModifyFlag();
	}

	if( pNumType )
	{
		OSL_ENSURE(sal_False, ""OFieldDescControl::DisplayData: invalid num type!"");
	}

	if( pLength )
		pLength->SetText( String::CreateFromInt32(pFieldDescr->GetPrecision()) );

	if( pScale )
		pScale->SetText( String::CreateFromInt32(pFieldDescr->GetScale()) );

	if( pFormat )
		UpdateFormatSample(pFieldDescr);

	if(m_pColumnName)
		m_pColumnName->SetText(pFieldDescr->GetName());

	if(m_pType)
	{
		sal_uInt16 nPos = pFieldType.get() ? m_pType->GetEntryPos(String(pFieldDescr->getTypeInfo()->aUIName)) : LISTBOX_ENTRY_NOTFOUND;
		if(nPos == LISTBOX_ENTRY_NOTFOUND)
		{
			const OTypeInfoMap*	pMap = getTypeInfo();
			OTypeInfoMap::const_iterator aIter = pMap->find(pFieldType.get() ? pFieldDescr->getTypeInfo()->nType : pFieldDescr->GetType());
			if(aIter == pMap->end() && !pMap->empty())
			{
				aIter = pMap->begin();
				if(pFieldDescr->GetPrecision() > aIter->second->nPrecision)
					pFieldDescr->SetPrecision(aIter->second->nPrecision);
				if(pFieldDescr->GetScale() > aIter->second->nMaximumScale)
					pFieldDescr->SetScale(0);
				if(!aIter->second->bNullable && pFieldDescr->IsNullable())
					pFieldDescr->SetIsNullable(ColumnValue::NO_NULLS);
				if(!aIter->second->bAutoIncrement && pFieldDescr->IsAutoIncrement())
					pFieldDescr->SetAutoIncrement(sal_False);
			}
			if ( aIter != pMap->end() )
			{
				pFieldDescr->SetType(aIter->second);
			}
		}
		m_pType->SelectEntry(pFieldDescr->getTypeInfo()->aUIName);
	}


	//////////////////////////////////////////////////////////////////////
	// Controls Enablen/Disablen
	sal_Bool bRead(IsReadOnly());


	ArrangeAggregates();
	CheckScrollBars();
	ScrollAllAggregates();

	SetReadOnly( bRead );
}
//------------------------------------------------------------------------
IMPL_LINK(OFieldDescControl, DelayedGrabFocus, Control**, ppControl)
{
	nDelayedGrabFocusEvent = 0;
	if (*ppControl)
		(*ppControl)->GrabFocus();

	return 0L;
}

//------------------------------------------------------------------------------
IMPL_LINK(OFieldDescControl, OnControlFocusGot, Control*, pControl )
{
	String strHelpText;
    OPropNumericEditCtrl* pNumeric = dynamic_cast< OPropNumericEditCtrl* >( pControl );
    if ( pNumeric )
	{
		pNumeric->SaveValue();
		strHelpText = pNumeric->GetHelp();
	}

    OPropColumnEditCtrl* pColumn = dynamic_cast< OPropColumnEditCtrl* >( pControl );
    if ( pColumn )
	{
		pColumn->SaveValue();
		strHelpText = pColumn->GetHelp();
	}

    OPropEditCtrl* pEdit = dynamic_cast< OPropEditCtrl* >( pControl );
    if ( pEdit )
	{
		pEdit->SaveValue();
		strHelpText = pEdit->GetHelp();
	}

    OPropListBoxCtrl* pListBox = dynamic_cast< OPropListBoxCtrl* >( pControl );
    if ( pListBox )
	{
		pListBox->SaveValue();
		strHelpText = pListBox->GetHelp();
	}

    if (pControl == pFormat)
		strHelpText  =String(ModuleRes(STR_HELP_FORMAT_BUTTON));

	if (strHelpText.Len() && (pHelp != NULL))
		pHelp->SetHelpText(strHelpText);

	m_pActFocusWindow = pControl;

	return 0L;
}

//------------------------------------------------------------------------------
IMPL_LINK(OFieldDescControl, OnControlFocusLost, Control*, pControl )
{
	if ((pControl == pLength) || (pControl == pTextLen) || (pControl == pScale))
	{
		OPropNumericEditCtrl* pConverted = (OPropNumericEditCtrl*)pControl;
		if (pConverted->IsModified())
			CellModified(-1, pConverted->GetPos());
	}
	if(pControl == m_pColumnName)
	{
		OPropColumnEditCtrl* pConverted = (OPropColumnEditCtrl*)pControl;
		if (pConverted->IsModified())
			CellModified(-1, pConverted->GetPos());
	}
	else if ((pControl == pDefault) || (pControl == pFormatSample) || (pControl == m_pAutoIncrementValue) )
	{
		OPropEditCtrl* pConverted = (OPropEditCtrl*)pControl;
		if (pConverted->IsModified())
			CellModified(-1, pConverted->GetPos());
	}
	else if ((pControl == pRequired) || (pControl == pNumType) || (pControl == pAutoIncrement) || (pControl == pBoolDefault) || (pControl == m_pType))
	{
		OPropListBoxCtrl* pConverted = (OPropListBoxCtrl*)pControl;
		if (pConverted->IsModified())
			CellModified(-1, pConverted->GetPos());
	}

	if (pControl == pDefault)
		UpdateFormatSample(pActFieldDescr);

	implFocusLost(pControl);

	return 0L;
}
//------------------------------------------------------------------------------
void OFieldDescControl::SaveData( OFieldDescription* pFieldDescr )
{
	DBG_CHKTHIS(OFieldDescControl,NULL);
	if( !pFieldDescr )
		return;

	//////////////////////////////////////////////////////////////////////
	// Controls auslesen
	::rtl::OUString sDefault;
	if (pDefault)
	{
		sDefault = pDefault->GetText();
	}
	else if (pBoolDefault)
	{
		sDefault = BoolStringPersistent(pBoolDefault->GetSelectEntry());
	}

	if ( sDefault.getLength() )
        pFieldDescr->SetControlDefault(makeAny(sDefault));
	else
		pFieldDescr->SetControlDefault(Any());

	if((pRequired && pRequired->GetSelectEntryPos() == 0) || pFieldDescr->IsPrimaryKey() || (pBoolDefault && pBoolDefault->GetEntryCount() == 2))  // yes
		pFieldDescr->SetIsNullable( ColumnValue::NO_NULLS );
	else
		pFieldDescr->SetIsNullable( ColumnValue::NULLABLE );

	if ( pAutoIncrement )
		pFieldDescr->SetAutoIncrement( pAutoIncrement->GetSelectEntryPos() == 0 );

	if( pTextLen )
		pFieldDescr->SetPrecision( static_cast<sal_Int32>(pTextLen->GetValue()) );
	else if( pLength )
		pFieldDescr->SetPrecision( static_cast<sal_Int32>(pLength->GetValue()) );
	if( pScale )
		pFieldDescr->SetScale( static_cast<sal_Int32>(pScale->GetValue()) );

	if(m_pColumnName)
		pFieldDescr->SetName(m_pColumnName->GetText());

	if ( m_pAutoIncrementValue && isAutoIncrementValueEnabled() )
		pFieldDescr->SetAutoIncrementValue(m_pAutoIncrementValue->GetText());
}

//------------------------------------------------------------------------------
void OFieldDescControl::UpdateFormatSample(OFieldDescription* pFieldDescr)
{
	if ( pFieldDescr && pFormatSample )
	    pFormatSample->SetText(getControlDefault(pFieldDescr,sal_False));
}

//------------------------------------------------------------------------------
void OFieldDescControl::GetFocus()
{
	DBG_CHKTHIS(OFieldDescControl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Setzt den Focus auf das zuletzt aktive Control
	TabPage::GetFocus();
	if( pLastFocusWindow )
	{
		pLastFocusWindow->GrabFocus();
		pLastFocusWindow = NULL;
	}
}

//------------------------------------------------------------------------------
void OFieldDescControl::implFocusLost(Window* _pWhich)
{
	DBG_CHKTHIS(OFieldDescControl,NULL);
	DBG_ASSERT(!_pWhich || IsChild(_pWhich), ""OFieldDescControl::implFocusLost : invalid window !"");

	//////////////////////////////////////////////////////////////////////
	// Das aktive Control merken
	if (!pLastFocusWindow)
		pLastFocusWindow = _pWhich;

	//////////////////////////////////////////////////////////////////////
	// HelpText zuruecksetzen
	if (pHelp && !pHelp->HasChildPathFocus())
		pHelp->SetHelpText( String() );
}

//------------------------------------------------------------------------------
void OFieldDescControl::LoseFocus()
{
	DBG_CHKTHIS(OFieldDescControl,NULL);

	implFocusLost(NULL);

	TabPage::LoseFocus();
}
// -----------------------------------------------------------------------------
sal_Bool OFieldDescControl::isCopyAllowed()
{
	sal_Bool bAllowed = (m_pActFocusWindow != NULL) &&
						(m_pActFocusWindow == pDefault || m_pActFocusWindow == pFormatSample	||
						m_pActFocusWindow == pTextLen || m_pActFocusWindow == pLength			||
						m_pActFocusWindow == pScale	 || m_pActFocusWindow == m_pColumnName		||
						m_pActFocusWindow == m_pAutoIncrementValue) &&
						static_cast<Edit*>(m_pActFocusWindow)->GetSelected().Len() != 0;

	return bAllowed;
}
// -----------------------------------------------------------------------------
sal_Bool OFieldDescControl::isCutAllowed()
{
	sal_Bool bAllowed = (m_pActFocusWindow != NULL) &&
						(m_pActFocusWindow == pDefault || m_pActFocusWindow == pFormatSample	||
						m_pActFocusWindow == pTextLen || m_pActFocusWindow == pLength			||
						m_pActFocusWindow == pScale	 || m_pActFocusWindow == m_pColumnName		||
						m_pActFocusWindow == m_pAutoIncrementValue) &&
						static_cast<Edit*>(m_pActFocusWindow)->GetSelected().Len() != 0;
	return bAllowed;
}
// -----------------------------------------------------------------------------
sal_Bool OFieldDescControl::isPasteAllowed()
{
	sal_Bool bAllowed = (m_pActFocusWindow != NULL) &&
						(m_pActFocusWindow == pDefault || m_pActFocusWindow == pFormatSample	||
						m_pActFocusWindow == pTextLen || m_pActFocusWindow == pLength			||
						m_pActFocusWindow == pScale	 || m_pActFocusWindow == m_pColumnName		||
						m_pActFocusWindow == m_pAutoIncrementValue);
	if ( bAllowed )
	{
		TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent()));
		bAllowed = aTransferData.HasFormat(SOT_FORMAT_STRING);
	}
	return bAllowed;
}
// -----------------------------------------------------------------------------
void OFieldDescControl::cut()
{
	if(isCutAllowed())
		static_cast<Edit*>(m_pActFocusWindow)->Cut();
}
// -----------------------------------------------------------------------------
void OFieldDescControl::copy()
{
	if(isCopyAllowed()) // this only checks if the focus window is valid
		static_cast<Edit*>(m_pActFocusWindow)->Copy();
}
// -----------------------------------------------------------------------------
void OFieldDescControl::paste()
{
	if(m_pActFocusWindow) // this only checks if the focus window is valid
		static_cast<Edit*>(m_pActFocusWindow)->Paste();
}
// -----------------------------------------------------------------------------
sal_Bool OFieldDescControl::isTextFormat(const OFieldDescription* _pFieldDescr,sal_uInt32& _nFormatKey) const
{
	_nFormatKey = _pFieldDescr->GetFormatKey();
	sal_Bool bTextFormat = sal_True;

	try
	{
		if (!_nFormatKey)
		{
			Reference< ::com::sun::star::util::XNumberFormatTypes> xNumberTypes(GetFormatter()->getNumberFormatsSupplier()->getNumberFormats(),UNO_QUERY);
			OSL_ENSURE(xNumberTypes.is(),""XNumberFormatTypes is null!"");

			_nFormatKey = ::dbtools::getDefaultNumberFormat( _pFieldDescr->GetType(),
				_pFieldDescr->GetScale(),
				_pFieldDescr->IsCurrency(),
				xNumberTypes,
				GetLocale());
		}
		sal_Int32 nNumberFormat = ::comphelper::getNumberFormatType(GetFormatter(),_nFormatKey);
		bTextFormat = (nNumberFormat == ::com::sun::star::util::NumberFormat::TEXT);
	}
	catch(const Exception&)
	{

	}

	return bTextFormat;
}
// -----------------------------------------------------------------------------
String OFieldDescControl::getControlDefault( const OFieldDescription* _pFieldDescr ,sal_Bool _bCheck) const
{
	::rtl::OUString sDefault;
	sal_Bool bCheck = !_bCheck || _pFieldDescr->GetControlDefault().hasValue();
	if ( bCheck )
	{
		sal_uInt32 nFormatKey;
		sal_Bool bTextFormat = sal_False;
		double nValue = 0.0;

		try
		{
			bTextFormat = isTextFormat(_pFieldDescr,nFormatKey);
			if ( _pFieldDescr->GetControlDefault() >>= sDefault )
			{
				if ( !bTextFormat )
				{
					if ( sDefault.getLength() )
					{
						try
						{
							nValue = GetFormatter()->convertStringToNumber(nFormatKey,sDefault);
						}
						catch(const Exception&)
						{
							return ::rtl::OUString(); // return empty string for format example
						}
					}
				}
			}
			else
				_pFieldDescr->GetControlDefault() >>= nValue;


			Reference< ::com::sun::star::util::XNumberFormatter> xNumberFormatter = GetFormatter();
			Reference<XPropertySet> xFormSet = xNumberFormatter->getNumberFormatsSupplier()->getNumberFormats()->getByKey(nFormatKey);
			OSL_ENSURE(xFormSet.is(),""XPropertySet is null!"");
			::rtl::OUString sFormat;
			xFormSet->getPropertyValue(::rtl::OUString::createFromAscii(""FormatString"")) >>= sFormat;

			if ( !bTextFormat )
			{
				Locale aLocale;
				::comphelper::getNumberFormatProperty(xNumberFormatter,nFormatKey,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(""Locale""))) >>= aLocale;

				sal_Int32 nNumberFormat = ::comphelper::getNumberFormatType(xNumberFormatter,nFormatKey);
				if(		(nNumberFormat & ::com::sun::star::util::NumberFormat::DATE)	== ::com::sun::star::util::NumberFormat::DATE
					|| (nNumberFormat & ::com::sun::star::util::NumberFormat::DATETIME) == ::com::sun::star::util::NumberFormat::DATETIME )
				{
					nValue = DBTypeConversion::toNullDate(DBTypeConversion::getNULLDate(xNumberFormatter->getNumberFormatsSupplier()),nValue);
				}



				Reference< ::com::sun::star::util::XNumberFormatPreviewer> xPreViewer(xNumberFormatter,UNO_QUERY);
				OSL_ENSURE(xPreViewer.is(),""XNumberFormatPreviewer is null!"");
				sDefault = xPreViewer->convertNumberToPreviewString(sFormat,nValue,aLocale,sal_True);
			}
			else if ( !_bCheck || (sDefault.getLength() != 0) )
				sDefault = xNumberFormatter->formatString(nFormatKey,(sDefault.getLength() != 0 )? sDefault : sFormat);
		}
		catch(const Exception&)
		{

		}
	}

	return sDefault;
}
// -----------------------------------------------------------------------------
",16141,True,3132.185515939227,median
"[[salesforce-component]]
== Salesforce Component

*Available as of Camel version 2.12*

This component supports producer and consumer endpoints to communicate
with Salesforce using Java DTOs.  +
 There is a companion maven plugin Camel Salesforce Plugin that
generates these DTOs (see further below).

Maven users will need to add the following dependency to their `pom.xml`
for this component:

[source,xml]
----
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-salesforce</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
----

NOTE: Developers wishing to contribute to the component are instructed
to look at the https://github.com/apache/camel/tree/master/components/camel-salesforce/camel-salesforce-component/README.md[README.md] file on instructions on how to get started and
setup your environment for running integration tests.

=== Authenticating to Salesforce

The component supports three OAuth authentication flows:

* https://help.salesforce.com/articleView?id=remoteaccess_oauth_username_password_flow.htm[OAuth 2.0 Username-Password Flow]
* https://help.salesforce.com/articleView?id=remoteaccess_oauth_refresh_token_flow.htm[OAuth 2.0 Refresh Token Flow]
* https://help.salesforce.com/articleView?id=remoteaccess_oauth_jwt_flow.htm[OAuth 2.0 JWT Bearer Token Flow]

For each of the flow different set of properties needs to be set:

.Properties to set for each authentication flow
|===
| Property     | Where to find it on Salesforce     | Flow

| clientId     | Connected App, Consumer Key        | All flows
| clientSecret | Connected App, Consumer Secret     | Username-Password, Refresh Token
| userName     | Salesforce user username           | Username-Password, JWT Bearer Token
| password     | Salesforce user password           | Username-Password
| refreshToken | From OAuth flow callback           | Refresh Token
| keystore     | Connected App, Digital Certificate | JWT Bearer Token
|===

The component auto determines what flow you're trying to configure, to
be remove ambiguity set the `authenticationType` property.

NOTE: Using Username-Password Flow in production is not encouraged.

NOTE: The certificate used in JWT Bearer Token Flow can be a selfsigned 
certificate. The KeyStore holding the certificate and the private key
must contain only single certificate-private key entry.

=== URI format

When used as a consumer, receiving streaming events, the URI scheme is:

[source,java]
----
salesforce:topic?options
----

When used as a producer, invoking the Salesforce REST APIs, the URI
scheme is:

[source,java]
----
salesforce:operationName?options
----

You can append query options to the URI in the following format,
`?option=value&option=value&...`

=== Passing in Salesforce headers and fetching Salesforce response headers

There is support to pass https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/headers.htm[Salesforce headers]
via inbound message headers, header names that start with `Sforce` or
`x-sfdc` on the Camel message will be passed on in the request, and
response headers that start with `Sforce` will be present in the outbound
message headers.

For example to fetch API limits you can specify:

[source,java]
----
// in your Camel route set the header before Salesforce endpoint
//...
  .setHeader(""Sforce-Limit-Info"", constant(""api-usage""))
  .to(""salesforce:getGlobalObjects"")
  .to(myProcessor);

// myProcessor will receive `Sforce-Limit-Info` header on the outbound
// message
class MyProcessor implements Processor {
    public void process(Exchange exchange) throws Exception {
        Message in = exchange.getIn();
        String apiLimits = in.getHeader(""Sforce-Limit-Info"", String.class);
   }
}
----

=== Supported Salesforce APIs

The component supports the following Salesforce APIs

Producer endpoints can use the following APIs. Most of the APIs process
one record at a time, the Query API can retrieve multiple Records.

==== Rest API

You can use the following for `operationName`:

* getVersions - Gets supported Salesforce REST API versions
* getResources - Gets available Salesforce REST Resource endpoints
* getGlobalObjects - Gets metadata for all available SObject types
* getBasicInfo - Gets basic metadata for a specific SObject type
* getDescription - Gets comprehensive metadata for a specific SObject
type
* getSObject - Gets an SObject using its Salesforce Id
* createSObject - Creates an SObject
* updateSObject - Updates an SObject using Id
* deleteSObject - Deletes an SObject using Id
* getSObjectWithId - Gets an SObject using an external (user defined) id
field
* upsertSObject - Updates or inserts an SObject using an external id
* deleteSObjectWithId - Deletes an SObject using an external id
* query - Runs a Salesforce SOQL query
* queryMore - Retrieves more results (in case of large number of
results) using result link returned from the 'query' API
* search - Runs a Salesforce SOSL query
* limits - fetching organization API usage limits
* recent - fetching recent items
* approval - submit a record or records (batch) for approval process
* approvals - fetch a list of all approval processes
* composite - submit up to 25 possibly related REST requests and receive individual responses
* composite-tree - create up to 200 records with parent-child relationships (up to 5 levels) in one go
* composite-batch - submit a composition of requests in batch
* queryAll - Runs a SOQL query. It returns the results that are deleted because of a merge or delete. Also returns the  information about archived Task and Event records.
* getBlobField - Retrieves the specified blob field from an individual record.
* apexCall - Executes a user defined APEX REST API call.

For example, the following producer endpoint uses the upsertSObject API,
with the sObjectIdName parameter specifying 'Name' as the external id
field. 
The request message body should be an SObject DTO generated using the
maven plugin.  
The response message will either be `null` if an existing record was
updated, or `CreateSObjectResult` with an id of the new record, or a
list of errors while creating the new object.

[source,java]
----
...to(""salesforce:upsertSObject?sObjectIdName=Name"")...
----

==== Rest Bulk API

Producer endpoints can use the following APIs. All Job data formats,
i.e. xml, csv, zip/xml, and zip/csv are supported.  +
 The request and response have to be marshalled/unmarshalled by the
route. Usually the request will be some stream source like a CSV file,
 +
 and the response may also be saved to a file to be correlated with the
request.

You can use the following for `operationName`:

* createJob - Creates a Salesforce Bulk Job
* getJob - Gets a Job using its Salesforce Id
* closeJob - Closes a Job
* abortJob - Aborts a Job
* createBatch - Submits a Batch within a Bulk Job
* getBatch - Gets a Batch using Id
* getAllBatches - Gets all Batches for a Bulk Job Id
* getRequest - Gets Request data (XML/CSV) for a Batch
* getResults - Gets the results of the Batch when its complete
* createBatchQuery - Creates a Batch from an SOQL query
* getQueryResultIds - Gets a list of Result Ids for a Batch Query
* getQueryResult - Gets results for a Result Id
* getRecentReports - Gets up to 200 of the reports you most recently viewed by sending a GET request to the Report List resource.
* getReportDescription - Retrieves the report, report type, and related metadata for a report, either in a tabular or summary or matrix format.
* executeSyncReport - Runs a report synchronously with or without changing filters and returns the latest summary data.
* executeAsyncReport - Runs an instance of a report asynchronously with or without filters and returns the summary data with or without details.
* getReportInstances - Returns a list of instances for a report that you requested to be run asynchronously. Each item in the list is treated as a separate instance of the report.
* getReportResults: Contains the results of running a report.

For example, the following producer endpoint uses the createBatch API to
create a Job Batch. The in message must contain a body that can be converted into an
`InputStream` (usually UTF-8 CSV or XML content from a file, etc.) and
header fields 'jobId' for the Job and 'contentType' for the Job content
type, which can be XML, CSV, ZIP_XML or ZIP_CSV. The put message body
will contain `BatchInfo` on success, or throw a `SalesforceException` on
error.

[source,java]
----
...to(""salesforce:createBatchJob"")..
----

==== Rest Streaming API

Consumer endpoints can use the following syntax for streaming endpoints
to receive Salesforce notifications on create/update.

To create and subscribe to a topic

[source,java]
----
from(""salesforce:CamelTestTopic?notifyForFields=ALL&notifyForOperations=ALL&sObjectName=Merchandise__c&updateTopic=true&sObjectQuery=SELECT Id, Name FROM Merchandise__c"")...
----

To subscribe to an existing topic

[source,java]
----
from(""salesforce:CamelTestTopic&sObjectName=Merchandise__c"")...
----

==== Platform events

To emit a platform event use `createSObject` operation. And set the
message body can be JSON string or InputStream with key-value data --
in that case `sObjectName` needs to be set to the API name of the
event, or a class that extends from AbstractDTOBase with the
appropriate class name for the event.

For example using a DTO:

[source,java]
----
class Order_Event__e extends AbstractDTOBase {
  @JsonProperty(""OrderNumber"")
  private String orderNumber;
  // ... other properties and getters/setters
}

from(""timer:tick"")
    .process(exchange -> {
        final Message in = exchange.getIn();
        String orderNumber = ""ORD"" + String.valueOf(in.getHeader(Exchange.TIMER_COUNTER));
        Order_Event__e event = new Order_Event__e();
        event.setOrderNumber(orderNumber);
        in.setBody(event);
    })
    .to(""salesforce:createSObject"");
----

Or using JSON event data:

[source,java]
----
from(""timer:tick"")
    .process(exchange -> {
        final Message in = exchange.getIn();
        String orderNumber = ""ORD"" + String.valueOf(in.getHeader(Exchange.TIMER_COUNTER));
        in.setBody(""{\\""OrderNumber\\"":\\"""" + orderNumber + ""\\""}"");
    })
    .to(""salesforce:createSObject?sObjectName=Order_Event__e"");
----

To receive platform events use the consumer endpoint with the API name of
the platform event prefixed with `event/` (or `/event/`), e.g.:
`salesforce:events/Order_Event__e`. Processor consuming from that
endpoint will receive either `org.apache.camel.component.salesforce.api.dto.PlatformEvent`
object or `org.cometd.bayeux.Message` in the body depending on the
`rawPayload` being `false` or `true` respectively.

For example, in the simplest form to consume one event:

[source,java]
----
PlatformEvent event = consumer.receiveBody(""salesforce:event/Order_Event__e"", PlatformEvent.class);
----

==== Change data capture events

On the one hand, Salesforce could be configured to emit notifications for record changes of select objects.
On the other hand, the Camel Salesforce component could react to such notifications, allowing for instance to
https://trailhead.salesforce.com/en/content/learn/modules/change-data-capture/understand-change-data-capture[synchronize those changes into an external system].

The notifications of interest could be specified in the `from(""salesforce:XXX"")` clause of a Camel route via the subscription channel, e.g:

[source,java]
----
from(""salesforce:data/ChangeEvents?replayId=-1"").log(""being notified of all change events"")
from(""salesforce:data/AccountChangeEvent?replayId=-1"").log(""being notified of change events for Account records"")
from(""salesforce:data/Employee__ChangeEvent?replayId=-1"").log(""being notified of change events for Employee__c custom object"")
----

The received message contains either `java.util.Map<String,Object>` or `org.cometd.bayeux.Message` in the body depending on the `rawPayload` being `false` or `true` respectively. The `CamelSalesforceChangeType` header could be valued to one of `CREATE`, `UPDATE`,  `DELETE` or `UNDELETE`.

More details about how to use the Camel Salesforce component change data capture capabilities could be found in the https://github.com/apache/camel/tree/master/components/camel-salesforce/camel-salesforce-component/src/test/java/org/apache/camel/component/salesforce/ChangeEventsConsumerIntegrationTest.java[ChangeEventsConsumerIntegrationTest].

The https://developer.salesforce.com/docs/atlas.en-us.change_data_capture.meta/change_data_capture/cdc_intro.htm[Salesforce developer guide]
is a good fit to better know the subtleties of implementing a change data capture integration application.
The dynamic nature of change event body fields, high level replication steps as well as security considerations could be of interest.

=== Examples

==== Uploading a document to a ContentWorkspace

Create the ContentVersion in Java, using a Processor instance:

[source,java]
----
public class ContentProcessor implements Processor {
    public void process(Exchange exchange) throws Exception {
        Message message = exchange.getIn();

        ContentVersion cv = new ContentVersion();
        ContentWorkspace cw = getWorkspace(exchange);
        cv.setFirstPublishLocationId(cw.getId());
        cv.setTitle(""test document"");
        cv.setPathOnClient(""test_doc.html"");
        byte[] document = message.getBody(byte[].class);
        ObjectMapper mapper = new ObjectMapper();
        String enc = mapper.convertValue(document, String.class);
        cv.setVersionDataUrl(enc);
        message.setBody(cv);
    }

    protected ContentWorkspace getWorkSpace(Exchange exchange) {
        // Look up the content workspace somehow, maybe use enrich() to add it to a
        // header that can be extracted here
        ....
    }
} 
----

Give the output from the processor to the Salesforce component:

[source,java]
----
from(""file:///home/camel/library"")
    .to(new ContentProcessor())     // convert bytes from the file into a ContentVersion SObject 
                                    // for the salesforce component
    .to(""salesforce:createSObject""); 
----

=== Using Salesforce Limits API

With `salesforce:limits` operation you can fetch of API limits from Salesforce and then act upon that data received.
The result of `salesforce:limits` operation is mapped to `org.apache.camel.component.salesforce.api.dto.Limits`
class and can be used in a custom processors or expressions.

For instance, consider that you need to limit the API usage of Salesforce so that 10% of daily API requests is left for
other routes. The body of output message contains an instance of
`org.apache.camel.component.salesforce.api.dto.Limits` object that can be used in conjunction with
Content Based Router and Content Based Router and 
xref:spel-language.adoc[Spring Expression Language (SpEL)] to choose when to perform queries.

Notice how multiplying `1.0` with the integer value held in `body.dailyApiRequests.remaining` makes the expression
evaluate as with floating point arithmetic, without it - it would end up making integral division which would result
with either `0` (some API limits consumed) or `1` (no API limits consumed).

[source,java]
----
from(""direct:querySalesforce"")
    .to(""salesforce:limits"")
    .choice()
    .when(spel(""#{1.0 * body.dailyApiRequests.remaining / body.dailyApiRequests.max < 0.1}""))
        .to(""salesforce:query?..."")
    .otherwise()
        .setBody(constant(""Used up Salesforce API limits, leaving 10% for critical routes""))
    .endChoice()
----

=== Working with approvals

All the properties are named exactly the same as in the Salesforce REST API prefixed with `approval.`. You can set
approval properties by setting `approval.PropertyName` of the Endpoint these will be used as template -- meaning
that any property not present in either body or header will be taken from the Endpoint configuration. Or you can set
the approval template on the Endpoint by assigning `approval` property to a reference onto a bean in the Registry.

You can also provide header values using the same `approval.PropertyName` in the incoming message headers.

And finally body can contain one `AprovalRequest` or an `Iterable` of `ApprovalRequest` objects to process as
a batch.

The important thing to remember is the priority of the values specified in these three mechanisms:

. value in body takes precedence before any other
. value in message header takes precedence before template value
. value in template is set if no other value in header or body was given

For example to send one record for approval using values in headers use:

Given a route:

[source,java]
----
from(""direct:example1"")//
        .setHeader(""approval.ContextId"", simple(""${body['contextId']}""))
        .setHeader(""approval.NextApproverIds"", simple(""${body['nextApproverIds']}""))
        .to(""salesforce:approval?""//
            + ""approval.actionType=Submit""//
            + ""&approval.comments=this is a test""//
            + ""&approval.processDefinitionNameOrId=Test_Account_Process""//
            + ""&approval.skipEntryCriteria=true"");
----

You could send a record for approval using:

[source,java]
----
final Map<String, String> body = new HashMap<>();
body.put(""contextId"", accountIds.iterator().next());
body.put(""nextApproverIds"", userId);

final ApprovalResult result = template.requestBody(""direct:example1"", body, ApprovalResult.class);
----

=== Using Salesforce Recent Items API

To fetch the recent items use `salesforce:recent` operation. This operation returns an `java.util.List` of
`org.apache.camel.component.salesforce.api.dto.RecentItem` objects (`List<RecentItem>`) that in turn contain
the `Id`, `Name` and `Attributes` (with `type` and `url` properties). You can limit the number of returned items
by specifying `limit` parameter set to maximum number of records to return. For example:

[source,java]
----
from(""direct:fetchRecentItems"")
    to(""salesforce:recent"")
        .split().body()
            .log(""${body.name} at ${body.attributes.url}"");
----

=== Using Salesforce Composite API to submit SObject tree

To create up to 200 records including parent-child relationships use `salesforce:composite-tree` operation. This
requires an instance of `org.apache.camel.component.salesforce.api.dto.composite.SObjectTree` in the input 
message and returns the same tree of objects in the output message. The 
`org.apache.camel.component.salesforce.api.dto.AbstractSObjectBase` instances within the tree get updated with
the identifier values (`Id` property) or their corresponding
`org.apache.camel.component.salesforce.api.dto.composite.SObjectNode` is populated with `errors` on failure.

Note that for some records operation can succeed and for some it can fail -- so you need to manually check for errors.

Easiest way to use this functionality is to use the DTOs generated by the `camel-salesforce-maven-plugin`, but you
also have the option of customizing the references that identify the each object in the tree, for instance primary keys
from your database.

Lets look at an example:

[source,java]
----
Account account = ...
Contact president = ...
Contact marketing = ...

Account anotherAccount = ...
Contact sales = ...
Asset someAsset = ...

// build the tree
SObjectTree request = new SObjectTree();
request.addObject(account).addChildren(president, marketing);
request.addObject(anotherAccount).addChild(sales).addChild(someAsset);

final SObjectTree response = template.requestBody(""salesforce:composite-tree"", tree, SObjectTree.class);
final Map<Boolean, List<SObjectNode>> result = response.allNodes()
                                                   .collect(Collectors.groupingBy(SObjectNode::hasErrors));

final List<SObjectNode> withErrors = result.get(true);
final List<SObjectNode> succeeded = result.get(false);

final String firstId = succeeded.get(0).getId();
----

=== Using Salesforce Composite API to submit multiple requests in a batch
The Composite API batch operation (`composite-batch`) allows you to accumulate multiple requests in a batch and then
submit them in one go, saving the round trip cost of multiple individual requests. Each response is then received in a
list of responses with the order preserved, so that the n-th requests response is in the n-th place of the response.

NOTE: The results can vary from API to API so the result of the request is given as a `java.lang.Object`. In most cases
the result will be a `java.util.Map` with string keys and values or other `java.util.Map` as value. Requests made in
JSON format hold some type information (i.e. it is known what values are strings and what values are numbers), so in
general those will be more type friendly. Note that the responses will vary between XML and JSON, this is due to the
responses from Salesforce API being different. So be careful if you switch between formats without changing the response
handling code.

Lets look at an example:

[source,java]
----
final String acountId = ...
final SObjectBatch batch = new SObjectBatch(""38.0"");

final Account updates = new Account();
updates.setName(""NewName"");
batch.addUpdate(""Account"", accountId, updates);

final Account newAccount = new Account();
newAccount.setName(""Account created from Composite batch API"");
batch.addCreate(newAccount);

batch.addGet(""Account"", accountId, ""Name"", ""BillingPostalCode"");

batch.addDelete(""Account"", accountId);

final SObjectBatchResponse response = template.requestBody(""salesforce:composite-batch?format=JSON"", batch, SObjectBatchResponse.class);

boolean hasErrors = response.hasErrors(); // if any of the requests has resulted in either 4xx or 5xx HTTP status
final List<SObjectBatchResult> results = response.getResults(); // results of three operations sent in batch

final SObjectBatchResult updateResult = results.get(0); // update result
final int updateStatus = updateResult.getStatusCode(); // probably 204
final Object updateResultData = updateResult.getResult(); // probably null

final SObjectBatchResult createResult = results.get(1); // create result
@SuppressWarnings(""unchecked"")
final Map<String, Object> createData = (Map<String, Object>) createResult.getResult();
final String newAccountId = createData.get(""id""); // id of the new account, this is for JSON, for XML it would be createData.get(""Result"").get(""id"")

final SObjectBatchResult retrieveResult = results.get(2); // retrieve result
@SuppressWarnings(""unchecked"")
final Map<String, Object> retrieveData = (Map<String, Object>) retrieveResult.getResult();
final String accountName = retrieveData.get(""Name""); // Name of the retrieved account, this is for JSON, for XML it would be createData.get(""Account"").get(""Name"")
final String accountBillingPostalCode = retrieveData.get(""BillingPostalCode""); // Name of the retrieved account, this is for JSON, for XML it would be createData.get(""Account"").get(""BillingPostalCode"")

final SObjectBatchResult deleteResult = results.get(3); // delete result
final int updateStatus = deleteResult.getStatusCode(); // probably 204
final Object updateResultData = deleteResult.getResult(); // probably null
----

=== Using Salesforce Composite API to submit multiple chained requests
The `composite` operation allows submitting up to 25 requests that can be chained together, for instance identifier
generated in previous request can be used in subsequent request. Individual requests and responses are linked with the
provided _reference_.

NOTE: Composite API supports only JSON payloads.

NOTE: As with the batch API the results can vary from API to API so the result of the request is given as a
`java.lang.Object`. In most cases the result will be a `java.util.Map` with string keys and values or other
`java.util.Map` as value. Requests made in JSON format hold some type information (i.e. it is known what values are
strings and what values are numbers), so in general those will be more type friendly.

Lets look at an example:

[source,java]
----
SObjectComposite composite = new SObjectComposite(""38.0"", true);

// first insert operation via an external id
final Account updateAccount = new TestAccount();
updateAccount.setName(""Salesforce"");
updateAccount.setBillingStreet(""Landmark @ 1 Market Street"");
updateAccount.setBillingCity(""San Francisco"");
updateAccount.setBillingState(""California"");
updateAccount.setIndustry(Account_IndustryEnum.TECHNOLOGY);
composite.addUpdate(""Account"", ""001xx000003DIpcAAG"", updateAccount, ""UpdatedAccount"");

final Contact newContact = new TestContact();
newContact.setLastName(""John Doe"");
newContact.setPhone(""1234567890"");
composite.addCreate(newContact, ""NewContact"");

final AccountContactJunction__c junction = new AccountContactJunction__c();
junction.setAccount__c(""001xx000003DIpcAAG"");
junction.setContactId__c(""@{NewContact.id}"");
composite.addCreate(junction, ""JunctionRecord"");

final SObjectCompositeResponse response = template.requestBody(""salesforce:composite?format=JSON"", composite, SObjectCompositeResponse.class);
final List<SObjectCompositeResult> results = response.getCompositeResponse();

final SObjectCompositeResult accountUpdateResult = results.stream().filter(r -> ""UpdatedAccount"".equals(r.getReferenceId())).findFirst().get()
final int statusCode = accountUpdateResult.getHttpStatusCode(); // should be 200
final Map<String, ?> accountUpdateBody = accountUpdateResult.getBody();

final SObjectCompositeResult contactCreationResult = results.stream().filter(r -> ""JunctionRecord"".equals(r.getReferenceId())).findFirst().get()
----

=== Generating SOQL query strings

`org.apache.camel.component.salesforce.api.utils.QueryHelper` contains helper
methods to generate SOQL queries. For instance to fetch all custom fields from
_Account_ SObject you can simply generate the SOQL SELECT by invoking:

[source,java]
----
String allCustomFieldsQuery = QueryHelper.queryToFetchFilteredFieldsOf(new Account(), SObjectField::isCustom);
----

=== Camel Salesforce Maven Plugin

This Maven plugin generates DTOs for the Camel. 

For obvious security reasons it is recommended that the clientId,
clientSecret, userName and password fields be not set in the pom.xml.  
The plugin should be configured for the rest of the properties, and can
be executed using the following command:

[source,java]
----
mvn camel-salesforce:generate -DcamelSalesforce.clientId=<clientid> -DcamelSalesforce.clientSecret=<clientsecret> \\
    -DcamelSalesforce.userName=<username> -DcamelSalesforce.password=<password>
----

The generated DTOs use Jackson and XStream annotations. All Salesforce
field types are supported. Date and time fields are mapped to
`java.time.ZonedDateTime` by default, and picklist fields are mapped to
generated Java Enumerations.

Please refer to
https://github.com/apache/camel/tree/master/components/camel-salesforce/camel-salesforce-maven-plugin[README.md]
for details on how to generate the DTO.

=== Options







// component options: START
The Salesforce component supports 30 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *authenticationType* (security) | Explicit authentication method to be used, one of USERNAME_PASSWORD, REFRESH_TOKEN or JWT. Salesforce component can auto-determine the authentication method to use from the properties set, set this property to eliminate any ambiguity. |  | AuthenticationType
| *loginConfig* (security) | All authentication configuration in one nested bean, all properties set there can be set directly on the component as well |  | SalesforceLoginConfig
| *instanceUrl* (security) | URL of the Salesforce instance used after authentication, by default received from Salesforce on successful authentication |  | String
| *loginUrl* (security) | *Required* URL of the Salesforce instance used for authentication, by default set to \\https://login.salesforce.com | https://login.salesforce.com | String
| *clientId* (security) | *Required* OAuth Consumer Key of the connected app configured in the Salesforce instance setup. Typically a connected app needs to be configured but one can be provided by installing a package. |  | String
| *clientSecret* (security) | OAuth Consumer Secret of the connected app configured in the Salesforce instance setup. |  | String
| *keystore* (security) | KeyStore parameters to use in OAuth JWT flow. The KeyStore should contain only one entry with private key and certificate. Salesforce does not verify the certificate chain, so this can easily be a selfsigned certificate. Make sure that you upload the certificate to the corresponding connected app. |  | KeyStoreParameters
| *refreshToken* (security) | Refresh token already obtained in the refresh token OAuth flow. One needs to setup a web application and configure a callback URL to receive the refresh token, or configure using the builtin callback at \\https://login.salesforce.com/services/oauth2/success or \\https://test.salesforce.com/services/oauth2/success and then retrive the refresh_token from the URL at the end of the flow. Note that in development organizations Salesforce allows hosting the callback web application at localhost. |  | String
| *userName* (security) | Username used in OAuth flow to gain access to access token. It's easy to get started with password OAuth flow, but in general one should avoid it as it is deemed less secure than other flows. |  | String
| *password* (security) | Password used in OAuth flow to gain access to access token. It's easy to get started with password OAuth flow, but in general one should avoid it as it is deemed less secure than other flows. Make sure that you append security token to the end of the password if using one. |  | String
| *lazyLogin* (security) | If set to true prevents the component from authenticating to Salesforce with the start of the component. You would generally set this to the (default) false and authenticate early and be immediately aware of any authentication issues. | false | boolean
| *config* (common) | Global endpoint configuration - use to set values that are common to all endpoints |  | SalesforceEndpoint Config
| *httpClientProperties* (common) | Used to set any properties that can be configured on the underlying HTTP client. Have a look at properties of SalesforceHttpClient and the Jetty HttpClient for all available options. |  | Map
| *longPollingTransport Properties* (common) | Used to set any properties that can be configured on the LongPollingTransport used by the BayeuxClient (CometD) used by the streaming api |  | Map
| *sslContextParameters* (security) | SSL parameters to use, see SSLContextParameters class for all available options. |  | SSLContextParameters
| *useGlobalSslContext Parameters* (security) | Enable usage of global SSL context parameters | false | boolean
| *httpProxyHost* (proxy) | Hostname of the HTTP proxy server to use. |  | String
| *httpProxyPort* (proxy) | Port number of the HTTP proxy server to use. |  | Integer
| *httpProxyUsername* (security) | Username to use to authenticate against the HTTP proxy server. |  | String
| *httpProxyPassword* (security) | Password to use to authenticate against the HTTP proxy server. |  | String
| *isHttpProxySocks4* (proxy) | If set to true the configures the HTTP proxy to use as a SOCKS4 proxy. | false | boolean
| *isHttpProxySecure* (security) | If set to false disables the use of TLS when accessing the HTTP proxy. | true | boolean
| *httpProxyIncluded Addresses* (proxy) | A list of addresses for which HTTP proxy server should be used. |  | Set
| *httpProxyExcluded Addresses* (proxy) | A list of addresses for which HTTP proxy server should not be used. |  | Set
| *httpProxyAuthUri* (security) | Used in authentication against the HTTP proxy server, needs to match the URI of the proxy server in order for the httpProxyUsername and httpProxyPassword to be used for authentication. |  | String
| *httpProxyRealm* (security) | Realm of the proxy server, used in preemptive Basic/Digest authentication methods against the HTTP proxy server. |  | String
| *httpProxyUseDigest Auth* (security) | If set to true Digest authentication will be used when authenticating to the HTTP proxy,otherwise Basic authorization method will be used | false | boolean
| *packages* (common) | In what packages are the generated DTO classes. Typically the classes would be generated using camel-salesforce-maven-plugin. Set it if using the generated DTOs to gain the benefit of using short SObject names in parameters/header values. |  | String[]
| *resolveProperty Placeholders* (advanced) | Whether the component should resolve property placeholders on itself when starting. Only properties which are of String type can use property placeholders. | true | boolean
| *basicPropertyBinding* (advanced) | Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
|===
// component options: END










// endpoint options: START
The Salesforce endpoint is configured using URI syntax:

----
salesforce:operationName:topicName
----

with the following path and query parameters:

==== Path Parameters (2 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *operationName* | The operation to use |  | OperationName
| *topicName* | The name of the topic/channel to use |  | String
|===


==== Query Parameters (46 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *apexMethod* (common) | APEX method name |  | String
| *apexQueryParams* (common) | Query params for APEX method |  | Map
| *apexUrl* (common) | APEX method URL |  | String
| *apiVersion* (common) | Salesforce API version, defaults to SalesforceEndpointConfig.DEFAULT_VERSION |  | String
| *backoffIncrement* (common) | Backoff interval increment for Streaming connection restart attempts for failures beyond CometD auto-reconnect. |  | long
| *batchId* (common) | Bulk API Batch ID |  | String
| *contentType* (common) | Bulk API content type, one of XML, CSV, ZIP_XML, ZIP_CSV |  | ContentType
| *defaultReplayId* (common) | Default replayId setting if no value is found in initialReplayIdMap |  | Long
| *format* (common) | Payload format to use for Salesforce API calls, either JSON or XML, defaults to JSON |  | PayloadFormat
| *httpClient* (common) | Custom Jetty Http Client to use to connect to Salesforce. |  | SalesforceHttpClient
| *includeDetails* (common) | Include details in Salesforce1 Analytics report, defaults to false. |  | Boolean
| *initialReplayIdMap* (common) | Replay IDs to start from per channel name. |  | Map
| *instanceId* (common) | Salesforce1 Analytics report execution instance ID |  | String
| *jobId* (common) | Bulk API Job ID |  | String
| *limit* (common) | Limit on number of returned records. Applicable to some of the API, check the Salesforce documentation. |  | Integer
| *maxBackoff* (common) | Maximum backoff interval for Streaming connection restart attempts for failures beyond CometD auto-reconnect. |  | long
| *notFoundBehaviour* (common) | Sets the behaviour of 404 not found status received from Salesforce API. Should the body be set to NULL NotFoundBehaviour#NULL or should a exception be signaled on the exchange NotFoundBehaviour#EXCEPTION - the default. |  | NotFoundBehaviour
| *notifyForFields* (common) | Notify for fields, options are ALL, REFERENCED, SELECT, WHERE |  | NotifyForFieldsEnum
| *notifyForOperationCreate* (common) | Notify for create operation, defaults to false (API version = 29.0) |  | Boolean
| *notifyForOperationDelete* (common) | Notify for delete operation, defaults to false (API version = 29.0) |  | Boolean
| *notifyForOperations* (common) | Notify for operations, options are ALL, CREATE, EXTENDED, UPDATE (API version 29.0) |  | NotifyForOperations Enum
| *notifyForOperationUndelete* (common) | Notify for un-delete operation, defaults to false (API version = 29.0) |  | Boolean
| *notifyForOperationUpdate* (common) | Notify for update operation, defaults to false (API version = 29.0) |  | Boolean
| *objectMapper* (common) | Custom Jackson ObjectMapper to use when serializing/deserializing Salesforce objects. |  | ObjectMapper
| *rawPayload* (common) | Use raw payload String for request and response (either JSON or XML depending on format), instead of DTOs, false by default | false | boolean
| *reportId* (common) | Salesforce1 Analytics report Id |  | String
| *reportMetadata* (common) | Salesforce1 Analytics report metadata for filtering |  | ReportMetadata
| *resultId* (common) | Bulk API Result ID |  | String
| *serializeNulls* (common) | Should the NULL values of given DTO be serialized with empty (NULL) values. This affects only JSON data format. | false | boolean
| *sObjectBlobFieldName* (common) | SObject blob field name |  | String
| *sObjectClass* (common) | Fully qualified SObject class name, usually generated using camel-salesforce-maven-plugin |  | String
| *sObjectFields* (common) | SObject fields to retrieve |  | String
| *sObjectId* (common) | SObject ID if required by API |  | String
| *sObjectIdName* (common) | SObject external ID field name |  | String
| *sObjectIdValue* (common) | SObject external ID field value |  | String
| *sObjectName* (common) | SObject name if required or supported by API |  | String
| *sObjectQuery* (common) | Salesforce SOQL query string |  | String
| *sObjectSearch* (common) | Salesforce SOSL search string |  | String
| *updateTopic* (common) | Whether to update an existing Push Topic when using the Streaming API, defaults to false | false | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *replayId* (consumer) | The replayId value to use when subscribing |  | Long
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. |  | ExchangePattern
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *basicPropertyBinding* (advanced) | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
|===
// endpoint options: END
// spring-boot-auto-configure options: START
=== Spring Boot Auto-Configuration

When using Spring Boot make sure to use the following Maven dependency to have support for auto configuration:

[source,xml]
----
<dependency>
  <groupId>org.apache.camel</groupId>
  <artifactId>camel-salesforce-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
----


The component supports 86 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *camel.component.salesforce.authentication-type* | Explicit authentication method to be used, one of USERNAME_PASSWORD, REFRESH_TOKEN or JWT. Salesforce component can auto-determine the authentication method to use from the properties set, set this property to eliminate any ambiguity. |  | AuthenticationType
| *camel.component.salesforce.basic-property-binding* | Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | Boolean
| *camel.component.salesforce.client-id* | OAuth Consumer Key of the connected app configured in the Salesforce instance setup. Typically a connected app needs to be configured but one can be provided by installing a package. |  | String
| *camel.component.salesforce.client-secret* | OAuth Consumer Secret of the connected app configured in the Salesforce instance setup. |  | String
| *camel.component.salesforce.config.apex-method* | APEX method name |  | String
| *camel.component.salesforce.config.apex-query-params* | Query params for APEX method |  | Map
| *camel.component.salesforce.config.apex-url* | APEX method URL |  | String
| *camel.component.salesforce.config.api-version* | Salesforce API version, defaults to SalesforceEndpointConfig.DEFAULT_VERSION |  | String
| *camel.component.salesforce.config.approval* | The approval request for Approval API. |  | ApprovalRequest
| *camel.component.salesforce.config.approval-action-type* | Represents the kind of action to take: Submit, Approve, or Reject. |  | ApprovalRequest$Action
| *camel.component.salesforce.config.approval-comments* | The comment to add to the history step associated with this request. |  | String
| *camel.component.salesforce.config.approval-context-actor-id* | The ID of the submitter who’s requesting the approval record. |  | String
| *camel.component.salesforce.config.approval-context-id* | The ID of the item that is being acted upon. |  | String
| *camel.component.salesforce.config.approval-next-approver-ids* | If the process requires specification of the next approval, the ID of the user to be assigned the next request. |  | List
| *camel.component.salesforce.config.approval-process-definition-name-or-id* | The developer name or ID of the process definition. |  | String
| *camel.component.salesforce.config.approval-skip-entry-criteria* | Determines whether to evaluate the entry criteria for the process (true) or not (false) if the process definition name or ID isn’t null. If the process definition name or ID isn’t specified, this argument is ignored, and standard evaluation is followed based on process order. By default, the entry criteria isn’t skipped if it’s not set by this request. |  | Boolean
| *camel.component.salesforce.config.backoff-increment* | Backoff interval increment for Streaming connection restart attempts for failures beyond CometD auto-reconnect. |  | Long
| *camel.component.salesforce.config.batch-id* | Bulk API Batch ID |  | String
| *camel.component.salesforce.config.content-type* | Bulk API content type, one of XML, CSV, ZIP_XML, ZIP_CSV |  | ContentType
| *camel.component.salesforce.config.default-replay-id* | Default replayId setting if no value is found in {@link #initialReplayIdMap} |  | Long
| *camel.component.salesforce.config.format* | Payload format to use for Salesforce API calls, either JSON or XML, defaults to JSON |  | PayloadFormat
| *camel.component.salesforce.config.http-client* | Custom Jetty Http Client to use to connect to Salesforce. |  | SalesforceHttpClient
| *camel.component.salesforce.config.include-details* | Include details in Salesforce1 Analytics report, defaults to false. |  | Boolean
| *camel.component.salesforce.config.initial-replay-id-map* | Replay IDs to start from per channel name. |  | Map
| *camel.component.salesforce.config.instance-id* | Salesforce1 Analytics report execution instance ID |  | String
| *camel.component.salesforce.config.job-id* | Bulk API Job ID |  | String
| *camel.component.salesforce.config.limit* | Limit on number of returned records. Applicable to some of the API, check the Salesforce documentation. |  | Integer
| *camel.component.salesforce.config.max-backoff* | Maximum backoff interval for Streaming connection restart attempts for failures beyond CometD auto-reconnect. |  | Long
| *camel.component.salesforce.config.not-found-behaviour* | Sets the behaviour of 404 not found status received from Salesforce API. Should the body be set to NULL {@link NotFoundBehaviour#NULL} or should a exception be signaled on the exchange {@link NotFoundBehaviour#EXCEPTION} - the default. |  | NotFoundBehaviour
| *camel.component.salesforce.config.notify-for-fields* | Notify for fields, options are ALL, REFERENCED, SELECT, WHERE |  | NotifyForFieldsEnum
| *camel.component.salesforce.config.notify-for-operation-create* | Notify for create operation, defaults to false (API version >= 29.0) |  | Boolean
| *camel.component.salesforce.config.notify-for-operation-delete* | Notify for delete operation, defaults to false (API version >= 29.0) |  | Boolean
| *camel.component.salesforce.config.notify-for-operation-undelete* | Notify for un-delete operation, defaults to false (API version >= 29.0) |  | Boolean
| *camel.component.salesforce.config.notify-for-operation-update* | Notify for update operation, defaults to false (API version >= 29.0) |  | Boolean
| *camel.component.salesforce.config.notify-for-operations* | Notify for operations, options are ALL, CREATE, EXTENDED, UPDATE (API version < 29.0) |  | NotifyForOperations Enum
| *camel.component.salesforce.config.object-mapper* | Custom Jackson ObjectMapper to use when serializing/deserializing Salesforce objects. |  | ObjectMapper
| *camel.component.salesforce.config.raw-payload* | Use raw payload {@link String} for request and response (either JSON or XML depending on {@code format}), instead of DTOs, false by default | false | Boolean
| *camel.component.salesforce.config.report-id* | Salesforce1 Analytics report Id |  | String
| *camel.component.salesforce.config.report-metadata* | Salesforce1 Analytics report metadata for filtering |  | ReportMetadata
| *camel.component.salesforce.config.result-id* | Bulk API Result ID |  | String
| *camel.component.salesforce.config.s-object-blob-field-name* | SObject blob field name |  | String
| *camel.component.salesforce.config.s-object-class* | Fully qualified SObject class name, usually generated using camel-salesforce-maven-plugin |  | String
| *camel.component.salesforce.config.s-object-fields* | SObject fields to retrieve |  | String
| *camel.component.salesforce.config.s-object-id* | SObject ID if required by API |  | String
| *camel.component.salesforce.config.s-object-id-name* | SObject external ID field name |  | String
| *camel.component.salesforce.config.s-object-id-value* | SObject external ID field value |  | String
| *camel.component.salesforce.config.s-object-name* | SObject name if required or supported by API |  | String
| *camel.component.salesforce.config.s-object-query* | Salesforce SOQL query string |  | String
| *camel.component.salesforce.config.s-object-search* | Salesforce SOSL search string |  | String
| *camel.component.salesforce.config.serialize-nulls* | Should the NULL values of given DTO be serialized with empty (NULL) values. This affects only JSON data format. | false | Boolean
| *camel.component.salesforce.config.update-topic* | Whether to update an existing Push Topic when using the Streaming API, defaults to false | false | Boolean
| *camel.component.salesforce.enabled* | Enable salesforce component | true | Boolean
| *camel.component.salesforce.http-client-properties* | Used to set any properties that can be configured on the underlying HTTP client. Have a look at properties of SalesforceHttpClient and the Jetty HttpClient for all available options. The option is a java.util.Map<java.lang.String,java.lang.Object> type. |  | String
| *camel.component.salesforce.http-proxy-auth-uri* | Used in authentication against the HTTP proxy server, needs to match the URI of the proxy server in order for the httpProxyUsername and httpProxyPassword to be used for authentication. |  | String
| *camel.component.salesforce.http-proxy-excluded-addresses* | A list of addresses for which HTTP proxy server should not be used. The option is a java.util.Set<java.lang.String> type. |  | String
| *camel.component.salesforce.http-proxy-host* | Hostname of the HTTP proxy server to use. |  | String
| *camel.component.salesforce.http-proxy-included-addresses* | A list of addresses for which HTTP proxy server should be used. The option is a java.util.Set<java.lang.String> type. |  | String
| *camel.component.salesforce.http-proxy-password* | Password to use to authenticate against the HTTP proxy server. |  | String
| *camel.component.salesforce.http-proxy-port* | Port number of the HTTP proxy server to use. |  | Integer
| *camel.component.salesforce.http-proxy-realm* | Realm of the proxy server, used in preemptive Basic/Digest authentication methods against the HTTP proxy server. |  | String
| *camel.component.salesforce.http-proxy-use-digest-auth* | If set to true Digest authentication will be used when authenticating to the HTTP proxy,otherwise Basic authorization method will be used | false | Boolean
| *camel.component.salesforce.http-proxy-username* | Username to use to authenticate against the HTTP proxy server. |  | String
| *camel.component.salesforce.instance-url* | URL of the Salesforce instance used after authentication, by default received from Salesforce on successful authentication |  | String
| *camel.component.salesforce.is-http-proxy-secure* | If set to false disables the use of TLS when accessing the HTTP proxy. | true | Boolean
| *camel.component.salesforce.is-http-proxy-socks4* | If set to true the configures the HTTP proxy to use as a SOCKS4 proxy. | false | Boolean
| *camel.component.salesforce.keystore* | KeyStore parameters to use in OAuth JWT flow. The KeyStore should contain only one entry with private key and certificate. Salesforce does not verify the certificate chain, so this can easily be a selfsigned certificate. Make sure that you upload the certificate to the corresponding connected app. The option is a org.apache.camel.support.jsse.KeyStoreParameters type. |  | String
| *camel.component.salesforce.lazy-login* | If set to true prevents the component from authenticating to Salesforce with the start of the component. You would generally set this to the (default) false and authenticate early and be immediately aware of any authentication issues. | false | Boolean
| *camel.component.salesforce.login-config.client-id* | Salesforce connected application Consumer Key |  | String
| *camel.component.salesforce.login-config.client-secret* | Salesforce connected application Consumer Secret |  | String
| *camel.component.salesforce.login-config.instance-url* | Configuration object for Salesforce login properties |  | String
| *camel.component.salesforce.login-config.keystore* | Keystore parameters for keystore containing certificate and private key needed for OAuth 2.0 JWT Bearer Token Flow. |  | KeyStoreParameters
| *camel.component.salesforce.login-config.lazy-login* | Flag to enable/disable lazy OAuth, default is false. When enabled, OAuth token retrieval or generation is not done until the first API call | false | Boolean
| *camel.component.salesforce.login-config.login-url* | Salesforce login URL, defaults to \\https://login.salesforce.com | https://login.salesforce.com | String
| *camel.component.salesforce.login-config.password* | Salesforce account password |  | String
| *camel.component.salesforce.login-config.refresh-token* | Salesforce connected application Consumer token |  | String
| *camel.component.salesforce.login-config.type* | Salesforce connected application Consumer token |  | AuthenticationType
| *camel.component.salesforce.login-config.user-name* | Salesforce account user name |  | String
| *camel.component.salesforce.login-url* | URL of the Salesforce instance used for authentication, by default set to \\https://login.salesforce.com | https://login.salesforce.com | String
| *camel.component.salesforce.long-polling-transport-properties* | Used to set any properties that can be configured on the LongPollingTransport used by the BayeuxClient (CometD) used by the streaming api. The option is a java.util.Map<java.lang.String,java.lang.Object> type. |  | String
| *camel.component.salesforce.packages* | In what packages are the generated DTO classes. Typically the classes would be generated using camel-salesforce-maven-plugin. Set it if using the generated DTOs to gain the benefit of using short SObject names in parameters/header values. |  | String[]
| *camel.component.salesforce.password* | Password used in OAuth flow to gain access to access token. It's easy to get started with password OAuth flow, but in general one should avoid it as it is deemed less secure than other flows. Make sure that you append security token to the end of the password if using one. |  | String
| *camel.component.salesforce.refresh-token* | Refresh token already obtained in the refresh token OAuth flow. One needs to setup a web application and configure a callback URL to receive the refresh token, or configure using the builtin callback at \\https://login.salesforce.com/services/oauth2/success or \\https://test.salesforce.com/services/oauth2/success and then retrive the refresh_token from the URL at the end of the flow. Note that in development organizations Salesforce allows hosting the callback web application at localhost. |  | String
| *camel.component.salesforce.resolve-property-placeholders* | Whether the component should resolve property placeholders on itself when starting. Only properties which are of String type can use property placeholders. | true | Boolean
| *camel.component.salesforce.ssl-context-parameters* | SSL parameters to use, see SSLContextParameters class for all available options. The option is a org.apache.camel.support.jsse.SSLContextParameters type. |  | String
| *camel.component.salesforce.use-global-ssl-context-parameters* | Enable usage of global SSL context parameters | false | Boolean
| *camel.component.salesforce.user-name* | Username used in OAuth flow to gain access to access token. It's easy to get started with password OAuth flow, but in general one should avoid it as it is deemed less secure than other flows. |  | String
|===
// spring-boot-auto-configure options: END
",12150,False,2171.0074530751053,median
"// 
//     Licensed to the Apache Software Foundation (ASF) under one
//     or more contributor license agreements.  See the NOTICE file
//     distributed with this work for additional information
//     regarding copyright ownership.  The ASF licenses this file
//     to you 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.
//

= NetBeans 电子商务教程 - 准备页面视图和控制器 Servlet
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: NetBeans 电子商务教程 - 准备页面视图和控制器 Servlet - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, NetBeans 电子商务教程 - 准备页面视图和控制器 Servlet



1. link:intro.html[+简介+]
2. link:design.html[+设计应用程序+]
3. link:setup-dev-environ.html[+设置开发环境+]
4. link:data-model.html[+设计数据模型+]
5. *准备页面视图和控制器 Servlet*
6. link:connect-db.html[+将应用程序与数据库连接+]
7. link:entity-session.html[+添加实体类和会话 Bean+]
8. link:manage-sessions.html[+管理会话+]
9. link:transaction.html[+集成事务性业务逻辑+]
10. link:language.html[+添加语言支持+]
11. link:security.html[+保护应用程序+]
12. link:test-profile.html[+测试和性能分析+]
13. link:conclusion.html[+小结+]

image::../../../../images_www/articles/68/netbeans-stamp-68-69.png[title=""此页上的内容适用于 NetBeans IDE 版本 6.8 和 6.9""]

本单元演示了如何在 IDE 中创建项目文件，并介绍了一些适用于 HTML 和 CSS 开发的功能。创建必需的项目文件之后，您便可以开始组织应用程序的前端。也就是说，您将在项目结构中的适当位置放置 JSP 文件，创建将应用于所有视图的页眉和页脚，并设置控制器 Servlet 以处理传入请求。

在此单元中，您还将为应用程序创建 Web 部署描述符（`web.xml` 文件）。可以使用该部署描述符指定在部署期间由服务器读取的配置信息。尽管 link:http://jcp.org/en/jsr/detail?id=315[+Servlet 3.0 规范+]（包含在 Java EE 6 中）允许您使用类标注替换 XML，但是您可能仍需要使用部署描述符来配置应用程序的某些元素。具体说来，您将在此单元中为页眉和页脚添加指令，并指定要将它们应用于哪些文件。

本单元的一个目标是创建与应用程序设计中指定的视图相对应的 JSP 页。查阅link:design.html#mockups[+页面模型+]和link:design.html#business[+过程流图+]，您可以通过为所有可视和功能组件创建_占位符_，开始根据模型实现页面布局。此单元为实现欢迎页的布局提供了指导。您可以应用下述步骤自行创建其他页，也可以link:https://netbeans.org/projects/samples/downloads/download/Samples%252FJavaEE%252Fecommerce%252FAffableBean_snapshot1.zip[+下载项目快照 1+]，其中提供了完成的所有页的布局。

您可以查看此教程中构建的应用程序的实时演示：link:http://dot.netbeans.org:8080/AffableBean/[+NetBeans 电子商务教程演示应用程序+]。



|===
|软件或资源 |要求的版本 

|link:https://netbeans.org/downloads/index.html[+NetBeans IDE+] |Java 包，6.8 或 6.9 

|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+Java 开发工具包 (JDK)+] |版本 6 

|<<glassFish,GlassFish Server>> |v3 或 Open Source Edition 3.0.1 
|===

*注：*

* NetBeans IDE 需要 Java 开发工具包 (JDK) 才能正常运行。如果不具备上面列出的任何资源，则应首先下载并安装 JDK。
* NetBeans IDE Java 包包含在本教程中构建的应用程序所需的 Java Web 和 Java EE 技术。
* NetBeans IDE Java 包还包含本教程所需的 GlassFish Server。可以link:https://glassfish.dev.java.net/public/downloadsindex.html[+单独下载 GlassFish Server+]，但是 NetBeans 下载中附带的版本具有在 IDE 中自动注册的额外好处。



[[createProjectFiles]]
== 创建项目文件

要为项目创建新文件，请访问 IDE 的文件向导。可以单击 ""New File""（新建文件）(image:images/new-file-btn.png[]) 按钮，然后按 Ctrl-N 组合键（在 Mac 上为 ⌘-N 组合键）；或者在 ""Projects""（项目）窗口中，右键单击包含新文件的文件夹节点，然后选择 ""New""（新建）> [file-type]""（[文件类型]）。在下面的小节中，将为项目创建 JSP 页和样式表。

* <<jsp,创建 JSP 页>>
* <<css,创建样式表>>


[[jsp]]
=== 创建 JSP 页

通过创建与link:design.html#business[+过程流图+]中显示的视图相对应的 JSP 页，开始处理项目。

IDE 生成的 `index.jsp` 页将成为项目的欢迎页。为其余四个视图创建 JSP 页，当前将这些页面放在 `index.jsp` 所在的项目 Web 根目录中。

1. 单击 ""New File""（新建文件）(image:images/new-file-btn.png[]) 按钮以打开文件向导。
2. 选择 ""Web"" 类别，然后选择 ""JSP"" 并单击 ""Next""（下一步）。
3. 将该文件命名为 ""`category`""。请注意，""Location""（位置）字段设置为 `Web Pages`（Web 页），表明将在项目的 Web 根目录中创建该文件。该位置对应于项目的 `web` 文件夹，您可以稍后在 IDE 的 ""Files""（文件）窗口中对此进行验证。
4. 单击 ""Finish""（完成）。IDE 生成新的 JSP 页并在编辑器中将其打开。
5. 重复上面的步骤 1 至步骤 4，以创建其余的 `cart.jsp`、`checkout.jsp` 和 `confirmation.jsp` 页。

完成后，""Projects""（项目）窗口将如下所示： 

image::images/projects-win-views.png[title=""包含在 ""]


[[css]]
=== 创建样式表

创建 CSS 文件以包含特定于应用程序的所有样式。

1. 在 ""Projects""（项目）窗口中，右键单击 ""Web Pages""（Web 页）节点，然后选择 ""New""（新建）> ""Folder""（文件夹）。
2. 在新建文件夹向导中，将文件夹命名为 ""`css`""，然后单击 ""Finish""（完成）。
3. 右键单击新的 `css` 文件夹，然后选择 ""New""（新建）> ""Cascading Style Sheet""（级联样式表）。（如果未列出 ""Cascading Style Sheet""（级联样式表）项目，请选择 ""Other""（其他）。在文件向导中，选择 ""Web"" 类别，然后选择 ""Cascading Style Sheet""（级联样式表）并选择 ""Next""（下一步）。）
4. 将样式表命名为 `affablebean`，然后单击 ""Finish""（完成）。

完成后，将看到 `affablebean.css` 文件显示在 ""Projects""（项目）窗口中。 

image::images/projects-win-css.png[]



[[implementHTML]]
== 实现 HTML 和 CSS 内容

此部分的目的是设计页面视图，以便它们开始镜像提供的link:design.html#mockups[+页面模型+]。这样，您就可以在项目开发后期使用它们作为插入动态内容的构架。为此，您将利用 IDE 的 HTML 和 CSS 编辑器，以及一些 CSS 支持窗口。

*浏览器兼容性说明：*本教程使用 Firefox 3，并且_不_保证页面视图标记与其他新型浏览器相兼容。当然，使用前端 Web 技术（HTML、CSS 和 JavaScript）时，您需要采取措施以确保 Web 页能正确呈现在站点访问者将使用的浏览器和浏览器版本中（通常是 Internet Explorer、Firefox、Safari、Chrome 和 Opera）。使用 IDE 时，您可以设置希望应用程序在其中打开的浏览器。选择 ""Tools""（工具）> ""Options""（选项）（在 Mac 上为 ""NetBeans"" > ""Preferences""（首选项）），然后在 ""Options""（选项）窗口的 ""General""（常规）标签下，从 ""Web Browser""（Web 浏览器）下拉列表中选择您希望使用的浏览器。IDE 会检测已安装到默认位置的浏览器。如果未显示计算机上安装的浏览器，可单击 ""Edit""（编辑）按钮，然后手动注册该浏览器。

准备 Web 页显示通常是一个重复过程，需要根据客户的定期反馈不断进行完善。以下步骤向您介绍 IDE 提供的一些功能，并使用link:design.html#index[+欢迎页模型+]作为示例演示如何开始着手操作。

1. 在 ""Projects""（项目）窗口中，双击 `index.jsp` 以在编辑器中将其打开。
2. 首先为页面的主区域创建 `<div>` 标记。您总共可以创建五个标记：四个用于主区域（页眉、页脚、左栏和右栏），第五个用于包含其他内容。删除 `<body>` 标记内的任何内容并替换为以下内容。（新代码以*粗体*显示。）

[source,html]
----

<body>
    *<div id=""main"">
        <div id=""header"">
            header
        </div>

        <div id=""indexLeftColumn"">
            left column
        </div>

        <div id=""indexRightColumn"">
            right column
        </div>

        <div id=""footer"">
            footer
        </div>
    </div>*
</body>
----

[start=3]
. 在页面的头中添加对样式表的引用，并更改标题文本。

[source,xml]
----

<head>
    <meta http-equiv=""Content-Type"" content=""text/html; charset=UTF-8"">
    *<link rel=""stylesheet"" type=""text/css"" href=""css/affablebean.css"">*
    <title>*The Affable Bean*</title>
</head>
----

[start=4]
. 在编辑器中打开 `affablebean.css` 样式表。首先为刚创建的 `<div>` ID 创建样式规则。
* 使用 `width` 和 `height` 属性创建每个区域所占的空间。
* 使用 `background` 属性区分显示的页面区域。
* 为了使四个区域在页面中水平居中，可以在 `body` 规则中包含 `margin: 20px auto`。（`20px` 适用于顶部和底部间距；`auto` 可在左侧和右侧创建相等的间距。）然后，在左栏和右栏中包括 `float: left`。
* 页脚需要 `clear: left`，以便在其上方的任何左侧浮动区域（即左栏和右栏）的底部边框后面显示其顶部边框。

[source,java]
----

body {
    font-family: Arial, Helvetica, sans-serif;
    width: 850px;
    text-align: center;
    margin: 20px auto;
}

#main { background: #eee }

#header {
    height: 250px;
    background: #aaa;
}

#footer {
    height: 60px;
    clear: left;
    background: #aaa;
}

#indexLeftColumn {
    height: 400px;
    width: 350px;
    float: left;
    background: #ccc;
}

#indexRightColumn {
    height: 400px;
    width: 500px;
    float: left;
    background: #eee;
}
----

[start=5]
. 在 IDE 的主工具栏中单击 ""Run Project""（运行项目）(image:images/run-project-btn.png[]) 按钮。此时，将自动保存包含更改的项目文件、编译项目中的任何 Java 代码、打包项目并将其部署到 GlassFish，并且浏览器随即打开以显示欢迎页的当前状态。 

image::images/index-page.png[title=""运行项目以查看页的当前状态""]

[start=6]
. 现在，开始分别为四个可视区域中的页面组件创建占位符。首先从页眉开始。查看link:design.html#index[+欢迎页模型+]，页眉应该包含以下组件：
* 徽标
* 徽标文本
* 购物车窗口部件
* 语言切换
对 `index.jsp` 文件进行如下更改。（新代码以*粗体*显示。）

[source,html]
----

<div id=""header"">
    *<div id=""widgetBar"">

        <div class=""headerWidget"">
            [ language toggle ]
        </div>

        <div class=""headerWidget"">
            [ shopping cart widget ]
        </div>

    </div>

    <a href=""#"">
        <img src=""#"" id=""logo"" alt=""Affable Bean logo"">
    </a>

    <img src=""#"" id=""logoText"" alt=""the affable bean"">*
</div>
----
在上面的代码中，您使用 `<div id=""widgetBar"">` 元素来包含语言切换和购物车窗口部件。 


=== NetBeans HTML 编辑器支持

使用编辑器时，您可以利用 IDE 的 HTML 支持。除了便于您区分标记、属性、属性值和文本的典型语法突出显示之外，该支持还提供了许多其他功能。

在编辑器中键入标记和属性时，您可以通过按 Ctrl-空格键调用代码完成和文档支持。IDE 会显示一个可供您选择的建议列表，以及一个定义选定项目并提供代码示例的文档窗口。

image::images/documentation-popup.png[title=""按 Ctrl-空格键可查看代码完成和文档窗口""]

IDE 会检测代码中的错误，并向您提供警告、错误消息，而且在某些情况下，还会提供建议。警告消息显示为黄色，而错误则显示为红色。将指针悬停在指定的区域上，可以查看工具提示中的消息。

image::images/html-hint.png[title=""悬停指针可查看工具提示警告""]

您还可以利用大量的快捷键。从主菜单中选择 ""Help""（帮助）> ""Keyboard Shortcuts Card""（快捷键列表）。



[start=7]
. 在样式表中，为新 ID 和类创建规则。在 `header` 规则下面添加以下规则。（新代码以*粗体*显示。）

[source,java]
----

#header {
    height: 250px;
    background: #aaa;
}

*#logo {
    height: 155px;
    width: 155px;
    float: left;
    margin-left: 30px;
    margin-top: -20px;
}

#logoText {
    float: left;
    margin: 20px 0 0 70px;
    /* font styles apply to text within alt tags */
    font-family: 'American Typewriter', Courier, monospace;
    font-size: 50px;
    color: #333;
}

#widgetBar {
    height: 50px;
    width: 850px;
    float: right;
    background: #ccc;
}

.headerWidget {
    width: 194px;
    margin: 20px 2px;
    font-size: small;
    float: right;
    line-height: 25px;
    background: #aaa;
}*
----
对于 `logo` 规则，应用 `margin-left` 和 `margin-top` 属性来定位页面上的组件。

如果上面的代码中存在您不熟悉的属性，请将光标置于给定属性上面并按 Ctrl-空格键，以便调用提供文档支持的弹出式窗口。 

image::images/css-doc-support.png[title=""在 CSS 属性上按 Ctrl-空格键可调用文档支持""] 

要查看属性影响页面的方式，您可以将其注释掉，然后在浏览器中刷新页面。要注释掉代码，请将光标置于代码行上，或者突出显示代码块，然后按 Ctrl-/ 组合键（在 Mac 上为 ⌘-/ 组合键）。


[start=8]
. 保存（Ctrl-S 组合键；在 Mac 上为 ⌘-S 组合键）`index.jsp` 和 `affablebean.css` 文件，然后切换到浏览器并刷新页面以查看其当前状态。 

*注：*系统会自动为 Java Web 项目激活 IDE 的“在保存时部署”功能。这意味着每次保存文件时，都会自动编译该文件（即，如果该文件为 Java 类或 JSP 页），并且还会重新打包项目并将其部署到服务器。因此，在进行 HTML 或 CSS 更改时，您不需要显式重新运行项目以在浏览器中查看更新后的版本。您只需保存文件，然后切换到浏览器并刷新页面。

image::images/index-page2.png[title=""在运行项目时会显示页眉的占位符""] 

按照以上步骤，您应该能够看见有一个图形出现。对于页面上的每个区域，执行下面三个步骤。
1. 在 HTML 中创建结构。
2. 创建一组用于定义外观的样式。
3. 查看页面以检查更改后的结果。
按照这三个步骤，让我们实现其余区域中的组件。

[start=9]
. 为右栏中的组件创建占位符。根据link:design.html#index[+欢迎页模型+]，右栏包含四个均匀分布的框。

为这四个框创建结构。在 `<div id=""indexRightColumn"">` 标记之间插入以下代码。（新代码以*粗体*显示。）

[source,html]
----

<div id=""indexRightColumn"">
    *<div class=""categoryBox"">
        <a href=""#"">
            <span class=""categoryLabelText"">dairy</span>
        </a>
    </div>
    <div class=""categoryBox"">
        <a href=""#"">
            <span class=""categoryLabelText"">meats</span>
        </a>
    </div>
    <div class=""categoryBox"">
        <a href=""#"">
            <span class=""categoryLabelText"">bakery</span>
        </a>
    </div>
    <div class=""categoryBox"">
        <a href=""#"">
            <span class=""categoryLabelText"">fruit &amp; veg</span>
        </a>
    </div>*
</div>
----

[start=10]
. 在 `affablebean.css` 中为新的 `categoryBox` 和 `categoryLabelText` 类添加样式规则。（新代码以*粗体*显示。）

[source,java]
----

#indexRightColumn {
    height: 400px;
    width: 500px;
    float: left;
    background: #eee;
}

*.categoryBox {
    height: 176px;
    width: 212px;
    margin: 21px 14px 6px;
    float: inherit;
    background: #ccc;
}

.categoryLabelText {
    line-height: 150%;
    font-size: x-large;
}*
----


=== NetBeans CSS 支持

使用样式表时，有两个窗口可能会特别有用。使用“CSS 预览”，您可以按样式规则在浏览器中呈现的方式查看样式规则。要打开“CSS 预览”，请从主菜单中选择 ""Window""（窗口）> ""Other""（其他）> ""CSS Preview""（CSS 预览）。当您将光标置于编辑器中的样式规则上时，“CSS 预览”会根据规则中定义的属性自动刷新以显示样例文本。

image::images/css-preview.png[title=""使用 ""]

如果不喜欢手动编写样式规则代码，则“CSS 样式构建器”会非常有用。要打开 CSS 样式构建器，请从主菜单中选择 ""Window""（窗口）> ""Other""（其他）> ""CSS Style Builder""（CSS 样式构建器）。使用此界面，您可以通过从图形界面中选择属性和值来构建规则。

image::images/style-builder.png[title=""使用 CSS 样式构建器构建样式规则""]

与“CSS 预览”一样，样式构建器会与编辑器保持同步。当在样式构建器中做出选择时，编辑器中的样式规则也会自动更新。同样，当在编辑器中键入更改时，样式构建器中的选择也会立即更新。



[start=11]
. 保存（Ctrl-S 组合键；在 Mac 上为 ⌘-S 组合键）`index.jsp` 和 `affablebean.css` 文件，然后切换到浏览器并刷新页面以查看其当前状态。 

image::images/index-page3.png[title=""在运行项目时会显示页眉和右栏的占位符""]

[start=12]
. 左栏和页脚只需要静态文本的占位符，因此让我们同时实现这两个区域。

在 `<div id=""indexLefttColumn"">` 和 `<div id=""footer"">` 标记之间插入以下代码。（新代码以*粗体*显示。）

[source,html]
----

<div id=""indexLeftColumn"">
    *<div id=""welcomeText"">
        <p>[ welcome text ]</p>
    </div>*
</div>

...

<div id=""footer"">
    *<hr>
    <p id=""footerText"">[ footer text ]</p>*
</div>
----

[start=13]
. 更改 `affablebean.css` 样式表。此时无需考虑所有的新 ID 和类 - 您可在以后从客户接收到文本和图像时再微调外观。

水平规则 (`<hr>`) 标记会扩展至包含它的元素 (`<div id=""footer""`) 的整个长度。因此，要根据模型图像缩短其长度，您可以调整 `<div id=""footer"">` 的宽度。（新代码以*粗体*显示。）

[source,java]
----

#footer {
    height: 60px;
    *width: 350px;*
    clear: left;
    background: #aaa;
}

*hr {
    border: 0;
    background-color: #333;
    height: 1px;
    margin: 0 25px;
    width: 300px;
}*
----

[start=14]
. 保存（Ctrl-S 组合键；在 Mac 上为 ⌘-S 组合键）`index.jsp` 和 `affablebean.css` 文件，然后切换到浏览器并刷新页面以查看其当前状态。

image::images/index-page4.png[title=""显示左栏和页脚的占位符""] 

欢迎页已经完成。您已经为将存在于页面上的组件创建了所有必需的占位符。

现在，您已经完成了应用程序欢迎页的初始设计。页面组件的所有占位符都已存在。在教程的后面部分，当您开始对页面视图应用动态逻辑时，您只需将 JSTL 和 EL 表达式插入这些占位符中。

剩下的任务是根据link:design.html#mockups[+模型+]为其他页面实现初始设计。要完成该任务，请按照上述模式进行操作，即：

1. 为主页面区域创建 `<div>` 标记。
2. 依次为每个区域重复执行以下三个步骤：
.. 在 HTML 中创建结构。
.. 创建一组用于定义外观的样式。
.. 查看页面以检查更改后的结果。

请确保利用 IDE 所提供的 HTML 和 CSS 支持。下面介绍了一些<<tipsTricks,提示和技巧>>。如果您只希望获取其余页面的代码并继续完成本教程，可以link:https://netbeans.org/projects/samples/downloads/download/Samples%252FJavaEE%252Fecommerce%252FAffableBean_snapshot1.zip[+下载 `AffableBean` 项目的快照 1+]。此处包含其余页面的初始模型实现图像。


[[categoryPage]]
==== 类别页

image::images/category-page.png[title=""为类别页实现的占位符""] 


[[cartPage]]
==== 购物车页

image::images/cart-page.png[title=""为购物车页实现的占位符""] 


[[checkoutPage]]
==== 结帐页

image::images/checkout-page.png[title=""为结帐页实现的占位符""] 


==== 确认页

image::images/confirmation-page.png[title=""为结帐页实现的占位符""] 

*注：*每个页面区域的背景色仅用于帮助您在开发应用程序时定位元素。最后，您将要从样式表中将其删除，并应用更适合应用程序的背景色。您可以通过调整 `main` 类的背景规则来实现此操作：


[source,java]
----

#main { background: #f7f7e9 }
----


[[tipsTricks]]
=== 提示和技巧

IDE 的编辑器提供了许多有助于您提高工作效率的功能。如果您熟悉快捷键和编辑器工具栏中的按钮，则可以提高工作效率。下面所列的提示适用于 HTML 和 CSS 文件编辑器。要查看更多快捷键，可从主菜单中选择 ""Help""（帮助）> ""Keyboard Shortcuts Card""（快捷键列表）以打开 IDE 的快捷键列表。

* *代码完成：*当您键入标记和属性时，会自动在一个弹出式框中显示代码完成的建议。按 Enter 键可完成建议的标记。
* *格式化代码：*在编辑器中单击鼠标右键，然后选择 ""Format""（格式化）。
* *开启/关闭行号：*在左旁注中单击鼠标右键，然后选择 ""Show Line Numbers""（显示行号）。
* *查找实例：*突出显示文本块，然后按 Ctrl-F 组合键（在 Mac 上为 ⌘-F 组合键）。所有匹配项在编辑器中突出显示。要开启/关闭突出显示，请在编辑器的工具栏中按 ""Toggle Highlight Search""（开启/关闭搜索文本的突出显示）(image:images/toggle-highlight.png[]) 按钮（Ctrl-Shift-H 组合键）。
* *Create a bookmark*（创建书签）：按 ""Toggle Bookmark""（开启/关闭书签）(image:images/toggle-bookmark.png[]) 按钮（Ctrl-Shift-M 组合键）可在编辑器的左旁注中创建书签。无论您处于文件的哪个位置，都可以通过在编辑器的工具栏中按 ""Previous Bookmark""（上一个书签）/""Next Bookmark""（下一个书签）按钮跳转至相应的书签。
* *向上或向下复制代码片段：*突出显示代码片段，然后按 Ctrl-Shift-向上方向键/向下方向键。
* *突出显示起始和结束标记：*将光标置于起始或结束标记上，两者都会以黄色突出显示。



[[view]]
== 在 WEB-INF 中放置 JSP 页

查看创建的link:design.html#mockups[+页面模型+]，可以发现无论何时由谁来请求link:design.html#index[+欢迎页+]，该页面的外观都应该相同。也就是说，欢迎页上显示的内容不是由用户的_会话_决定的。（在第 8 单元link:manage-sessions.html[+管理会话+]中将对会话进行介绍。）但请注意，所有其他页面确实需要某些形式的用户特定信息才能正常显示。例如，link:design.html#category[+类别页+]需要用户选择类别才能显示，link:design.html#cart[+购物车页+]需要知道当前放入购物车的所有项目。如果服务器不能将用户特定信息与传入请求相关联，则无法正常呈现这些页面。因此，我们不希望直接从浏览器的地址栏中访问这些页面。项目的 `WEB-INF` 文件夹可以用于此目的：`WEB-INF` 文件夹中包含的任何资源都不能直接从浏览器进行访问。

创建一个名为 `view` 的新文件夹，并将其置于 `WEB-INF` 文件夹中。然后，将除欢迎页之外的所有其他 JSP 页移动到此新文件夹中。

1. 在 ""Projects""（项目）窗口中，右键单击 ""WEB-INF"" 节点，然后选择 ""New""（新建）> ""Folder""（文件夹）。
2. 在新建文件夹向导中，将文件夹命名为 `view`，然后单击 ""Finish""（完成）。请注意，""Projects""（项目）窗口中出现新文件夹节点。
3. 将 `category.jsp`、`cart.jsp`、`checkout.jsp` 和 `confirmation.jsp` 页移动到 `view` 文件夹中。

也可以通过单击 `cart.jsp` 将其选定，然后按住 Shift 键并单击 `confirmation.jsp` 来选择文件。这可选定四个文件。然后，在选定四个文件的情况下，单击它们并将它们拖至 `WEB-INF/view` 文件夹中。 

image::images/view-folder.png[title=""单击 JSP 页并将其拖至 ""]

要演示无法再从浏览器访问这些页，请单击 ""Run Project""（运行项目）(image:images/run-project-btn.png[]) 按钮以运行项目。当应用程序显示在浏览器中时，在地址栏中输入其中任意文件的完整路径。例如，键入：


[source,java]
----

http://localhost:8080/AffableBean/WEB-INF/view/category.jsp
----

您会收到一条 HTTP 状态 404 消息，指示该资源不可用。



[[jspf]]
== 创建页眉和页脚

查看link:design.html#mockups[+页面模型+]，很容易发现所有五个视图都共享了相同的内容；在顶部，它们包含公司徽标、语言切换以及与购物车功能相关的其他窗口部件。在底部，它们包含一些具有隐私政策和联系信息链接的文本。我们可以将此代码提取到两个 JSP 片段（一个页眉和一个页脚）中，而不是在每个页面的源文件中都包含此代码。然后，在需要呈现片段文件时，我们将这些文件包含在页面视图中。

对于这些片段，让我们创建一个名为 `jspf` 的新文件夹，并将其置于 `WEB-INF` 中。

1. 在 ""Projects""（项目）窗口中，右键单击 ""WEB-INF"" 节点，然后选择 ""New""（新建）> ""Folder""（文件夹）。
2. 在新建文件夹向导中，将文件夹命名为 `jspf`，然后单击 ""Finish""（完成）。 

IDE 提供的菜单项通常与上下文有关。例如，由于您右键单击了 ""WEB-INF"" 节点，因此在显示新建文件夹向导时，会在 ""Parent Folder""（父文件夹）字段中自动输入 `web/WEB-INF`。同样，当您在 ""Projects""（项目）窗口中右键单击某个节点并选择“新建”时，所列的文件类型部分取决于您之前选择的项目。


[start=3]
. 创建两个 JSP 片段：`header.jspf` 和 `footer.jspf`。为此，请右键单击新创建的 `jspf` 文件夹，然后选择 ""New""（新建）> ""JSP""。在新建 JSP 向导中，输入文件名，在 ""Options""（选项）下选择 ""Create as a JSP Segment""（作为 JSP 片段创建）选项，然后单击 ""Finish""（完成）。

完成后，将看到 `header.jspf` 和 `footer.jspf` 显示在 ""Projects""（项目）窗口中： 

image::images/projects-win-jspf.png[title=""将在项目中显示页眉和页脚 JSP 片段""] 

现在，您可以从任意 JSP 页中复制页眉代码并将其粘贴到 `header.jspf` 文件中。同样，您可以从任意 JSP 页中复制页脚代码并将其粘贴到 `footer.jspf` 文件中。完成此任务后，可以从所有 JSP 页中删除页眉和页脚代码。

[start=4]
. 从任意 JSP 页中复制页眉代码并将其粘贴到 `header.jspf` 文件中。页眉应该包括页面文档类型以及从 `<html>`、`<head>` 和 `<body>` 起始标记到 `<div id=""header"">` 元素的结束标记之间的内容。请确保包括在页面视图顶部使用的购物车窗口部件、语言切换和 ""proceed to checkout"" 按钮的占位符。在将代码粘贴到 `header.jspf` 中后，该文件将如下所示。

[source,html]
----

<%@page contentType=""text/html"" pageEncoding=""UTF-8""%>
<!DOCTYPE HTML PUBLIC ""-//W3C//DTD HTML 4.01 Transitional//EN""
    ""http://www.w3.org/TR/html4/loose.dtd"">

<html>
    <head>
        <meta http-equiv=""Content-Type"" content=""text/html; charset=UTF-8"">
        <link rel=""stylesheet"" type=""text/css"" href=""css/affablebean.css"">
        <title>The Affable Bean</title>
    </head>
    <body>
        <div id=""main"">
            <div id=""header"">
                <div id=""widgetBar"">

                    <div class=""headerWidget"">
                        [ language toggle ]
                    </div>

                    <div class=""headerWidget"">
                        [ checkout button ]
                    </div>

                    <div class=""headerWidget"">
                        [ shopping cart widget ]
                    </div>

                </div>

                <a href=""#"">
                    <img src=""#"" id=""logo"" alt=""Affable Bean logo"">
                </a>

                <img src=""#"" id=""logoText"" alt=""the affable bean"">
            </div>
----

[start=5]
. 从任意 JSP 页中复制页脚代码并将其粘贴到 `footer.jspf` 文件中。页脚代码应该包括从 `<div id=""footer"">` 元素到 `<html>` 结束标记之间的内容。在将代码粘贴到 `footer.jspf` 中后，该文件将如下所示。

[source,html]
----

            <div id=""footer"">
                <hr>
                <p id=""footerText"">[ footer text ]</p>
            </div>
        </div>
    </body>
</html>
----

[start=6]
. 从所有五个 JSP 页（`index.jsp`、`category.jsp`、`cart.jsp`、`checkout.jsp` 和 `confirmation.jsp`）中删除页眉和页脚。



[[dd]]
== 向部署描述符中添加指令

到目前为止，您已经将视图放在适当的位置并将公用的页眉和页脚代码提取到 `header.jspf` 和 `footer.jspf` 文件中。应用程序仍然需要知道页眉和页脚文件将应用到哪些页面。您可以在每个页面视图中添加 `<jsp:include>` 标记。但是，这样做只会重新引入我们刚要努力消除的重复代码。一种替代解决方案是创建一个 `web.xml` 部署描述符，然后添加 JSP 属性组指令以指定页眉和页脚片段应该应用到哪些页面视图。

1. 按 Ctrl-N 组合键（在 Mac 上为 ⌘-N 组合键）以打开新建文件向导。选择 ""Web"" 类别，然后在 ""File Types""（文件类型）下选择 ""Standard Deployment Descriptor (web.xml)""（标准部署描述符 (web.xml)）。
2. 单击 ""Next""（下一步）。请注意，该文件名为 `web.xml`，并且在完成后，该向导会将其放置在项目的 `WEB-INF` 目录中。
3. 单击 ""Finish""（完成）。将会创建 `web.xml` 文件并将其添加到项目中。编辑器中会打开部署描述符的 IDE 图形界面。

该界面按可以在 Web 应用程序中配置的区域进行分类。这些区域在编辑器工具栏中显示为标签，并包含 ""Servlet""、“过滤器”、“引用”和“安全”等主题。""XML"" 标签显示文件的整个源代码。您在图形界面中所做的任何更改将会导致立即更新部署描述符的源代码，通过切换到 ""XML"" 标签可以对此进行验证。下面的步骤演示了这一点。

[start=4]
. 单击 ""Pages""（页面）标签，然后单击 ""Add JSP Property Group""（添加 JSP 属性组）按钮。打开 ""Add JSP Property Group""（添加 JSP 属性组）对话框。

[start=5]
. 在 ""Description""（描述）字段中键入 ""`header and footer settings`""。将 ""Display Name""（显示名称）保留为空。""Display Name""（显示名称）和 ""Description""（描述）字段均为可选字段。

[start=6]
. 对于 ""URL Patterns""（URL 模式），指定五个视图的路径。键入 ""`/index.jsp`"" 和 ""`/WEB-INF/view/*`""。使用逗号分隔这两个路径。（""`*`"" 是表示给定文件夹内所有文件的通配符。） 

image::images/add-jsp-prop-group-dialog.png[title=""使用 ""] 标记"">

[start=7]
. 单击 ""OK""（确定）。在 ""Pages""（页面）标签的 ""JSP Properties Groups""（JSP 属性组）类别中添加一个条目。

[start=8]
. 切换回 ""XML"" 标签。请注意，以下代码已添加到部署描述符中。

[source,xml]
----

<jsp-config>
    <jsp-property-group>
        <description>header and footer settings</description>
        <url-pattern>/index.jsp</url-pattern>
        <url-pattern>/WEB-INF/view/*</url-pattern>
    </jsp-property-group>
</jsp-config>
----

*注：*您可能需要在代码中添加回车符，以便该代码显示为多行。可以在编辑器中单击鼠标右键并选择 ""Format""（格式化）（Alt-Shift-F 组合键；在 Mac 上为 Ctrl-Shift-F 组合键）来适当缩进代码。


[start=9]
. 再次切换到 ""Pages""（页面）标签，然后在 ""Include Preludes""（包括 Prelude）和 ""Include Codas""（包括 Coda）字段中，分别输入 `header.jspf` 和 `footer.jspf` 文件的路径。您可以单击 ""Browse""（浏览）按钮，然后在提供的对话框中导航至这些文件。 
[.feature]
--

image::images/jsp-prop-groups-small.png[role=""left"", link=""images/jsp-prop-groups.png""]

--

[start=10]
. 切换回 ""XML"" 标签。请注意，已经添加以下代码。（更改内容以*粗体*显示。）

[source,xml]
----

<jsp-config>
    <jsp-property-group>
        <description>header and footer settings</description>
        <url-pattern>/index.jsp</url-pattern>
        <url-pattern>/WEB-INF/view/*</url-pattern>
        *<include-prelude>/WEB-INF/jspf/header.jspf</include-prelude>
        <include-coda>/WEB-INF/jspf/footer.jspf</include-coda>*
    </jsp-property-group>
</jsp-config>
----
上面的指令指定在给定 `url-pattern` 包含的所有文件前面附加 `header.jspf` 文件，并在后面附加 `footer.jspf` 文件。 

要查看上述标记以及 Web 部署描述符中提供的所有标记的定义，请参见 link:http://jcp.org/en/jsr/detail?id=315[+Servlet 规范+]。


[start=11]
. 再次运行应用程序（按 F6 键；在 Mac 上为 fn-F6 组合键）。您已经删除了 `index.jsp` 文件中的页眉和页脚代码，因此可以确定在请求该文件时是否会自动添加页眉和页脚。

您将看到<<welcome-page,欢迎页显示的内容和以前一样>>，其中包括页眉和页脚内容。



[[controller]]
== 创建控制器 Servlet

控制器 Servlet 通过以下方式来处理传入请求：启动任何所需的操作来生成请求模型，然后将请求转发到相应的视图。有关可视表示，请参见 link:design.html#mvcDiagram[+AffableBean 项目的 MVC 图+]。

IDE 提供了一个 Servlet 向导，使用该向导可以在 Web 应用程序中定义 Servlet 组件，方法是在生成的类中包括 `@WebServlet` 标注，或者将必需的指令添加到部署描述符中。在以下步骤中，您将创建 `ControllerServlet` 并使用 link:http://java.sun.com/javaee/6/docs/api/javax/servlet/annotation/WebServlet.html[+`@WebServlet`+] 标注在应用程序上下文中对其进行定义。

1. 在 ""Projects""（项目）窗口中，右键单击 `AffableBean` 项目节点，然后选择 ""New""（新建）> ""Servlet""。
2. 在向导的 ""Class Name""（类名）字段中，键入 `ControllerServlet`。
3. 在 ""Package""（包）字段中，键入 `controller`。（完成向导后，将会自动创建新包。） 

image::images/servlet-wizard.png[title=""使用 Servlet 向导可为项目创建 Servlet""]

[start=4]
. 单击 ""Next""（下一步）。该向导的步骤 3 允许您配置 Servlet。最重要的是您需要指定 URL 模式。该模式标识用于调用 Servlet 的 URL。例如，如果输入 ""`/category`""，则会指定 Servlet 处理如下所示的请求。

[source,java]
----

http://localhost/AffableBean*/category*
----
URL 模式应该与用户可以启动的视图和操作相对应。查看link:design.html#index[+欢迎页模型+]，用户应该能够选择类别。因此，我们可以将 `/category` URL 与单击类别图像的操作相关联。同样，在link:design.html#category[+类别页+]中，用户应该能够向购物车添加项目。因此，我们可以指定 `/addToCart`。

[start=5]
. 在 ""URL Pattern(s)""（URL 模式）字段中，键入 ""`/category, /addToCart, /viewCart`""。各模式之间使用逗号分隔。创建 Servlet 类后，您可以直接在其中添加更多模式。 

image::images/servlet-wizard2.png[title=""直接在向导中配置 Servlet 部署""]

[start=6]
. 单击 ""Finish""（完成）。IDE 生成 `ControllerServlet` 并在编辑器中将其打开。Servlet 和 URL 模式包括在 `@WebServlet` 标注中，该标注显示在类签名上面。

[source,java]
----

*@WebServlet(name=""ControllerServlet"", urlPatterns={""/category"", ""/addToCart"", ""/viewCart""})*
public class ControllerServlet extends HttpServlet {
----
在上一步中，如果您在向导中选择了 `Add information to deployment descriptor (web.xml)`（将信息添加到部署描述符 (web.xml)）选项，则会在应用程序的 `web.xml` 文件中生成以下标记。

[source,xml]
----

<servlet>
    <servlet-name>ControllerServlet</servlet-name>
    <servlet-class>controller.ControllerServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>ControllerServlet</servlet-name>
    <url-pattern>/category</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>ControllerServlet</servlet-name>
    <url-pattern>/addToCart</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>ControllerServlet</servlet-name>
    <url-pattern>/viewCart</url-pattern>
</servlet-mapping>
----

[start=7]
. 直接在 `@WebServlet` 标注的 `urlPatterns` 元素中添加其他 URL 模式。应用程序需要更多 URL 模式以便用于其他操作和视图。您可以键入下列模式：
* `/updateCart`
* `/checkout`
* `/purchase`
* `/chooseLanguage`
请确保使用逗号分隔每个模式。您还可以按如下方式重新格式化标注：

[source,java]
----

@WebServlet(name=""ControllerServlet"",
            urlPatterns = {""/category"",
                           ""/addToCart"",
                           ""/viewCart""*,
                           ""/updateCart"",
                           ""/checkout"",
                           ""/purchase"",
                           ""/chooseLanguage""*})
----

[start=8]
. 最后，包括 `loadOnStartup` 元素，以便在部署应用程序时实例化和初始化该 Servlet。值等于或大于 `0` 将导致发生此行为（`-1` 为默认值）。

[source,java]
----

@WebServlet(name=""ControllerServlet"",
            *loadOnStartup = 1,*
            urlPatterns = {""/category"",
                           ""/addToCart"",
                           ""/viewCart"",
                           ""/updateCart"",
                           ""/checkout"",
                           ""/purchase"",
                           ""/chooseLanguage""})
----



[[implement]]
== 实现控制器 Servlet

如前面所述，控制器 Servlet 通过以下方式来处理传入请求：启动任何所需的操作来生成请求模型，然后将请求转发到相应的视图。有关可视表示，请参见 link:design.html#mvcDiagram[+AffableBean 项目的 MVC 图+]。

查看为新的 `ControllerServlet` 生成的代码时，可以看到 IDE 的 Servlet 模板采用 `processRequest` 方法，该方法由 `doGet` 和 `doPost` 方法调用。（要查看这些方法，您可能需要展开代码折叠，方法是编辑器的左旁注中单击加号图标 (image:images/code-fold-icon.png[])。）由于此应用程序区分 `doGet` 和 `doPost`，因此您将直接在这些方法中添加代码并完全删除 `processRequest` 方法。


=== 使用 IDE 的模板管理器修改文件模板

IDE 为您创建的任何新文件都提供了一个基本模板。如果模板并不适合您的工作模式，可以使用 IDE 的模板管理器对其进行更改。IDE 几乎为所有文件类型都提供了模板。

例如，要修改 Servlet 模板，请执行以下操作：

1. 通过从主菜单中选择 ""Tools""（工具）> ""Templates""（模板）以打开 ""Template Manager""（模板管理器）。
2. 展开 ""Web"" 类别，然后选择 ""Servlet"" 模板。 

image::images/template-manager.png[title=""通过模板管理器访问和修改文件模板""]

[start=3]
. 单击 ""Open in Editor""（在编辑器中打开）按钮。

[start=4]
. 在编辑器中修改模板。下次您创建新的 Servlet（例如，使用 Servlet 向导）时，将会应用新版本。



现在，您已经使用 `@WebServlet` 标注将 URL 模式映射到 Servlet，接下来应设置 `ControllerServlet` 以处理这些模式。此外，还应实例化 `RequestDispatcher` 以将请求的模式转发到相应的视图。

1. 将 `ControllerServlet` 类模板代码替换为以下代码。

[source,xml]
----

public class ControllerServlet extends HttpServlet {

    /**
     * Handles the HTTP <code>GET</code> method.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {

        String userPath = request.getServletPath();

        // if category page is requested
        if (userPath.equals(""/category"")) {
            // TODO: Implement category request

        // if cart page is requested
        } else if (userPath.equals(""/viewCart"")) {
            // TODO: Implement cart page request

            userPath = ""/cart"";

        // if checkout page is requested
        } else if (userPath.equals(""/checkout"")) {
            // TODO: Implement checkout page request

        // if user switches language
        } else if (userPath.equals(""/chooseLanguage"")) {
            // TODO: Implement language request

        }

        // use RequestDispatcher to forward request internally
        String url = ""/WEB-INF/view"" + userPath + "".jsp"";

        try {
            request.getRequestDispatcher(url).forward(request, response);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * Handles the HTTP <code>POST</code> method.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {

        String userPath = request.getServletPath();

        // if addToCart action is called
        if (userPath.equals(""/addToCart"")) {
            // TODO: Implement add product to cart action

        // if updateCart action is called
        } else if (userPath.equals(""/updateCart"")) {
            // TODO: Implement update cart action

        // if purchase action is called
        } else if (userPath.equals(""/purchase"")) {
            // TODO: Implement purchase action

            userPath = ""/confirmation"";
        }

        // use RequestDispatcher to forward request internally
        String url = ""/WEB-INF/view"" + userPath + "".jsp"";

        try {
            request.getRequestDispatcher(url).forward(request, response);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

}
----
继续执行该教程的操作时，将返回 `ControllerServlet`，并单独实现每个映射的 URL 模式。

[start=2]
. 检查上面的代码。有几点需要注：
* Servlet 使用 `userPath` 实例变量从客户端获取请求的 URL 模式：

[source,java]
----

String userPath = request.getServletPath();
----
`userPath` 由 `doGet` 和 `doPost` 方法使用。
* 主要与页面请求相关联的 URL 模式由 `doGet` 方法管理。例如，`/category`、`/viewCart` 和 `/checkout` 会导致显示类别、购物车和结帐页。
* 与窗体提交和敏感用户数据传输相关联的 URL 模式（例如，`/addToCart`、`/updateCart` 和 `/purchase`）由 `doPost` 方法管理。
* 对于 `doGet` 和 `doPost` 方法，相应视图的路径采用 `url` 字符串形式：

[source,java]
----

String url = ""/WEB-INF/view"" + userPath + "".jsp"";
----
* `RequestDispatcher` 从 `HttpServletRequest` 获取并应用 `url` 转发请求：

[source,java]
----

request.getRequestDispatcher(url).forward(request, response);
----
* `TODO` 注释用于表示仍需要完成的工作。例如：

[source,java]
----

// if category page is requested
if (userPath.equals(""/category"")) {
    // TODO: Implement category request
----
在代码中应用 `TODO` 注释是一种便于跟踪需要完成的任务的有用方法。可以使用 IDE 的 ""Tasks""（任务）窗口（Ctrl-6 组合键；在 Mac 上为 ⌘-6 组合键）查看所有 TODO 注释，以及项目中包含的任何语法或编译错误。 

image::images/tasks-window.png[title=""使用 IDE 的 ""] 

您可以控制 ""Tasks""（任务）窗口中显示的关键字。打开 ""Options""（选项）窗口（""Tools""（工具）> ""Options""（选项）；在 Mac 上为 ""NetBeans"" > ""Preferences""（首选项）），然后选择 ""Miscellaneous""（其他）> ""Tasks""（任务）。


[start=3]
. 运行项目（按 F6 键；在 Mac 上为 fn-F6 组合键）并测试以查看 `ControllerServlet` 是否将请求转发到相应的视图。
* 在浏览器的地址栏中键入 `http://localhost:8080/AffableBean/category`。将显示应用程序的<<categoryPage,类别页>>。
* 在浏览器的地址栏中键入 `http://localhost:8080/AffableBean/viewCart`。将显示应用程序的<<cartPage,购物车页>>。
* 在浏览器的地址栏中键入 `http://localhost:8080/AffableBean/checkout`。将显示应用程序的<<checkoutPage,结帐页>>。

*注：*在浏览器的地址栏中输入 `http://localhost:8080/AffableBean/purchase` 时，不能查看<<confirmationPage,确认页>>。当然，这是因为，`/purchase` URL 模式由 Servlet 的 `doPost` 方法处理，而从浏览器地址栏发送的请求通常是使用 HTTP GET 方法发送的。

此时，您已经创建了包含功能组件占位符的 JSP 页。您还设置了应用程序的前端结构。现在，JSP 页已位于 `WEB-INF` 文件夹中，页眉和页脚代码已被提取到单独的文件中，对部署描述符进行了正确配置，并且您设置了 `ControllerServlet` 来处理传入请求。在下一个教程单元中，您将采取措施来启用应用程序和数据库之间的连接。

如果希望将自己的工作与此单元的样例解决方案进行比较，可以link:https://netbeans.org/projects/samples/downloads/download/Samples%252FJavaEE%252Fecommerce%252FAffableBean_snapshot2.zip[+下载 AffableBean 项目的快照 2+]。

link:/about/contact_form.html?to=3&subject=Feedback: NetBeans E-commerce Tutorial - Preparing the Page Views and Controller Servlet[+请将您的反馈意见发送给我们+]



[[seeAlso]]
== 另请参见


=== NetBeans 教程

* link:../javaee-intro.html[+Java EE 技术简介+]
* link:../javaee-gettingstarted.html[+Java EE 6 应用程序入门指南+]
* link:../../web/quickstart-webapps.html[+Web 应用程序开发简介+]
* link:../../web/mysql-webapp.html[+使用 MySQL 数据库创建简单的 Web 应用程序+]
* link:../../screencasts.html[+NetBeans IDE 6.x 的视频教程和演示+]
* link:https://netbeans.org/projects/www/downloads/download/shortcuts.pdf[+快捷键和代码模板列表+]
* link:../../../trails/java-ee.html[+Java EE 和 Java Web 学习资源+]


=== NetBeans 书籍

* link:https://netbeans.org/kb/articles/netbeans-tips-and-tricks-book.html[+100 个 NetBeans IDE 提示和技巧+]
* link:http://www.apress.com/book/view/1590598954[+专业的 NetBeans IDE 6 富客户端平台版本+]
* link:http://apress.com/book/view/1430219548[+带有 GlassFish 3 的 Java EE 6 平台入门：从初学者到专业人士+]
* link:https://netbeans.org/kb/articles/books.html[+有关 NetBeans IDE 的更多书籍+]


=== 外部资源

* link:http://jcp.org/en/jsr/detail?id=315[+Servlet 3.0 规范+]
* link:https://developer.mozilla.org/en/Common_CSS_Questions[+常见的 CSS 问题+]
* link:http://quirksmode.org/compatibility.html[+浏览器兼容性主表+]
* link:http://refcardz.dzone.com/refcardz/netbeans-ide-67-update[+用于 NetBeans Java 编辑器的 DZone Refcard+]
",12415,False,2235.601620501633,median
"= Performance

== Performance/AncestorsInclude

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| No
| Yes (Unsafe)
| 1.7
| -
|===

This cop is used to identify usages of `ancestors.include?` and
change them to use `<=` instead.

=== Safety

This cop is unsafe because it can't tell whether the receiver is a class or an object.
e.g. the false positive was for `Nokogiri::XML::Node#ancestors`.

=== Examples

[source,ruby]
----
# bad
A.ancestors.include?(B)

# good
A <= B
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#ancestorsinclude-vs--code

== Performance/ArraySemiInfiniteRangeSlice

NOTE: Required Ruby version: 2.7

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Disabled
| No
| Yes (Unsafe)
| 1.9
| -
|===

This cop identifies places where slicing arrays with semi-infinite ranges
can be replaced by `Array#take` and `Array#drop`.
This cop was created due to a mistake in microbenchmark and hence is disabled by default.
Refer https://github.com/rubocop/rubocop-performance/pull/175#issuecomment-731892717

=== Safety

This cop is unsafe for string slices because strings do not have `#take` and `#drop` methods.

=== Examples

[source,ruby]
----
# bad
array[..2]
array[...2]
array[2..]
array[2...]
array.slice(..2)

# good
array.take(3)
array.take(2)
array.drop(2)
array.drop(2)
array.take(3)
----

== Performance/BigDecimalWithNumericArgument

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.7
| -
|===

This cop identifies places where numeric argument to BigDecimal should be
converted to string. Initializing from String is faster
than from Numeric for BigDecimal.

=== Examples

[source,ruby]
----
# bad
BigDecimal(1, 2)
4.to_d(6)
BigDecimal(1.2, 3, exception: true)
4.5.to_d(6, exception: true)

# good
BigDecimal('1', 2)
BigDecimal('4', 6)
BigDecimal('1.2', 3, exception: true)
BigDecimal('4.5', 6, exception: true)
----

== Performance/BindCall

NOTE: Required Ruby version: 2.7

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 1.6
| -
|===

In Ruby 2.7, `UnboundMethod#bind_call` has been added.

This cop identifies places where `bind(obj).call(args, ...)`
can be replaced by `bind_call(obj, args, ...)`.

The `bind_call(obj, args, ...)` method is faster than
`bind(obj).call(args, ...)`.

=== Examples

[source,ruby]
----
# bad
umethod.bind(obj).call(foo, bar)
umethod.bind(obj).(foo, bar)

# good
umethod.bind_call(obj, foo, bar)
----

== Performance/BlockGivenWithExplicitBlock

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.9
| -
|===

This cop identifies unnecessary use of a `block_given?` where explicit check
of block argument would suffice.

=== Examples

[source,ruby]
----
# bad
def method(&block)
  do_something if block_given?
end

# good
def method(&block)
  do_something if block
end

# good - block is reassigned
def method(&block)
  block ||= -> { do_something }
  warn ""Using default ..."" unless block_given?
  # ...
end
----

== Performance/Caller

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.49
| 1.9
|===

This cop identifies places where `caller[n]`
can be replaced by `caller(n..n).first`.

=== Examples

[source,ruby]
----
# bad
caller[1]
caller.first
caller_locations[1]
caller_locations.first

# good
caller(2..2).first
caller(1..1).first
caller_locations(2..2).first
caller_locations(1..1).first
----

== Performance/CaseWhenSplat

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Disabled
| Yes
| Yes (Unsafe)
| 0.34
| 1.13
|===

Reordering `when` conditions with a splat to the end
of the `when` branches can improve performance.

Ruby has to allocate memory for the splat expansion every time
that the `case` `when` statement is run. Since Ruby does not support
fall through inside of `case` `when`, like some other languages do,
the order of the `when` branches should not matter. By placing any
splat expansions at the end of the list of `when` branches we will
reduce the number of times that memory has to be allocated for
the expansion. The exception to this is if multiple of your `when`
conditions can be true for any given condition. A likely scenario for
this defining a higher level when condition to override a condition
that is inside of the splat expansion.

=== Safety

This cop is not unsafe auto-correction because it is not a guaranteed
performance improvement. If the data being processed by the `case` condition is
normalized in a manner that favors hitting a condition in the splat expansion,
it is possible that moving the splat condition to the end will use more memory,
and run slightly slower.
See for more details: https://github.com/rubocop/rubocop/pull/6163

=== Examples

[source,ruby]
----
# bad
case foo
when *condition
  bar
when baz
  foobar
end

case foo
when *[1, 2, 3, 4]
  bar
when 5
  baz
end

# good
case foo
when baz
  foobar
when *condition
  bar
end

case foo
when 1, 2, 3, 4
  bar
when 5
  baz
end
----

== Performance/Casecmp

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| No
| Yes (Unsafe)
| 0.36
| -
|===

This cop identifies places where a case-insensitive string comparison
can better be implemented using `casecmp`.

=== Safety

This cop is unsafe because `String#casecmp` and `String#casecmp?` behave
differently when using Non-ASCII characters.

=== Examples

[source,ruby]
----
# bad
str.downcase == 'abc'
str.upcase.eql? 'ABC'
'abc' == str.downcase
'ABC'.eql? str.upcase
str.downcase == str.downcase

# good
str.casecmp('ABC').zero?
'abc'.casecmp(str).zero?
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#stringcasecmp-vs-stringdowncase---code

== Performance/ChainArrayAllocation

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Disabled
| Yes
| No
| 0.59
| -
|===

This cop is used to identify usages of `array.compact.flatten.map { |x| x.downcase }`.
Each of these methods (`compact`, `flatten`, `map`) will generate a new intermediate array
that is promptly thrown away. Instead it is faster to mutate when we know it's safe.

=== Examples

[source,ruby]
----
# bad
array = [""a"", ""b"", ""c""]
array.compact.flatten.map { |x| x.downcase }

# good
array = [""a"", ""b"", ""c""]
array.compact!
array.flatten!
array.map! { |x| x.downcase }
array
----

=== References

* https://twitter.com/schneems/status/1034123879978029057

== Performance/CollectionLiteralInLoop

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| No
| 1.8
| -
|===

This cop identifies places where Array and Hash literals are used
within loops. It is better to extract them into a local variable or constant
to avoid unnecessary allocations on each iteration.

You can set the minimum number of elements to consider
an offense with `MinSize`.

=== Examples

[source,ruby]
----
# bad
users.select do |user|
  %i[superadmin admin].include?(user.role)
end

# good
admin_roles = %i[superadmin admin]
users.select do |user|
  admin_roles.include?(user.role)
end

# good
ADMIN_ROLES = %i[superadmin admin]
...
users.select do |user|
  ADMIN_ROLES.include?(user.role)
end
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| MinSize
| `1`
| Integer
|===

== Performance/CompareWithBlock

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.46
| -
|===

This cop identifies places where `sort { |a, b| a.foo <=> b.foo }`
can be replaced by `sort_by(&:foo)`.
This cop also checks `max` and `min` methods.

=== Examples

[source,ruby]
----
# bad
array.sort { |a, b| a.foo <=> b.foo }
array.max { |a, b| a.foo <=> b.foo }
array.min { |a, b| a.foo <=> b.foo }
array.sort { |a, b| a[:foo] <=> b[:foo] }

# good
array.sort_by(&:foo)
array.sort_by { |v| v.foo }
array.sort_by do |var|
  var.foo
end
array.max_by(&:foo)
array.min_by(&:foo)
array.sort_by { |a| a[:foo] }
----

== Performance/ConcurrentMonotonicTime

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.12
| -
|===

This cop identifies places where `Concurrent.monotonic_time`
can be replaced by `Process.clock_gettime(Process::CLOCK_MONOTONIC)`.

=== Examples

[source,ruby]
----
# bad
Concurrent.monotonic_time

# good
Process.clock_gettime(Process::CLOCK_MONOTONIC)
----

=== References

* https://github.com/rails/rails/pull/43502

== Performance/ConstantRegexp

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.9
| 1.10
|===

This cop finds regular expressions with dynamic components that are all constants.

Ruby allocates a new Regexp object every time it executes a code containing such
a regular expression. It is more efficient to extract it into a constant,
memoize it, or add an `/o` option to perform `#{}` interpolation only once and
reuse that Regexp object.

=== Examples

[source,ruby]
----
# bad
def tokens(pattern)
  pattern.scan(TOKEN).reject { |token| token.match?(/\\A#{SEPARATORS}\\Z/) }
end

# good
ALL_SEPARATORS = /\\A#{SEPARATORS}\\Z/
def tokens(pattern)
  pattern.scan(TOKEN).reject { |token| token.match?(ALL_SEPARATORS) }
end

# good
def tokens(pattern)
  pattern.scan(TOKEN).reject { |token| token.match?(/\\A#{SEPARATORS}\\Z/o) }
end

# good
def separators
  @separators ||= /\\A#{SEPARATORS}\\Z/
end
----

== Performance/Count

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes (Unsafe)
| 0.31
| 1.8
|===

This cop is used to identify usages of `count` on an `Enumerable` that
follow calls to `select`, `find_all`, `filter` or `reject`. Querying logic can instead be
passed to the `count` call.

=== Safety

This cop is unsafe because it has known compatibility issues with `ActiveRecord` and other
frameworks. ActiveRecord's `count` ignores the block that is passed to it.
`ActiveRecord` will ignore the block that is passed to `count`.
Other methods, such as `select`, will convert the association to an
array and then run the block on the array. A simple work around to
make `count` work with a block is to call `to_a.count {...}`.

For example:

[source,ruby]
----
`Model.where(id: [1, 2, 3]).select { |m| m.method == true }.size`
----

becomes:

[source,ruby]
----
`Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }`
----

=== Examples

[source,ruby]
----
# bad
[1, 2, 3].select { |e| e > 2 }.size
[1, 2, 3].reject { |e| e > 2 }.size
[1, 2, 3].select { |e| e > 2 }.length
[1, 2, 3].reject { |e| e > 2 }.length
[1, 2, 3].select { |e| e > 2 }.count { |e| e.odd? }
[1, 2, 3].reject { |e| e > 2 }.count { |e| e.even? }
array.select(&:value).count

# good
[1, 2, 3].count { |e| e > 2 }
[1, 2, 3].count { |e| e < 2 }
[1, 2, 3].count { |e| e > 2 && e.odd? }
[1, 2, 3].count { |e| e < 2 && e.even? }
Model.select('field AS field_one').count
Model.select(:value).count
----

== Performance/DeletePrefix

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| No
| Yes (Unsafe)
| 1.6
| 1.11
|===

In Ruby 2.5, `String#delete_prefix` has been added.

This cop identifies places where `gsub(/\\Aprefix/, '')` and `sub(/\\Aprefix/, '')`
can be replaced by `delete_prefix('prefix')`.

This cop has `SafeMultiline` configuration option that `true` by default because
`^prefix` is unsafe as it will behave incompatible with `delete_prefix`
for receiver is multiline string.

The `delete_prefix('prefix')` method is faster than `gsub(/\\Aprefix/, '')`.

=== Safety

This cop is unsafe because `Pathname` has `sub` but not `delete_prefix`.

=== Examples

[source,ruby]
----
# bad
str.gsub(/\\Aprefix/, '')
str.gsub!(/\\Aprefix/, '')

str.sub(/\\Aprefix/, '')
str.sub!(/\\Aprefix/, '')

# good
str.delete_prefix('prefix')
str.delete_prefix!('prefix')
----

==== SafeMultiline: true (default)

[source,ruby]
----
# good
str.gsub(/^prefix/, '')
str.gsub!(/^prefix/, '')
str.sub(/^prefix/, '')
str.sub!(/^prefix/, '')
----

==== SafeMultiline: false

[source,ruby]
----
# bad
str.gsub(/^prefix/, '')
str.gsub!(/^prefix/, '')
str.sub(/^prefix/, '')
str.sub!(/^prefix/, '')
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| SafeMultiline
| `true`
| Boolean
|===

== Performance/DeleteSuffix

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| No
| Yes (Unsafe)
| 1.6
| 1.11
|===

In Ruby 2.5, `String#delete_suffix` has been added.

This cop identifies places where `gsub(/suffix\\z/, '')` and `sub(/suffix\\z/, '')`
can be replaced by `delete_suffix('suffix')`.

This cop has `SafeMultiline` configuration option that `true` by default because
`suffix$` is unsafe as it will behave incompatible with `delete_suffix?`
for receiver is multiline string.

The `delete_suffix('suffix')` method is faster than `gsub(/suffix\\z/, '')`.

=== Safety

This cop is unsafe because `Pathname` has `sub` but not `delete_suffix`.

=== Examples

[source,ruby]
----
# bad
str.gsub(/suffix\\z/, '')
str.gsub!(/suffix\\z/, '')

str.sub(/suffix\\z/, '')
str.sub!(/suffix\\z/, '')

# good
str.delete_suffix('suffix')
str.delete_suffix!('suffix')
----

==== SafeMultiline: true (default)

[source,ruby]
----
# good
str.gsub(/suffix$/, '')
str.gsub!(/suffix$/, '')
str.sub(/suffix$/, '')
str.sub!(/suffix$/, '')
----

==== SafeMultiline: false

[source,ruby]
----
# bad
str.gsub(/suffix$/, '')
str.gsub!(/suffix$/, '')
str.sub(/suffix$/, '')
str.sub!(/suffix$/, '')
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| SafeMultiline
| `true`
| Boolean
|===

== Performance/Detect

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes (Unsafe)
| 0.30
| 1.8
|===

This cop is used to identify usages of `first`, `last`, `[0]` or `[-1]`
chained to `select`, `find_all` or `filter` and change them to use
`detect` instead.

=== Safety

This cop is unsafe because is has known compatibility issues with `ActiveRecord` and other
frameworks. `ActiveRecord` does not implement a `detect` method and `find` has its own
meaning. Correcting `ActiveRecord` methods with this cop should be considered unsafe.

=== Examples

[source,ruby]
----
# bad
[].select { |item| true }.first
[].select { |item| true }.last
[].find_all { |item| true }.first
[].find_all { |item| true }.last
[].filter { |item| true }.first
[].filter { |item| true }.last
[].filter { |item| true }[0]
[].filter { |item| true }[-1]

# good
[].detect { |item| true }
[].reverse.detect { |item| true }
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#enumerabledetect-vs-enumerableselectfirst-code

== Performance/DoubleStartEndWith

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.36
| 0.48
|===

This cop checks for double `#start_with?` or `#end_with?` calls
separated by `||`. In some cases such calls can be replaced
with an single `#start_with?`/`#end_with?` call.

`IncludeActiveSupportAliases` configuration option is used to check for
`starts_with?` and `ends_with?`. These methods are defined by Active Support.

=== Examples

[source,ruby]
----
# bad
str.start_with?(""a"") || str.start_with?(Some::CONST)
str.start_with?(""a"", ""b"") || str.start_with?(""c"")
str.end_with?(var1) || str.end_with?(var2)

# good
str.start_with?(""a"", Some::CONST)
str.start_with?(""a"", ""b"", ""c"")
str.end_with?(var1, var2)
----

==== IncludeActiveSupportAliases: false (default)

[source,ruby]
----
# good
str.starts_with?(""a"", ""b"") || str.starts_with?(""c"")
str.ends_with?(var1) || str.ends_with?(var2)

str.starts_with?(""a"", ""b"", ""c"")
str.ends_with?(var1, var2)
----

==== IncludeActiveSupportAliases: true

[source,ruby]
----
# bad
str.starts_with?(""a"", ""b"") || str.starts_with?(""c"")
str.ends_with?(var1) || str.ends_with?(var2)

# good
str.starts_with?(""a"", ""b"", ""c"")
str.ends_with?(var1, var2)
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| IncludeActiveSupportAliases
| `false`
| Boolean
|===

== Performance/EndWith

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes (Unsafe)
| 0.36
| 1.10
|===

This cop identifies unnecessary use of a regex where `String#end_with?` would suffice.

This cop has `SafeMultiline` configuration option that `true` by default because
`end$` is unsafe as it will behave incompatible with `end_with?`
for receiver is multiline string.

=== Safety

This will change to a new method call which isn't guaranteed to be on the
object. Switching these methods has to be done with knowledge of the types
of the variables which rubocop doesn't have.

=== Examples

[source,ruby]
----
# bad
'abc'.match?(/bc\\Z/)
/bc\\Z/.match?('abc')
'abc' =~ /bc\\Z/
/bc\\Z/ =~ 'abc'
'abc'.match(/bc\\Z/)
/bc\\Z/.match('abc')

# good
'abc'.end_with?('bc')
----

==== SafeMultiline: true (default)

[source,ruby]
----
# good
'abc'.match?(/bc$/)
/bc$/.match?('abc')
'abc' =~ /bc$/
/bc$/ =~ 'abc'
'abc'.match(/bc$/)
/bc$/.match('abc')
----

==== SafeMultiline: false

[source,ruby]
----
# bad
'abc'.match?(/bc$/)
/bc$/.match?('abc')
'abc' =~ /bc$/
/bc$/ =~ 'abc'
'abc'.match(/bc$/)
/bc$/.match('abc')
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| SafeMultiline
| `true`
| Boolean
|===

=== References

* https://github.com/JuanitoFatas/fast-ruby#stringmatch-vs-stringstart_withstringend_with-code-start-code-end

== Performance/FixedSize

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| No
| 0.35
| -
|===

Do not compute the size of statically sized objects.

=== Examples

[source,ruby]
----
# String methods
# bad
'foo'.size
%q[bar].count
%(qux).length

# Symbol methods
# bad
:fred.size
:'baz'.length

# Array methods
# bad
[1, 2, thud].count
%W(1, 2, bar).size

# Hash methods
# bad
{ a: corge, b: grault }.length

# good
foo.size
bar.count
qux.length

# good
:""#{fred}"".size
CONST = :baz.length

# good
[1, 2, *thud].count
garply = [1, 2, 3]
garply.size

# good
{ a: corge, **grault }.length
waldo = { a: corge, b: grault }
waldo.size
----

== Performance/FlatMap

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.30
| -
|===

This cop is used to identify usages of `map { ... }.flatten` and
change them to use `flat_map { ... }` instead.

=== Examples

[source,ruby]
----
# bad
[1, 2, 3, 4].map { |e| [e, e] }.flatten(1)
[1, 2, 3, 4].collect { |e| [e, e] }.flatten(1)

# good
[1, 2, 3, 4].flat_map { |e| [e, e] }
[1, 2, 3, 4].map { |e| [e, e] }.flatten
[1, 2, 3, 4].collect { |e| [e, e] }.flatten
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| EnabledForFlattenWithoutParams
| `false`
| Boolean
|===

=== References

* https://github.com/JuanitoFatas/fast-ruby#enumerablemaparrayflatten-vs-enumerableflat_map-code

== Performance/InefficientHashSearch

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| No
| Yes (Unsafe)
| 0.56
| -
|===

This cop checks for inefficient searching of keys and values within
hashes.

`Hash#keys.include?` is less efficient than `Hash#key?` because
the former allocates a new array and then performs an O(n) search
through that array, while `Hash#key?` does not allocate any array and
performs a faster O(1) search for the key.

`Hash#values.include?` is less efficient than `Hash#value?`. While they
both perform an O(n) search through all of the values, calling `values`
allocates a new array while using `value?` does not.

=== Safety

This cop is unsafe because it can't tell whether the receiver is a hash object.

=== Examples

[source,ruby]
----
# bad
{ a: 1, b: 2 }.keys.include?(:a)
{ a: 1, b: 2 }.keys.include?(:z)
h = { a: 1, b: 2 }; h.keys.include?(100)

# good
{ a: 1, b: 2 }.key?(:a)
{ a: 1, b: 2 }.has_key?(:z)
h = { a: 1, b: 2 }; h.key?(100)

# bad
{ a: 1, b: 2 }.values.include?(2)
{ a: 1, b: 2 }.values.include?('garbage')
h = { a: 1, b: 2 }; h.values.include?(nil)

# good
{ a: 1, b: 2 }.value?(2)
{ a: 1, b: 2 }.has_value?('garbage')
h = { a: 1, b: 2 }; h.value?(nil)
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#hashkey-instead-of-hashkeysinclude-code

== Performance/IoReadlines

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Disabled
| Yes
| Yes
| 1.7
| -
|===

This cop identifies places where inefficient `readlines` method
can be replaced by `each_line` to avoid fully loading file content into memory.

=== Examples

[source,ruby]
----
# bad
File.readlines('testfile').each { |l| puts l }
IO.readlines('testfile', chomp: true).each { |l| puts l }

conn.readlines(10).map { |l| l.size }
file.readlines.find { |l| l.start_with?('#') }
file.readlines.each { |l| puts l }

# good
File.open('testfile', 'r').each_line { |l| puts l }
IO.open('testfile').each_line(chomp: true) { |l| puts l }

conn.each_line(10).map { |l| l.size }
file.each_line.find { |l| l.start_with?('#') }
file.each_line { |l| puts l }
----

=== References

* https://docs.gitlab.com/ee/development/performance.html#reading-from-files-and-other-data-sources

== Performance/MapCompact

NOTE: Required Ruby version: 2.7

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes (Unsafe)
| 1.11
| -
|===

In Ruby 2.7, `Enumerable#filter_map` has been added.

This cop identifies places where `map { ... }.compact` can be replaced by `filter_map`.

[source,ruby]
----
[true, false, nil].compact              #=> [true, false]
[true, false, nil].filter_map(&:itself) #=> [true]
----

=== Safety

This cop's autocorrection is unsafe because `map { ... }.compact` that is not
compatible with `filter_map`.

=== Examples

[source,ruby]
----
# bad
ary.map(&:foo).compact
ary.collect(&:foo).compact

# good
ary.filter_map(&:foo)
ary.map(&:foo).compact!
ary.compact.map(&:foo)
----

== Performance/MethodObjectAsBlock

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| No
| 1.9
| -
|===

This cop identifies places where methods are converted to blocks, with the
use of `&method`, and passed as arguments to method calls.
It is faster to replace those with explicit blocks, calling those methods inside.

=== Examples

[source,ruby]
----
# bad
array.map(&method(:do_something))
[1, 2, 3].each(&out.method(:puts))

# good
array.map { |x| do_something(x) }
[1, 2, 3].each { |x| out.puts(x) }
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#normal-way-to-apply-method-vs-method-code

== Performance/OpenStruct

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Disabled
| No
| No
| 0.61
| -
|===

This cop checks for `OpenStruct.new` calls.
Instantiation of an `OpenStruct` invalidates
Ruby global method cache as it causes dynamic method
definition during program runtime.
This could have an effect on performance,
especially in case of single-threaded
applications with multiple `OpenStruct` instantiations.

=== Safety

This cop is unsafe because `OpenStruct.new` and `Struct.new`
are not equivalent.

=== Examples

[source,ruby]
----
# bad
class MyClass
  def my_method
    OpenStruct.new(my_key1: 'my_value1', my_key2: 'my_value2')
  end
end

# good
class MyClass
  MyStruct = Struct.new(:my_key1, :my_key2)
  def my_method
    MyStruct.new('my_value1', 'my_value2')
  end
end
----

== Performance/RangeInclude

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| No
| Yes (Unsafe)
| 0.36
| 1.7
|===

This cop identifies uses of `Range#include?` and `Range#member?`, which iterates over each
item in a `Range` to see if a specified item is there. In contrast,
`Range#cover?` simply compares the target item with the beginning and
end points of the `Range`. In a great majority of cases, this is what
is wanted.

=== Safety

This cop is unsafe because `Range#include?` (or `Range#member?`) and `Range#cover?`
are not equivalent behaviour.

=== Examples

[source,ruby]
----
# bad
('a'..'z').include?('b') # => true
('a'..'z').member?('b')  # => true

# good
('a'..'z').cover?('b') # => true

# Example of a case where `Range#cover?` may not provide
# the desired result:

('a'..'z').cover?('yellow') # => true
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#cover-vs-include-code

== Performance/RedundantBlockCall

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.36
| -
|===

This cop identifies the use of a `&block` parameter and `block.call`
where `yield` would do just as well.

=== Examples

[source,ruby]
----
# bad
def method(&block)
  block.call
end
def another(&func)
  func.call 1, 2, 3
end

# good
def method
  yield
end
def another
  yield 1, 2, 3
end
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#proccall-and-block-arguments-vs-yieldcode

== Performance/RedundantEqualityComparisonBlock

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| No
| Yes (Unsafe)
| 1.10
| -
|===

This cop checks for uses `Enumerable#all?`, `Enumerable#any?`, `Enumerable#one?`,
and `Enumerable#none?` are compared with `===` or similar methods in block.

By default, `Object#===` behaves the same as `Object#==`, but this
behavior is appropriately overridden in subclass. For example,
`Range#===` returns `true` when argument is within the range.

=== Safety

This cop is unsafe because `===` and `==` do not always behave the same.

=== Examples

[source,ruby]
----
# bad
items.all? { |item| pattern === item }
items.all? { |item| item == other }
items.all? { |item| item.is_a?(Klass) }
items.all? { |item| item.kind_of?(Klass) }

# good
items.all?(pattern)
----

=== References

* https://github.com/rails/rails/pull/41363

== Performance/RedundantMatch

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.36
| -
|===

This cop identifies the use of `Regexp#match` or `String#match`, which
returns `#<MatchData>`/`nil`. The return value of `=~` is an integral
index/`nil` and is more performant.

=== Examples

[source,ruby]
----
# bad
do_something if str.match(/regex/)
while regex.match('str')
  do_something
end

# good
method(str =~ /regex/)
return value unless regex =~ 'str'
----

== Performance/RedundantMerge

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| No
| Yes (Unsafe)
| 0.36
| 1.11
|===

This cop identifies places where `Hash#merge!` can be replaced by
`Hash#[]=`.
You can set the maximum number of key-value pairs to consider
an offense with `MaxKeyValuePairs`.

=== Safety

This cop is unsafe because RuboCop cannot determine if the
receiver of `merge!` is actually a hash or not.

=== Examples

[source,ruby]
----
# bad
hash.merge!(a: 1)
hash.merge!({'key' => 'value'})

# good
hash[:a] = 1
hash['key'] = 'value'
----

==== MaxKeyValuePairs: 2 (default)

[source,ruby]
----
# bad
hash.merge!(a: 1, b: 2)

# good
hash[:a] = 1
hash[:b] = 2
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| MaxKeyValuePairs
| `2`
| Integer
|===

=== References

* https://github.com/JuanitoFatas/fast-ruby#hashmerge-vs-hash-code

== Performance/RedundantSortBlock

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.7
| -
|===

This cop identifies places where `sort { |a, b| a <=> b }`
can be replaced with `sort`.

=== Examples

[source,ruby]
----
# bad
array.sort { |a, b| a <=> b }

# good
array.sort
----

== Performance/RedundantSplitRegexpArgument

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.10
| -
|===

This cop identifies places where `split` argument can be replaced from
a deterministic regexp to a string.

=== Examples

[source,ruby]
----
# bad
'a,b,c'.split(/,/)

# good
'a,b,c'.split(',')
----

== Performance/RedundantStringChars

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.7
| -
|===

This cop checks for redundant `String#chars`.

=== Examples

[source,ruby]
----
# bad
str.chars[0..2]
str.chars.slice(0..2)

# good
str[0..2].chars

# bad
str.chars.first
str.chars.first(2)

# good
str[0]
str[0...2].chars

# bad
str.chars.take(2)
str.chars.length
str.chars.size
str.chars.empty?

# good
str[0...2].chars
str.length
str.size
str.empty?

# For example, if the receiver is a blank string, it will be incompatible.
# If a negative value is specified for the receiver, `nil` is returned.
str.chars.last    # Incompatible with `str[-1]`.
str.chars.last(2) # Incompatible with `str[-2..-1].chars`.
str.chars.drop(2) # Incompatible with `str[2..-1].chars`.
----

== Performance/RegexpMatch

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.47
| -
|===

In Ruby 2.4, `String#match?`, `Regexp#match?`, and `Symbol#match?`
have been added. The methods are faster than `match`.
Because the methods avoid creating a `MatchData` object or saving
backref.
So, when `MatchData` is not used, use `match?` instead of `match`.

=== Examples

[source,ruby]
----
# bad
def foo
  if x =~ /re/
    do_something
  end
end

# bad
def foo
  if x !~ /re/
    do_something
  end
end

# bad
def foo
  if x.match(/re/)
    do_something
  end
end

# bad
def foo
  if /re/ === x
    do_something
  end
end

# good
def foo
  if x.match?(/re/)
    do_something
  end
end

# good
def foo
  if !x.match?(/re/)
    do_something
  end
end

# good
def foo
  if x =~ /re/
    do_something(Regexp.last_match)
  end
end

# good
def foo
  if x.match(/re/)
    do_something($~)
  end
end

# good
def foo
  if /re/ === x
    do_something($~)
  end
end
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#regexp-vs-stringmatch-vs-string-vs-stringmatch-code-

== Performance/ReverseEach

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.30
| -
|===

This cop is used to identify usages of `reverse.each` and
change them to use `reverse_each` instead.

If the return value is used, it will not be detected because the result will be different.

[source,ruby]
----
[1, 2, 3].reverse.each {} #=> [3, 2, 1]
[1, 2, 3].reverse_each {} #=> [1, 2, 3]
----

=== Examples

[source,ruby]
----
# bad
items.reverse.each

# good
items.reverse_each
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#enumerablereverseeach-vs-enumerablereverse_each-code

== Performance/ReverseFirst

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.7
| -
|===

This cop identifies places where `reverse.first(n)` and `reverse.first`
can be replaced by `last(n).reverse` and `last`.

=== Examples

[source,ruby]
----
# bad
array.reverse.first(5)
array.reverse.first

# good
array.last(5).reverse
array.last
----

== Performance/SelectMap

NOTE: Required Ruby version: 2.7

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Disabled
| Yes
| No
| 1.11
| -
|===

In Ruby 2.7, `Enumerable#filter_map` has been added.

This cop identifies places where `select.map` can be replaced by `filter_map`.

=== Examples

[source,ruby]
----
# bad
ary.select(&:foo).map(&:bar)
ary.filter(&:foo).map(&:bar)

# good
ary.filter_map { |o| o.bar if o.foo }
----

== Performance/Size

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.30
| -
|===

This cop is used to identify usages of `count` on an
`Array` and `Hash` and change them to `size`.

TODO: Add advanced detection of variables that could
have been assigned to an array or a hash.

=== Examples

[source,ruby]
----
# bad
[1, 2, 3].count
(1..3).to_a.count
Array[*1..3].count
Array(1..3).count

# bad
{a: 1, b: 2, c: 3}.count
[[:foo, :bar], [1, 2]].to_h.count
Hash[*('a'..'z')].count
Hash(key: :value).count

# good
[1, 2, 3].size
(1..3).to_a.size
Array[*1..3].size
Array(1..3).size

# good
{a: 1, b: 2, c: 3}.size
[[:foo, :bar], [1, 2]].to_h.size
Hash[*('a'..'z')].size
Hash(key: :value).size

# good
[1, 2, 3].count { |e| e > 2 }
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#arraylength-vs-arraysize-vs-arraycount-code

== Performance/SortReverse

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.7
| -
|===

This cop identifies places where `sort { |a, b| b <=> a }`
can be replaced by a faster `sort.reverse`.

=== Examples

[source,ruby]
----
# bad
array.sort { |a, b| b <=> a }

# good
array.sort.reverse
----

== Performance/Squeeze

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.7
| -
|===

This cop identifies places where `gsub(/a+/, 'a')` and `gsub!(/a+/, 'a')`
can be replaced by `squeeze('a')` and `squeeze!('a')`.

The `squeeze('a')` method is faster than `gsub(/a+/, 'a')`.

=== Examples

[source,ruby]
----
# bad
str.gsub(/a+/, 'a')
str.gsub!(/a+/, 'a')

# good
str.squeeze('a')
str.squeeze!('a')
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#remove-extra-spaces-or-other-contiguous-characters-code

== Performance/StartWith

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes (Unsafe)
| 0.36
| 1.10
|===

This cop identifies unnecessary use of a regex where `String#start_with?` would suffice.

This cop has `SafeMultiline` configuration option that `true` by default because
`^start` is unsafe as it will behave incompatible with `start_with?`
for receiver is multiline string.

=== Safety

This will change to a new method call which isn't guaranteed to be on the
object. Switching these methods has to be done with knowledge of the types
of the variables which rubocop doesn't have.

=== Examples

[source,ruby]
----
# bad
'abc'.match?(/\\Aab/)
/\\Aab/.match?('abc')
'abc' =~ /\\Aab/
/\\Aab/ =~ 'abc'
'abc'.match(/\\Aab/)
/\\Aab/.match('abc')

# good
'abc'.start_with?('ab')
----

==== SafeMultiline: true (default)

[source,ruby]
----
# good
'abc'.match?(/^ab/)
/^ab/.match?('abc')
'abc' =~ /^ab/
/^ab/ =~ 'abc'
'abc'.match(/^ab/)
/^ab/.match('abc')
----

==== SafeMultiline: false

[source,ruby]
----
# bad
'abc'.match?(/^ab/)
/^ab/.match?('abc')
'abc' =~ /^ab/
/^ab/ =~ 'abc'
'abc'.match(/^ab/)
/^ab/.match('abc')
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| SafeMultiline
| `true`
| Boolean
|===

=== References

* https://github.com/JuanitoFatas/fast-ruby#stringmatch-vs-stringstart_withstringend_with-code-start-code-end

== Performance/StringIdentifierArgument

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.13
| -
|===

This cop identifies places where string identifier argument can be replaced
by symbol identifier argument.
It prevents the redundancy of the internal string-to-symbol conversion.

This cop targets methods that take identifier (e.g. method name) argument
and the following examples are parts of it.

=== Examples

[source,ruby]
----
# bad
send('do_something')
attr_accessor 'do_something'
instance_variable_get('@ivar')

# good
send(:do_something)
attr_accessor :do_something
instance_variable_get(:@ivar)
----

== Performance/StringInclude

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes (Unsafe)
| 1.7
| 1.12
|===

This cop identifies unnecessary use of a regex where
`String#include?` would suffice.

=== Safety

This cop's offenses are not safe to auto-correct if a receiver is nil.

=== Examples

[source,ruby]
----
# bad
'abc'.match?(/ab/)
/ab/.match?('abc')
'abc' =~ /ab/
/ab/ =~ 'abc'
'abc'.match(/ab/)
/ab/.match('abc')

# good
'abc'.include?('ab')
----

== Performance/StringReplacement

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.33
| -
|===

This cop identifies places where `gsub` can be replaced by
`tr` or `delete`.

=== Examples

[source,ruby]
----
# bad
'abc'.gsub('b', 'd')
'abc'.gsub('a', '')
'abc'.gsub(/a/, 'd')
'abc'.gsub!('a', 'd')

# good
'abc'.gsub(/.*/, 'a')
'abc'.gsub(/a+/, 'd')
'abc'.tr('b', 'd')
'a b c'.delete(' ')
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#stringgsub-vs-stringtr-code

== Performance/Sum

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes (Unsafe)
| 1.8
| 1.13
|===

This cop identifies places where custom code finding the sum of elements
in some Enumerable object can be replaced by `Enumerable#sum` method.

=== Safety

Auto-corrections are unproblematic wherever an initial value is provided explicitly:

[source,ruby]
----
[1, 2, 3].reduce(4, :+) # => 10
[1, 2, 3].sum(4) # => 10

[].reduce(4, :+) # => 4
[].sum(4) # => 4
----

This also holds true for non-numeric types which implement a `:+` method:

[source,ruby]
----
['l', 'o'].reduce('Hel', :+) # => ""Hello""
['l', 'o'].sum('Hel') # => ""Hello""
----

When no initial value is provided though, `Enumerable#reduce` will pick the first enumerated value
as initial value and successively add all following values to it, whereas
`Enumerable#sum` will set an initial value of `0` (`Integer`) which can lead to a `TypeError`:

[source,ruby]
----
[].reduce(:+) # => nil
[1, 2, 3].reduce(:+) # => 6
['H', 'e', 'l', 'l', 'o'].reduce(:+) # => ""Hello""

[].sum # => 0
[1, 2, 3].sum # => 6
['H', 'e', 'l', 'l', 'o'].sum # => in `+': String can't be coerced into Integer (TypeError)
----

=== Examples

==== OnlySumOrWithInitialValue: false (default)

[source,ruby]
----
# bad
[1, 2, 3].inject(:+)                        # Auto-corrections for cases without initial value are unsafe
[1, 2, 3].inject(&:+)                       # and will only be performed when using the `-A` option.
[1, 2, 3].reduce { |acc, elem| acc + elem } # They can be prohibited completely using `SafeAutoCorrect: true`.
[1, 2, 3].reduce(10, :+)
[1, 2, 3].map { |elem| elem ** 2 }.sum
[1, 2, 3].collect(&:count).sum(10)

# good
[1, 2, 3].sum
[1, 2, 3].sum(10)
[1, 2, 3].sum { |elem| elem ** 2 }
[1, 2, 3].sum(10, &:count)
----

==== OnlySumOrWithInitialValue: true

[source,ruby]
----
# bad
[1, 2, 3].reduce(10, :+)
[1, 2, 3].map { |elem| elem ** 2 }.sum
[1, 2, 3].collect(&:count).sum(10)

# good
[1, 2, 3].sum(10)
[1, 2, 3].sum { |elem| elem ** 2 }
[1, 2, 3].sum(10, &:count)
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| OnlySumOrWithInitialValue
| `false`
| Boolean
|===

=== References

* https://blog.bigbinary.com/2016/11/02/ruby-2-4-introduces-enumerable-sum.html

== Performance/TimesMap

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes (Unsafe)
| 0.36
| 1.13
|===

This cop checks for .times.map calls.
In most cases such calls can be replaced
with an explicit array creation.

=== Safety

This cop's autocorrection is unsafe because `Integer#times` does nothing if receiver is 0
or less. However, `Array.new` raises an error if argument is less than 0.

For example:

[source,ruby]
----
-1.times{}    # does nothing
Array.new(-1) # ArgumentError: negative array size
----

=== Examples

[source,ruby]
----
# bad
9.times.map do |i|
  i.to_s
end

# good
Array.new(9) do |i|
  i.to_s
end
----

== Performance/UnfreezeString

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes (Unsafe)
| 0.50
| 1.9
|===

In Ruby 2.3 or later, use unary plus operator to unfreeze a string
literal instead of `String#dup` and `String.new`.
Unary plus operator is faster than `String#dup`.

=== Safety

This cop's autocorrection is unsafe because `String.new` (without operator) is not
exactly the same as `+''`. These differ in encoding. `String.new.encoding` is always
`ASCII-8BIT`. However, `(+'').encoding` is the same as script encoding(e.g. `UTF-8`).
if you expect `ASCII-8BIT` encoding, disable this cop.

=== Examples

[source,ruby]
----
# bad
''.dup
""something"".dup
String.new
String.new('')
String.new('something')

# good
+'something'
+''
----

== Performance/UriDefaultParser

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.50
| -
|===

This cop identifies places where `URI::Parser.new`
can be replaced by `URI::DEFAULT_PARSER`.

=== Examples

[source,ruby]
----
# bad
URI::Parser.new

# good
URI::DEFAULT_PARSER
----
",12348,True,2990.713576939757,median
"[[streams]]
= Streams

[partintro]
--
In this section you will learn all about Streams and how to use them with Spring Cloud Data Flow.
--

[[spring-cloud-dataflow-stream-intro]]
== Introduction

In Spring Cloud Data Flow, a basic stream defines the ingestion of event data from a _source_ to a _sink_ that passes through any number of _processors_. Streams are composed of http://cloud.spring.io/spring-cloud-stream/[Spring Cloud Stream] applications and the deployment of stream definitions is done via the Data Flow Server (REST API). The xref:getting-started#getting-started[Getting Started] section shows you how to start the server and how to start and use the Spring Cloud Data Flow shell.

A high level DSL is used to create stream definitions. The DSL to define a stream that has an http source and a file sink (with no processors) is shown below

```
http | file
```
The DSL mimics UNIX pipes and filters syntax. Default values for ports and filenames are used in this example but can be overridden using `--` options, such as

```
http --server.port=8091 | file --directory=/tmp/httpdata/
```
To create these stream definitions you use the shell or make an HTTP POST request to the Spring Cloud Data Flow Server.  For more information on making HTTP request directly to the server, consult the <<api-guide, REST API Guide>>.

== Stream DSL

In the example above, we connected a source to a sink using the pipe symbol `|`. You can also pass properties to the source and sink configurations. The property names will depend on the individual app implementations, but as an example, the `http` source app exposes a `server.port` setting and it allows you to change the data ingestion port from the default value. To create the stream using port 8000, we would use
```
dataflow:> stream create --definition ""http --server.port=8000 | log"" --name myhttpstream
```
The shell provides tab completion for application properties and also the shell command `app info <appType>:<appName>` provides additional documentation for all the supported properties.

NOTE: Supported Stream <appType>'s are: source, processor, and sink

[[spring-cloud-dataflow-register-apps]]
== Register a Stream App

Register a Stream App with the App Registry using the Spring Cloud Data Flow Shell
`app register` command. You must provide a unique name, application type, and a URI that can be
resolved to the app artifact. For the type, specify ""source"", ""processor"", or ""sink"".
Here are a few examples:

```
dataflow:>app register --name mysource --type source --uri maven://com.example:mysource:0.0.1-SNAPSHOT

dataflow:>app register --name myprocessor --type processor --uri file:///Users/example/myprocessor-1.2.3.jar

dataflow:>app register --name mysink --type sink --uri http://example.com/mysink-2.0.1.jar
```

When providing a URI with the `maven` scheme, the format should conform to the following:

```
maven://<groupId>:<artifactId>[:<extension>[:<classifier>]]:<version>
```

For example, if you would like to register the snapshot versions of the `http` and `log`
applications built with the RabbitMQ binder, you could do the following:

```
dataflow:>app register --name http --type source --uri maven://org.springframework.cloud.stream.app:http-source-rabbit:1.2.1.BUILD-SNAPSHOT
dataflow:>app register --name log --type sink --uri maven://org.springframework.cloud.stream.app:log-sink-rabbit:1.2.1.BUILD-SNAPSHOT
```

If you would like to register multiple apps at one time, you can store them in a properties file
where the keys are formatted as `<type>.<name>` and the values are the URIs.

For example, if you would like to register the snapshot versions of the `http` and `log`
applications built with the RabbitMQ binder, you could have the following in a properties file [_eg: stream-apps.properties_]:

```
source.http=maven://org.springframework.cloud.stream.app:http-source-rabbit:1.2.1.BUILD-SNAPSHOT
sink.log=maven://org.springframework.cloud.stream.app:log-sink-rabbit:1.2.1.BUILD-SNAPSHOT
```

Then to import the apps in bulk, use the `app import` command and provide the location of the properties file via `--uri`:

```
dataflow:>app import --uri file:///<YOUR_FILE_LOCATION>/stream-apps.properties
```

For convenience, we have the static files with application-URIs (for both maven and docker) available 
for all the out-of-the-box stream and task/batch app-starters. You can point to this file and import
all the application-URIs in bulk. Otherwise, as explained in previous paragraphs, you can register them individually or have your own custom property file with only the required application-URIs in it. It is recommended, however, to have a ""focused"" list of desired application-URIs in a custom property file.

List of available Stream Application Starters:

[width=""100%"",frame=""topbot"",options=""header""]
|======================
|Artifact Type |Stable Release |SNAPSHOT Release

|RabbitMQ + Maven
|http://bit.ly/Bacon-RELEASE-stream-applications-rabbit-maven
|http://bit.ly/Bacon-BUILD-SNAPSHOT-stream-applications-rabbit-maven

|RabbitMQ + Docker
|http://bit.ly/Bacon-RELEASE-stream-applications-rabbit-docker
|N/A

|Kafka 0.9 + Maven
|http://bit.ly/Bacon-RELEASE-stream-applications-kafka-09-maven
|http://bit.ly/Bacon-BUILD-SNAPSHOT-stream-applications-kafka-09-maven

|Kafka 0.9 + Docker
|http://bit.ly/Bacon-RELEASE-stream-applications-kafka-09-docker
|N/A

|Kafka 0.10 + Maven
|http://bit.ly/Bacon-RELEASE-stream-applications-kafka-10-maven
|http://bit.ly/Bacon-BUILD-SNAPSHOT-stream-applications-kafka-10-maven

|Kafka 0.10 + Docker
|http://bit.ly/Bacon-RELEASE-stream-applications-kafka-10-docker
|N/A
|======================

List of available Task Application Starters:

[width=""100%"",frame=""topbot"",options=""header""]
|======================
|Artifact Type |Stable Release |SNAPSHOT Release

|Maven
|http://bit.ly/Belmont-GA-task-applications-maven
|http://bit.ly/Belmont-BUILD-SNAPSHOT-task-applications-maven

|Docker
|http://bit.ly/Belmont-GA-task-applications-docker
|N/A
|======================

You can find more information about the available task starters in the http://cloud.spring.io/spring-cloud-task-app-starters/[Task App Starters Project Page] and
related reference documentation.  For more information about the available stream starters look at the http://cloud.spring.io/spring-cloud-stream-app-starters/[Stream App Starters Project Page]
and related reference documentation.

As an example, if you would like to register all out-of-the-box stream applications built with the RabbitMQ binder in bulk, you can with
the following command.

```
dataflow:>app import --uri http://bit.ly/Bacon-RELEASE-stream-applications-rabbit-maven
```

You can also pass the `--local` option (which is `true` by default) to indicate whether the
properties file location should be resolved within the shell process itself. If the location should
be resolved from the Data Flow Server process, specify `--local false`.

[WARNING]
====
When using either `app register` or `app import`, if an app is already registered with
the provided name and type, it will not be overridden by default. If you would like to override the
pre-existing app coordinates, then include the `--force` option.

Note however that once downloaded, applications may be cached locally on the Data Flow server, based on the resource
location. If the resource location doesn't change (even though the actual resource _bytes_ may be different), then it
won't be re-downloaded. When using `maven://` resources on the other hand, using a constant location still may circumvent
caching (if using `-SNAPSHOT` versions).

Moreover, if a stream is already deployed and using some version of a registered app, then (forcibly) re-registering a
different app will have no effect until the stream is deployed anew.
====

[NOTE]
In some cases the Resource is resolved on the server side, whereas in others the
URI will be passed to a runtime container instance where it is resolved. Consult
the specific documentation of each Data Flow Server for more detail.

[[spring-cloud-dataflow-stream-app-whitelisting]]
=== Whitelisting application properties

Stream and Task applications are Spring Boot applications which are aware of many <<spring-cloud-dataflow-global-properties>>, e.g. `server.port` but also families of properties such as those with the prefix `spring.jmx` and `logging`.  When creating your own application it is desirable to whitelist properties so that the shell and the UI can display them first as primary properties when presenting options via TAB completion or in drop-down boxes.

To whitelist application properties create a file named `spring-configuration-metadata-whitelist.properties` in the `META-INF` resource directory.  There are two property keys that can be used inside this file. The first key is named `configuration-properties.classes`.  The value is a comma separated list of fully qualified `@ConfigurationProperty` class names.  The second key is `configuration-properties.names` whose value is a comma separated list of property names.  This can contain the full name of property, such as `server.port` or a partial name to whitelist a category of property names, e.g. `spring.jmx`.

The link:https://github.com/spring-cloud-stream-app-starters[Spring Cloud Stream application starters] are a good place to look for examples of usage.  Here is a simple example of the file sink's `spring-configuration-metadata-whitelist.properties` file

```
configuration-properties.classes=org.springframework.cloud.stream.app.file.sink.FileSinkProperties
```

If we also wanted to add `server.port` to be white listed, then it would look like this:

```
configuration-properties.classes=org.springframework.cloud.stream.app.file.sink.FileSinkProperties
configuration-properties.names=server.port
```

[IMPORTANT]
====
Make sure to add 'spring-boot-configuration-processor' as an optional dependency to generate configuration metadata file for the properties.

[source,xml]
----
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>
----
====


[[spring-cloud-dataflow-stream-app-metadata-artifact]]
=== Creating and using a dedicated metadata artifact
You can go a step further in the process of describing the main properties that your stream or task app supports by
creating a so-called metadata companion artifact. This simple jar file contains only the Spring boot JSON file about
configuration properties metadata, as well as the whitelisting file described in the previous section.

Here is the contents of such an artifact, for the canonical `log` sink:

[source, bash]
----
$ jar tvf log-sink-rabbit-1.2.1.BUILD-SNAPSHOT-metadata.jar
373848 META-INF/spring-configuration-metadata.json
   174 META-INF/spring-configuration-metadata-whitelist.properties
----

Note that the `spring-configuration-metadata.json` file is quite large. This is because it contains the concatenation of _all_ the properties that
are available at runtime to the `log` sink (some of them come from `spring-boot-actuator.jar`, some of them come from
`spring-boot-autoconfigure.jar`, even some more from `spring-cloud-starter-stream-sink-log.jar`, _etc._) Data Flow
always relies on all those properties, even when a companion artifact is not available, but here all have been merged
into a single file.

To help with that (as a matter of fact, you don't want to try to craft this giant JSON file by hand), you can use the
following plugin in your build:

[source, xml]
----
<plugin>
 	<groupId>org.springframework.cloud</groupId>
 	<artifactId>spring-cloud-app-starter-metadata-maven-plugin</artifactId>
 	<executions>
 		<execution>
 			<id>aggregate-metadata</id>
 			<phase>compile</phase>
 			<goals>
 				<goal>aggregate-metadata</goal>
 			</goals>
 		</execution>
 	</executions>
 </plugin>
----

NOTE: This plugin comes in _addition_ to the `spring-boot-configuration-processor` that creates the individual JSON files.
Be sure to configure the two!

The benefits of a companion artifact are manifold:

1. being way lighter (usually a few kilobytes, as opposed to megabytes for the actual app), they are quicker to download,
allowing quicker feedback when using _e.g._ `app info` or the Dashboard UI
2. as a consequence of the above, they can be used in resource constrained environments (such as PaaS) when metadata is
the only piece of information needed
3. finally, for environments that don't deal with boot uberjars directly (for example, Docker-based runtimes such as
Kubernetes or Mesos), this is the only way to provide metadata about the properties supported by the app.

Remember though, that this is entirely optional when dealing with uberjars. The uberjar itself _also_ includes the
metadata in it already.

==== Using the companion artifact
Once you have a companion artifact at hand, you need to make the system aware of it so that it can be used.

When registering a single app _via_ `app register`, you can use the optional `--metadata-uri` option in the shell, like so:

[source]
----
dataflow:>app register --name log --type sink
    --uri maven://org.springframework.cloud.stream.app:log-sink-kafka-10:1.2.1.BUILD-SNAPSHOT
    --metadata-uri=maven://org.springframework.cloud.stream.app:log-sink-kafka-10:jar:metadata:1.2.1.BUILD-SNAPSHOT
----

When registering several files using the `app import` command, the file should contain a `<type>.<name>.metadata` line
in addition to each `<type>.<name>` line. This is optional (_i.e._ if some apps have it but some others don't, that's fine).

Here is an example for a Dockerized app, where the metadata artifact is being hosted in a Maven repository (but retrieving
it _via_ `http://` or `file://` would be equally possible).

[source, properties]
----
...
source.http=docker:springcloudstream/http-source-rabbit:latest
source.http.metadata=maven://org.springframework.cloud.stream.app:http-source-rabbit:jar:metadata:1.2.1.BUILD-SNAPSHOT
...
----

[[custom-applications]]
== Creating custom applications

While there are out of the box source, processor, sink applications available, one can extend these applications or write a custom link:https://github.com/spring-cloud/spring-cloud-stream[Spring Cloud Stream] application.

The process of creating Spring Cloud Stream applications via Spring Initializr is detailed in the Spring Cloud Stream {spring-cloud-stream-docs}#_getting_started[documentation].
It is possible to include multiple binders to an application.
If doing so, refer the instructions in <<passing_producer_consumer_properties>> on how to configure them.

For supporting property whitelisting, Spring Cloud Stream applications running in Spring Cloud Data Flow may include the Spring Boot `configuration-processor` as an optional dependency, as in the following example.

[source,xml]
----
<dependencies>
  <!-- other dependencies -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
  </dependency>
</dependencies>

----

[NOTE]
====
Make sure that the `spring-boot-maven-plugin` is included in the POM. 
The plugin is necesary for creating the executable jar that will be registered with Spring Cloud Data Flow.
Spring Initialzr will include the plugin in the generated POM.
====

Once a custom application has been created, it can be registered as described in <<spring-cloud-dataflow-register-apps>>.


[[spring-cloud-dataflow-create-stream]]
== Creating a Stream

The Spring Cloud Data Flow Server exposes a full RESTful API for managing the lifecycle of stream definitions, but the easiest way to use is it is via the Spring Cloud Data Flow shell. Start the shell as described in the xref:getting-started#getting-started[Getting Started] section.

New streams are created by with the help of stream definitions. The definitions are built from a simple DSL. For example, let's walk through what happens if we execute the following shell command:

```
dataflow:> stream create --definition ""time | log"" --name ticktock
```
This defines a stream named `ticktock` based off the DSL expression `time | log`.  The DSL uses the ""pipe"" symbol `|`, to connect a source to a sink.

Then to deploy the stream execute the following shell command (or alternatively add the `--deploy` flag when creating the stream so that this step is not needed):

```
dataflow:> stream deploy --name ticktock
```
The Data Flow Server resolves `time` and `log` to maven coordinates and uses those to launch the `time` and `log` applications of the stream.

```
2016-06-01 09:41:21.728  INFO 79016 --- [nio-9393-exec-6] o.s.c.d.spi.local.LocalAppDeployer       : deploying app ticktock.log instance 0
   Logs will be in /var/folders/wn/8jxm_tbd1vj28c8vj37n900m0000gn/T/spring-cloud-dataflow-912434582726479179/ticktock-1464788481708/ticktock.log
2016-06-01 09:41:21.914  INFO 79016 --- [nio-9393-exec-6] o.s.c.d.spi.local.LocalAppDeployer       : deploying app ticktock.time instance 0
   Logs will be in /var/folders/wn/8jxm_tbd1vj28c8vj37n900m0000gn/T/spring-cloud-dataflow-912434582726479179/ticktock-1464788481910/ticktock.time
```

In this example, the time source simply sends the current time as a message each second, and the log sink outputs it using the logging framework.
You can tail the `stdout` log (which has an ""_<instance>"" suffix). The log files are located within the directory displayed in the Data Flow Server's log output, as shown above.

```
$ tail -f /var/folders/wn/8jxm_tbd1vj28c8vj37n900m0000gn/T/spring-cloud-dataflow-912434582726479179/ticktock-1464788481708/ticktock.log/stdout_0.log
2016-06-01 09:45:11.250  INFO 79194 --- [  kafka-binder-] log.sink    : 06/01/16 09:45:11
2016-06-01 09:45:12.250  INFO 79194 --- [  kafka-binder-] log.sink    : 06/01/16 09:45:12
2016-06-01 09:45:13.251  INFO 79194 --- [  kafka-binder-] log.sink    : 06/01/16 09:45:13
```
=== Application properties

Application properties are the properties associated with each application in the stream. When the application is deployed, the application properties are applied to the application via
command line arguments or environment variables based on the underlying deployment implementation.

==== Passing application properties when creating a stream

The following stream

[source,bash]
----
dataflow:> stream create --definition ""time | log"" --name ticktock
----

can have application properties defined at the time of stream creation.

The shell command `app info <appType>:<appName>` displays the white-listed application properties for the application.
For more info on the property white listing refer to <<spring-cloud-dataflow-stream-app-whitelisting>>

Below are the white listed properties for the app `time`:

[source,bash]
----
dataflow:> app info source:time
╔══════════════════════════════╤══════════════════════════════╤══════════════════════════════╤══════════════════════════════╗
║         Option Name          │         Description          │           Default            │             Type             ║
╠══════════════════════════════╪══════════════════════════════╪══════════════════════════════╪══════════════════════════════╣
║trigger.time-unit             │The TimeUnit to apply to delay│<none>                        │java.util.concurrent.TimeUnit ║
║                              │values.                       │                              │                              ║
║trigger.fixed-delay           │Fixed delay for periodic      │1                             │java.lang.Integer             ║
║                              │triggers.                     │                              │                              ║
║trigger.cron                  │Cron expression value for the │<none>                        │java.lang.String              ║
║                              │Cron Trigger.                 │                              │                              ║
║trigger.initial-delay         │Initial delay for periodic    │0                             │java.lang.Integer             ║
║                              │triggers.                     │                              │                              ║
║trigger.max-messages          │Maximum messages per poll, -1 │1                             │java.lang.Long                ║
║                              │means infinity.               │                              │                              ║
║trigger.date-format           │Format for the date value.    │<none>                        │java.lang.String              ║
╚══════════════════════════════╧══════════════════════════════╧══════════════════════════════╧══════════════════════════════╝
----

Below are the white listed properties for the app `log`:

[source,bash]
----
dataflow:> app info sink:log
╔══════════════════════════════╤══════════════════════════════╤══════════════════════════════╤══════════════════════════════╗
║         Option Name          │         Description          │           Default            │             Type             ║
╠══════════════════════════════╪══════════════════════════════╪══════════════════════════════╪══════════════════════════════╣
║log.name                      │The name of the logger to use.│<none>                        │java.lang.String              ║
║log.level                     │The level at which to log     │<none>                        │org.springframework.integratio║
║                              │messages.                     │                              │n.handler.LoggingHandler$Level║
║log.expression                │A SpEL expression (against the│payload                       │java.lang.String              ║
║                              │incoming message) to evaluate │                              │                              ║
║                              │as the logged message.        │                              │                              ║
╚══════════════════════════════╧══════════════════════════════╧══════════════════════════════╧══════════════════════════════╝
----

The application properties for the `time` and `log` apps can be specified at the time of `stream` creation as follows:

[source,bash]
----
dataflow:> stream create --definition ""time --fixed-delay=5 | log --level=WARN"" --name ticktock
----

Note that the properties `fixed-delay` and `level` defined above for the apps `time` and `log` are the 'short-form' property names provided by the shell completion.
These 'short-form' property names are applicable only for the white-listed properties and in all other cases, only _fully qualified_ property names should be used.

=== Deployment properties

When deploying the stream, properties that control the deployment of the apps into the target platform are known as `deployment` properties.
For instance, one can specify how many instances need to be deployed for the specific application defined in the stream using the deployment property called `count`.

==== Application properties versus Deployer properties

Starting with version 1.2, the distinction between properties that are meant for the _deployed app_ and properties that
govern _how_ this app is deployed (thanks to some implementation of a
https://github.com/spring-cloud/spring-cloud-deployer/[spring cloud deployer]) is more explicit. The former should be
passed using the syntax `app.<app-name>.<property-name>=<value>` while the latter use the
`deployer.<app-name>.<short-property-name>=<value>`

The following table recaps the difference in behavior between the two.

|===
| | Application Properties | Deployer Properties

| *Example Syntax*
| `app.filter.expression=foo`
| `deployer.filter.count=3`

| *What the application ""sees""*
| `expression=foo` or `<some-prefix>.expression=foo` if `expression` is one of the whitelisted properties
| Nothing

| *What the deployer ""sees""*
| Nothing
| `spring.cloud.deployer.count=3` The `spring.cloud.deployer` prefix is automatically and always prepended to the property name

| *Typical usage*
| Passing/Overriding application properties, passing Spring Cloud Stream binder or partitionning properties
| Setting the number of instances, memory, disk, etc.

|===


==== Passing instance count as deployment property

If you would like to have multiple instances of an application in the stream, you
can include a deployer property with the deploy command:

[source,bash,subs=attributes]
----
dataflow:> stream deploy --name ticktock --properties ""deployer.time.count=3""
----

Note that `count` is the *reserved* property name used by the underlying deployer. Hence, if the application also has a custom property named `count`, it is *not* supported
 when specified in 'short-form' form during stream _deployment_ as it could conflict with the _instance_ count deployer property. Instead, the `count` as a custom application property can be
 specified in its _fully qualified_ form (example: `app.foo.bar.count`) during stream _deployment_ or it can be specified using 'short-form' or _fully qualified_ form during the stream _creation_
 where it will be considered as an app property.

IMPORTANT: See <<spring-cloud-dataflow-stream-app-labels>>.

==== Inline vs file reference properties

When using the Spring Cloud Data Flow Shell, there are two ways to provide deployment
properties: either *inline* or via a *file reference*. Those two ways are exclusive
and documented below:

*Inline properties*::

  use the `--properties` shell option and list properties as a comma separated
  list of key=value pairs, like so:

[source,bash]
----
stream deploy foo
    --properties ""deployer.transform.count=2,app.transform.producer.partitionKeyExpression=payload""
----

*Using a file reference*::

  use the `--propertiesFile` option and point it to a local `.properties`, `.yaml` or `.yml` file
  (i.e. that lives in the filesystem of the machine running the shell). Being read
  as a `.properties` file, normal rules apply (ISO 8859-1 encoding, `=`, `<space>` or
  `:` delimiter, etc.) although we recommend using `=` as a key-value pair delimiter
  for consistency:

[source,bash]
----
stream deploy foo --propertiesFile myprops.properties
----

where `myprops.properties` contains:

```
deployer.transform.count=2
app.transform.producer.partitionKeyExpression=payload
```

Both the above properties will be passed as deployment properties for the stream `foo` above.

In case of using YAML as the format for the deployment properties, use the `.yaml` or `.yml` file extention when deploying the stream,

[source,bash]
----
stream deploy foo --propertiesFile myprops.yaml
----

where `myprops.yaml` contains:

```
deployer:
  transform:
    count: 2
app:
  transform:
    producer:
      partitionKeyExpression: payload
```

==== Passing application properties when deploying a stream

The application properties can also be specified when deploying a stream. When specified during deployment, these application properties can either be specified as
 'short-form' property names (applicable for white-listed properties) or _fully qualified_ property names. The application properties should have the prefix ""app.<appName/label>"".

For example, the stream

[source,bash]
----
dataflow:> stream create --definition ""time | log"" --name ticktock
----

can be deployed with application properties using the 'short-form' property names:

[source,bash]
----
dataflow:>stream deploy ticktock --properties ""app.time.fixed-delay=5,app.log.level=ERROR""
----

When using the app label,

[source,bash]
----
stream create ticktock --definition ""a: time | b: log""
----

the application properties can be defined as:

[source,bash]
----
stream deploy ticktock --properties ""app.a.fixed-delay=4,app.b.level=ERROR""
----

[[passing_producer_consumer_properties]]
==== Passing Spring Cloud Stream properties for the application
Spring Cloud Data Flow sets the `required` Spring Cloud Stream properties for the applications inside the stream. Most importantly, the `spring.cloud.stream.bindings.<input/output>.destination` is set internally for the apps to bind.

If someone wants to override any of the Spring Cloud Stream properties, they can be set via deployment properties.

For example, for the below stream

[source,bash]
----
dataflow:> stream create --definition ""http | transform --expression=payload.getValue('hello').toUpperCase() | log"" --name ticktock
----

if there are multiple binders available in the classpath for each of the applications and the binder is chosen for each deployment then the stream can be deployed with the specific Spring Cloud Stream properties as:

[source,bash]
----
dataflow:>stream deploy ticktock --properties ""app.time.spring.cloud.stream.bindings.output.binder=kafka,app.transform.spring.cloud.stream.bindings.input.binder=kafka,app.transform.spring.cloud.stream.bindings.output.binder=rabbit,app.log.spring.cloud.stream.bindings.input.binder=rabbit""
----

NOTE: Overriding the destination names is not recommended as Spring Cloud Data Flow takes care of setting this internally.

==== Passing per-binding producer consumer properties
A Spring Cloud Stream application can have producer and consumer properties set `per-binding` basis.
While Spring Cloud Data Flow supports specifying short-hand notation for per binding producer properties such as `partitionKeyExpression`, `partitionKeyExtractorClass` as described in <<passing_stream_partition_properties>>, all the supported Spring Cloud Stream producer/consumer properties can be set as Spring Cloud Stream properties for the app directly as well.

The consumer properties can be set for the `inbound` channel name with the prefix `app.[app/label name].spring.cloud.stream.bindings.<channelName>.consumer.` and the producer properties can be set for the `outbound` channel name with the prefix `app.[app/label name].spring.cloud.stream.bindings.<channelName>.producer.`.
For example, the stream

[source,bash]
----
dataflow:> stream create --definition ""time | log"" --name ticktock
----

can be deployed with producer/consumer properties as:

[source,bash]
----
dataflow:>stream deploy ticktock --properties ""app.time.spring.cloud.stream.bindings.output.producer.requiredGroups=myGroup,app.time.spring.cloud.stream.bindings.output.producer.headerMode=raw,app.log.spring.cloud.stream.bindings.input.consumer.concurrency=3,app.log.spring.cloud.stream.bindings.input.consumer.maxAttempts=5""
----

The `binder` specific producer/consumer properties can also be specified in a similar way.

For instance

[source,bash]
----
dataflow:>stream deploy ticktock --properties ""app.time.spring.cloud.stream.rabbit.bindings.output.producer.autoBindDlq=true,app.log.spring.cloud.stream.rabbit.bindings.input.consumer.transacted=true""
----

[[passing_stream_partition_properties]]
==== Passing stream partition properties during stream deployment
A common pattern in stream processing is to partition the data as it is streamed.
This entails deploying multiple instances of a message consuming app and using
content-based routing so that messages with a given key (as determined at runtime)
are always routed to the same app instance. You can pass the partition properties during
stream deployment to declaratively configure a partitioning strategy to route each
message to a specific consumer instance.

See below for examples of deploying partitioned streams:

*app.[app/label name].producer.partitionKeyExtractorClass*::
  The class name of a PartitionKeyExtractorStrategy (default `null`)

*app.[app/label name].producer.partitionKeyExpression*::
  A SpEL expression, evaluated against the message, to determine the partition key;
  only applies if `partitionKeyExtractorClass` is null. If both are null, the app
  is not partitioned (default `null`)

*app.[app/label name].producer.partitionSelectorClass*::
  The class name of a PartitionSelectorStrategy (default `null`)

*app.[app/label name].producer.partitionSelectorExpression*::
  A SpEL expression, evaluated against the partition key, to determine the partition
  index to which the message will be routed. The final partition index will be the
  return value (an integer) modulo `[nextModule].count`. If both the class and
  expression are null, the underlying binder's default PartitionSelectorStrategy
  will be applied to the key (default `null`)

In summary, an app is partitioned if its count is > 1 and the previous app has a
`partitionKeyExtractorClass` or `partitionKeyExpression` (class takes precedence).
When a partition key is extracted, the partitioned app instance is determined by
invoking the `partitionSelectorClass`, if present, or the `partitionSelectorExpression % partitionCount`,
where `partitionCount` is application count in the case of RabbitMQ, and the underlying
partition count of the topic in the case of Kafka.

If neither a `partitionSelectorClass` nor a `partitionSelectorExpression` is
present the result is `key.hashCode() % partitionCount`.

[[passing_content_type_properties]]
==== Passing application content type properties
In a stream definition you can specify that the input or the output of an application need to be converted to a different type.
You can use the `inputType` and `outputType` properties to specify the content type for the incoming data and outgoing data, respectively.

For example, consider the following stream:

```
dataflow:>stream create tuple --definition ""http | filter --inputType=application/x-spring-tuple
 --expression=payload.hasFieldName('hello') | transform --expression=payload.getValue('hello').toUpperCase()
 | log"" --deploy
```

The `http` app is expected to send the data in JSON and the `filter` app receives the JSON data
and processes it as a Spring Tuple.
In order to do so, we use the `inputType` property on the filter app to convert the data into the expected Spring Tuple format.
The `transform` application processes the Tuple data and sends the processed data to the downstream `log` application.

When sending some data to the `http` application:

```
dataflow:>http post --data {""hello"":""world"",""foo"":""bar""} --contentType application/json --target http://localhost:<http-port>
```

At the log application you see the content as follows:

```
INFO 18745 --- [transform.tuple-1] log.sink                                 : WORLD
```

Depending on how applications are chained, the content type conversion can be specified either as via the `--outputType` in the upstream app or as an `--inputType` in the downstream app.
For instance, in the above stream, instead of specifying the `--inputType` on the 'transform' application to convert, the option `--outputType=application/x-spring-tuple` can also be specified on the 'http' application.

For the complete list of message conversion and message converters, please refer to Spring Cloud Stream {spring-cloud-stream-docs}#contenttypemanagement[documentation].

==== Overriding application properties during stream deployment

Application properties that are defined during deployment override the same properties defined during the stream creation.

For example, the following stream has application properties defined during stream creation:

[source,bash]
----
dataflow:> stream create --definition ""time --fixed-delay=5 | log --level=WARN"" --name ticktock
----

To override these application properties, one can specify the new property values during deployment:

[source,bash]
----
dataflow:>stream deploy ticktock --properties ""app.time.fixed-delay=4,app.log.level=ERROR""
----

[[spring-cloud-dataflow-global-properties]]
=== Common application properties

In addition to configuration via DSL, Spring Cloud Data Flow provides a mechanism for setting common properties to all
the streaming applications that are launched by it.
This can be done by adding properties prefixed with `spring.cloud.dataflow.applicationProperties.stream` when starting
the server.
When doing so, the server will pass all the properties, without the prefix, to the instances it launches.

For example, all the launched applications can be configured to use a specific Kafka broker by launching the
Data Flow server with the following options:

```
--spring.cloud.dataflow.applicationProperties.stream.spring.cloud.stream.kafka.binder.brokers=192.168.1.100:9092
--spring.cloud.dataflow.applicationProperties.stream.spring.cloud.stream.kafka.binder.zkNodes=192.168.1.100:2181
```

This will cause the properties `spring.cloud.stream.kafka.binder.brokers` and `spring.cloud.stream.kafka.binder.zkNodes`
to be passed to all the launched applications.

[NOTE]
Properties configured using this mechanism have lower precedence than stream deployment properties.
They will be overridden if a property with the same key is specified at stream deployment time (e.g.
`app.http.spring.cloud.stream.kafka.binder.brokers` will override the common property).

[[spring-cloud-dataflow-destroy-stream]]
== Destroying a Stream

You can delete a stream by issuing the `stream destroy` command from the shell:

```
dataflow:> stream destroy --name ticktock
```

If the stream was deployed, it will be undeployed before the stream definition is deleted.

[[spring-cloud-dataflow-deploy-undeploy-stream]]
== Deploying and Undeploying Streams

Often you will want to stop a stream, but retain the name and definition for future use. In that case you can `undeploy` the stream by name and issue the `deploy` command at a later time to restart it.
```
dataflow:> stream undeploy --name ticktock
dataflow:> stream deploy --name ticktock
```

[[spring-cloud-dataflow-stream-app-types]]
== Other Source and Sink Application Types

Let's try something a bit more complicated and swap out the `time` source for something else. Another supported source type is `http`, which accepts data for ingestion over HTTP POSTs. Note that the `http` source accepts data on a different port from the Data Flow Server (default 8080). By default the port is randomly assigned.

To create a stream using an `http` source, but still using the same `log` sink, we would change the original command above to

```
dataflow:> stream create --definition ""http | log"" --name myhttpstream --deploy
```
which will produce the following output from the server

```
2016-06-01 09:47:58.920  INFO 79016 --- [io-9393-exec-10] o.s.c.d.spi.local.LocalAppDeployer       : deploying app myhttpstream.log instance 0
   Logs will be in /var/folders/wn/8jxm_tbd1vj28c8vj37n900m0000gn/T/spring-cloud-dataflow-912434582726479179/myhttpstream-1464788878747/myhttpstream.log
2016-06-01 09:48:06.396  INFO 79016 --- [io-9393-exec-10] o.s.c.d.spi.local.LocalAppDeployer       : deploying app myhttpstream.http instance 0
   Logs will be in /var/folders/wn/8jxm_tbd1vj28c8vj37n900m0000gn/T/spring-cloud-dataflow-912434582726479179/myhttpstream-1464788886383/myhttpstream.http
```

Note that we don't see any other output this time until we actually post some data (using a shell command). In order to see the randomly assigned port on which the http source is listening, execute:

```
dataflow:> runtime apps
```
You should see that the corresponding http source has a `url` property containing the host and port information on which it is listening. You are now ready to post to that url, e.g.:
```
dataflow:> http post --target http://localhost:1234 --data ""hello""
dataflow:> http post --target http://localhost:1234 --data ""goodbye""
```
and the stream will then funnel the data from the http source to the output log implemented by the log sink

```
2016-06-01 09:50:22.121  INFO 79654 --- [  kafka-binder-] log.sink    : hello
2016-06-01 09:50:26.810  INFO 79654 --- [  kafka-binder-] log.sink    : goodbye
```

Of course, we could also change the sink implementation. You could pipe the output to a file (`file`), to hadoop (`hdfs`) or to any of the other sink apps which are available. You can also define your own apps.

[[spring-cloud-dataflow-simple-stream]]
== Simple Stream Processing

As an example of a simple processing step, we can transform the payload of the HTTP posted data to upper case using the stream definitions
```
http | transform --expression=payload.toUpperCase() | log
```
To create this stream enter the following command in the shell
```
dataflow:> stream create --definition ""http | transform --expression=payload.toUpperCase() | log"" --name mystream --deploy
```
Posting some data (using a shell command)
```
dataflow:> http post --target http://localhost:1234 --data ""hello""
```
Will result in an uppercased 'HELLO' in the log

```
2016-06-01 09:54:37.749  INFO 80083 --- [  kafka-binder-] log.sink    : HELLO
```

[[spring-cloud-dataflow-stream-partitions]]
== Stateful Stream Processing

To demonstrate the data partitioning functionality, let's deploy the following stream with Kafka as the binder.

```
dataflow:>stream create --name words --definition ""http --server.port=9900 | splitter --expression=payload.split(' ') | log""
Created new stream 'words'

dataflow:>stream deploy words --properties ""app.splitter.producer.partitionKeyExpression=payload,deployer.log.count=2""
Deployed stream 'words'

dataflow:>http post --target http://localhost:9900 --data ""How much wood would a woodchuck chuck if a woodchuck could chuck wood""
> POST (text/plain;Charset=UTF-8) http://localhost:9900 How much wood would a woodchuck chuck if a woodchuck could chuck wood
> 202 ACCEPTED
```

You'll see the following in the server logs.

```
2016-06-05 18:33:24.982  INFO 58039 --- [nio-9393-exec-9] o.s.c.d.spi.local.LocalAppDeployer       : deploying app words.log instance 0
   Logs will be in /var/folders/c3/ctx7_rns6x30tq7rb76wzqwr0000gp/T/spring-cloud-dataflow-694182453710731989/words-1465176804970/words.log
2016-06-05 18:33:24.988  INFO 58039 --- [nio-9393-exec-9] o.s.c.d.spi.local.LocalAppDeployer       : deploying app words.log instance 1
   Logs will be in /var/folders/c3/ctx7_rns6x30tq7rb76wzqwr0000gp/T/spring-cloud-dataflow-694182453710731989/words-1465176804970/words.log
```

Review the `words.log instance 0` logs:

```
2016-06-05 18:35:47.047  INFO 58638 --- [  kafka-binder-] log.sink                                 : How
2016-06-05 18:35:47.066  INFO 58638 --- [  kafka-binder-] log.sink                                 : chuck
2016-06-05 18:35:47.066  INFO 58638 --- [  kafka-binder-] log.sink                                 : chuck
```

Review the `words.log instance 1` logs:

```
2016-06-05 18:35:47.047  INFO 58639 --- [  kafka-binder-] log.sink                                 : much
2016-06-05 18:35:47.066  INFO 58639 --- [  kafka-binder-] log.sink                                 : wood
2016-06-05 18:35:47.066  INFO 58639 --- [  kafka-binder-] log.sink                                 : would
2016-06-05 18:35:47.066  INFO 58639 --- [  kafka-binder-] log.sink                                 : a
2016-06-05 18:35:47.066  INFO 58639 --- [  kafka-binder-] log.sink                                 : woodchuck
2016-06-05 18:35:47.067  INFO 58639 --- [  kafka-binder-] log.sink                                 : if
2016-06-05 18:35:47.067  INFO 58639 --- [  kafka-binder-] log.sink                                 : a
2016-06-05 18:35:47.067  INFO 58639 --- [  kafka-binder-] log.sink                                 : woodchuck
2016-06-05 18:35:47.067  INFO 58639 --- [  kafka-binder-] log.sink                                 : could
2016-06-05 18:35:47.067  INFO 58639 --- [  kafka-binder-] log.sink                                 : wood
```

This shows that payload splits that contain the same word are routed to the same application instance.

[[spring-cloud-dataflow-stream-tap-dsl]]
== Tap a Stream

Taps can be created at various producer endpoints in a stream. For a stream like this:

```
stream create --definition ""http | step1: transform --expression=payload.toUpperCase() | step2: transform --expression=payload+'!' | log"" --name mainstream --deploy

```
taps can be created at the output of `http`, `step1` and `step2`.

To create a stream that acts as a 'tap' on another stream requires to specify the `source destination name` for the tap stream. The syntax for source destination name is:

```
`:<streamName>.<label/appName>`
```
To create a tap at the output of `http` in the stream above, the source destination name is `mainstream.http`
To create a tap at the output of the first transform app in the stream above, the source destination name is `mainstream.step1`

The tap stream DSL looks like this:

```
stream create --definition "":mainstream.http > counter"" --name tap_at_http --deploy

stream create --definition "":mainstream.step1 > jdbc"" --name tap_at_step1_transformer --deploy
```

Note the colon (:) prefix before the destination names. The colon allows the parser to recognize this as a destination name instead of an app name.

[[spring-cloud-dataflow-stream-app-labels]]
== Using Labels in a Stream

When a stream is comprised of multiple apps with the same name, they must be qualified with labels:
```
stream create --definition ""http | firstLabel: transform --expression=payload.toUpperCase() | secondLabel: transform --expression=payload+'!' | log"" --name myStreamWithLabels --deploy
```

[[spring-cloud-dataflow-stream-explicit-destination-names]]
== Explicit Broker Destinations in a Stream

One can connect to a specific destination name located in the broker (Rabbit, Kafka etc.,) either at the `source` or at the `sink` position.

The following stream has the destination name at the `source` position:

```
stream create --definition "":myDestination > log"" --name ingest_from_broker --deploy
```

This stream receives messages from the destination `myDestination` located at the broker and connects it to the `log` app.


The following stream has the destination name at the `sink` position:

```
stream create --definition ""http > :myDestination"" --name ingest_to_broker --deploy
```
This stream sends the messages from the `http` app to the destination `myDestination` located at the broker.

From the above streams, notice that the `http` and `log` apps are interacting with each other via the broker (through the destination `myDestination`) rather than having a pipe directly between `http` and `log` within a single stream.

It is also possible to connect two different destinations (`source` and `sink` positions) at the broker in a stream.

```
stream create --definition "":destination1 > :destination2"" --name bridge_destinations --deploy
```

In the above stream, both the destinations (`destination1` and `destination2`) are located in the broker. The messages flow from the source destination to the sink destination via a `bridge` app that connects them.

[[spring-cloud-dataflow-stream-advanced]]
== Directed Graphs in a Stream

If directed graphs are needed instead of the simple linear streams described above, two features are relevant.

First, named destinations may be used as a way to combine the output from multiple streams or for multiple consumers to share the output from a single stream.
This can be done using the DSL syntax `http > :mydestination` or `:mydestination > log`.

Second, you may need to determine the output channel of a stream based on some information that is only known at runtime.
In that case, a router may be used in the sink position of a stream definition. For more information, refer to the Router Sink starter's
link:https://github.com/spring-cloud-stream-app-starters/router/tree/master/spring-cloud-starter-stream-sink-router[README].

[[spring-cloud-dataflow-stream-multi-binder]]
== Stream applications with multiple binder configurations

In some cases, a stream can have its applications bound to multiple spring cloud stream binders when they are required to connect to different messaging
middleware configurations. In those cases, it is important to make sure the applications are configured appropriately with their binder
configurations. For example, let's consider the following stream:

```
http | transform --expression=payload.toUpperCase() | log
```

and in this stream, each application connects to messaging middleware in the following way:

```
Http source sends events to RabbitMQ (rabbit1)
Transform processor receives events from RabbitMQ (rabbit1) and sends the processed events into Kafka (kafka1)
Log sink receives events from Kafka (kafka1)
```
Here, `rabbit1` and `kafka1` are the binder names given in the spring cloud stream application properties.
Based on this setup, the applications will have the following binder(s) in their classpath with the appropriate configuration:

```
Http - Rabbit binder
Transform - Both Kafka and Rabbit binders
Log - Kafka binder
```
The spring-cloud-stream `binder` configuration properties can be set within the applications themselves.
If not, they can be passed via `deployment` properties when the stream is deployed.

For example,

```
dataflow:>stream create --definition ""http | transform --expression=payload.toUpperCase() | log"" --name mystream
```

```
dataflow:>stream deploy mystream --properties ""app.http.spring.cloud.stream.bindings.output.binder=rabbit1,app.transform.spring.cloud.stream.bindings.input.binder=rabbit1,
app.transform.spring.cloud.stream.bindings.output.binder=kafka1,app.log.spring.cloud.stream.bindings.input.binder=kafka1""
```

One can override any of the binder configuration properties by specifying them via deployment properties.
",12143,False,2101.393836683297,median
"---
title: ""Chapter 4. Installing Applications: Packages and Ports""
part: Part I. Getting Started
prev: books/handbook/basics
next: books/handbook/x11
description: ""FreeBSD provides two complementary technologies for installing third-party software: the FreeBSD Ports Collection, for installing from source, and packages, for installing from pre-built binaries""
tags: [""ports"", ""collection"", ""pkg"", ""poudriere"", ""management""]
showBookMenu: true
weight: 6
path: ""/books/handbook/""
---

[[ports]]
= Installing Applications: Packages and Ports
:doctype: book
:toc: macro
:toclevels: 1
:icons: font
:sectnums:
:sectnumlevels: 6
:sectnumoffset: 4
:partnums:
:source-highlighter: rouge
:experimental:
:images-path: books/handbook/ports/

ifdef::env-beastie[]
ifdef::backend-html5[]
:imagesdir: ../../../../images/{images-path}
endif::[]
ifndef::book[]
include::shared/authors.adoc[]
include::shared/mirrors.adoc[]
include::shared/releases.adoc[]
include::shared/attributes/attributes-{{% lang %}}.adoc[]
include::shared/{{% lang %}}/teams.adoc[]
include::shared/{{% lang %}}/mailing-lists.adoc[]
include::shared/{{% lang %}}/urls.adoc[]
toc::[]
endif::[]
ifdef::backend-pdf,backend-epub3[]
include::../../../../../shared/asciidoctor.adoc[]
endif::[]
endif::[]

ifndef::env-beastie[]
toc::[]
include::../../../../../shared/asciidoctor.adoc[]
endif::[]

[[ports-synopsis]]
== Synopsis

FreeBSD is bundled with a rich collection of system tools as part of the base system.
In addition, FreeBSD provides two complementary technologies for installing third-party software: the FreeBSD Ports Collection,
for installing from source, and packages, for installing from pre-built binaries.
Either method may be used to install software from local media or from the network.

After reading this chapter, you will know:

* The difference between binary packages and ports.
* How to find third-party software that has been ported to FreeBSD.
* How to manage binary packages using pkg.
* How to build third-party software from source using the Ports Collection.
* How to find the files installed with the application for post-installation configuration.
* What to do if a software installation fails.

[[ports-overview]]
== Overview of Software Installation

The typical steps for installing third-party software on a UNIX(R) system include:

[.procedure]
. Find and download the software, which might be distributed in source code format or as a binary.
. Unpack the software from its distribution format. This is typically a tarball compressed with a program such as man:compress[1], man:gzip[1], man:bzip2[1] or man:xz[1].
. Locate the documentation in [.filename]#INSTALL#, [.filename]#README# or some file in a [.filename]#doc/# subdirectory and read up on how to install the software.
. If the software was distributed in source format, compile it. This may involve editing a [.filename]#Makefile# or running a `configure` script.
. Test and install the software.

A FreeBSD _port_ is a collection of files designed to automate the process of compiling an application from source code.
The files that comprise a port contain all the necessary information to automatically download, extract, patch, compile, and install the application.

If the software has not already been adapted and tested on FreeBSD, the source code might need editing in order for it to install and run properly.

However, over link:https://www.FreeBSD.org/ports/[{numports}] third-party applications have already been ported to FreeBSD.
When feasible, these applications are made available for download as pre-compiled _packages_.

Packages can be manipulated with the FreeBSD package management commands.

Both packages and ports understand dependencies.
If a package or port is used to install an application and a dependent library is not already installed, the library will automatically be installed first.

A FreeBSD package contains pre-compiled copies of all the commands for an application, as well as any configuration files and documentation.
A package can be manipulated with the man:pkg[8] commands, such as `pkg install`.

While the two technologies are similar, packages and ports each have their own strengths.
Select the technology that meets your requirements for installing a particular application.

.Package Benefits
* A compressed package tarball is typically smaller than the compressed tarball containing the source code for the application.
* Packages do not require compilation time. For large applications, such as Mozilla, KDE, or GNOME, this can be important on a slow system.
* Packages do not require any understanding of the process involved in compiling software on FreeBSD.

.Port Benefits
* Packages are normally compiled with conservative options because they have to run on the maximum number of systems. By compiling from the port, one can change the compilation options.
* Some applications have compile-time options relating to which features are installed. For example, Apache can be configured with a wide variety of different built-in options.
+
In some cases, multiple packages will exist for the same application to specify certain settings. For example, Ghostscript is available as a [.filename]#ghostscript# package and a [.filename]#ghostscript-nox11# package, depending on whether or not Xorg is installed. Creating multiple packages rapidly becomes impossible if an application has more than one or two different compile-time options.
* The licensing conditions of some software forbid binary distribution. Such software must be distributed as source code which must be compiled by the end-user.
* Some people do not trust binary distributions or prefer to read through source code in order to look for potential problems.
* Source code is needed in order to apply custom patches.

To keep track of updated ports, subscribe to the {freebsd-ports} and the {freebsd-ports-bugs}.

[WARNING]
====

Before installing any application, check https://vuxml.freebsd.org/[] for security issues related to the application or type `pkg audit -F` to check all installed applications for known vulnerabilities.
====

The remainder of this chapter explains how to use packages and ports to install and manage third-party software on FreeBSD.

[[ports-finding-applications]]
== Finding Software

FreeBSD's list of available applications is growing all the time.
There are a number of ways to find software to install:

* The FreeBSD web site maintains an up-to-date searchable list of all the available applications, at link:https://www.FreeBSD.org/ports/[https://www.FreeBSD.org/ports/]. The ports can be searched by application name or by software category.
* Dan Langille maintains http://www.FreshPorts.org/[FreshPorts.org] which provides a comprehensive search utility and also tracks changes to the applications in the Ports Collection. Registered users can create a customized watch list in order to receive an automated email when their watched ports are updated.
* If finding a particular application becomes challenging, try searching a site like http://www.sourceforge.net/[SourceForge.net] or http://www.github.com/[GitHub.com] then check back at the link:https://www.FreeBSD.org/ports/[FreeBSD site] to see if the application has been ported.
* To search the binary package repository for an application:
+
[source,shell]
....
# pkg search subversion
git-subversion-1.9.2
java-subversion-1.8.8_2
p5-subversion-1.8.8_2
py27-hgsubversion-1.6
py27-subversion-1.8.8_2
ruby-subversion-1.8.8_2
subversion-1.8.8_2
subversion-book-4515
subversion-static-1.8.8_2
subversion16-1.6.23_4
subversion17-1.7.16_2
....
+
Package names include the version number and, in the case of ports based on python, the version number of the version of python the package was built with.
Some ports also have multiple versions available.
In the case of Subversion, there are different versions available, as well as different compile options.
In this case, the statically linked version of Subversion.
When indicating which package to install, it is best to specify the application by the port origin, which is the path in the ports tree.
Repeat the `pkg search` with `-o` to list the origin of each package:
+
[source,shell]
....
# pkg search -o subversion
devel/git-subversion
java/java-subversion
devel/p5-subversion
devel/py-hgsubversion
devel/py-subversion
devel/ruby-subversion
devel/subversion16
devel/subversion17
devel/subversion
devel/subversion-book
devel/subversion-static
....
+
Searching by shell globs, regular expressions, exact match, by description, or any other field in the repository database is also supported by `pkg search`.
After installing package:ports-mgmt/pkg[] or package:ports-mgmt/pkg-devel[], see man:pkg-search[8] for more details.
* If the Ports Collection is already installed, there are several methods to query the local version of the ports tree. To find out which category a port is in, type `whereis _file_`, where _file_ is the program to be installed:
+
[source,shell]
....
# whereis lsof
lsof: /usr/ports/sysutils/lsof
....
+
Alternately, an man:echo[1] statement can be used:
+
[source,shell]
....
# echo /usr/ports/*/*lsof*
/usr/ports/sysutils/lsof
....
+
Note that this will also return any matched files downloaded into the [.filename]#/usr/ports/distfiles# directory.
* Another way to find software is by using the Ports Collection's built-in search mechanism. To use the search feature, cd to [.filename]#/usr/ports# then run `make search name=program-name` where _program-name_ is the name of the software. For example, to search for `lsof`:
+
[source,shell]
....
# cd /usr/ports
# make search name=lsof
Port:   lsof-4.88.d,8
Path:   /usr/ports/sysutils/lsof
Info:   Lists information about open files (similar to fstat(1))
Maint:  ler@lerctr.org
Index:  sysutils
B-deps:
R-deps:
....
+
[TIP]
====
The built-in search mechanism uses a file of index information.
If a message indicates that the [.filename]#INDEX# is required, run `make fetchindex` to download the current index file.
With the [.filename]#INDEX# present, `make search` will be able to perform the requested search.
====
+
The ""Path:"" line indicates where to find the port.
+
To receive less information, use the `quicksearch` feature:
+
[source,shell]
....
# cd /usr/ports
# make quicksearch name=lsof
Port:   lsof-4.88.d,8
Path:   /usr/ports/sysutils/lsof
Info:   Lists information about open files (similar to fstat(1))
....
+
For more in-depth searching, use `make search key=_string_` or `make quicksearch key=_string_`, where _string_ is some text to search for.
The text can be in comments, descriptions, or dependencies in order to find ports which relate to a particular subject when the name of the program is unknown.
+
When using `search` or `quicksearch`, the search string is case-insensitive.
Searching for ""LSOF"" will yield the same results as searching for ""lsof"".

[[pkgng-intro]]
== Using pkg for Binary Package Management

pkg is the next generation replacement for the traditional FreeBSD package management tools, offering many features that make dealing with binary packages faster and easier.

For sites wishing to only use prebuilt binary packages from the FreeBSD mirrors, managing packages with pkg can be sufficient.

However, for those sites building from source or using their own repositories, a separate <<ports-upgrading-tools,port management tool>> will be needed.

Since pkg only works with binary packages, it is not a replacement for such tools.
Those tools can be used to install software from both binary packages and the Ports Collection, while pkg installs only binary packages.

[[pkgng-initial-setup]]
=== Getting Started with pkg

FreeBSD includes a bootstrap utility which can be used to download and install pkg and its manual pages.
This utility is designed to work with versions of FreeBSD starting with 10._X_.

[NOTE]
====
Not all FreeBSD versions and architectures support this bootstrap process.
The current list is at https://pkg.freebsd.org/[].
For other cases, pkg must instead be installed from the Ports Collection or as a binary package.
====

To bootstrap the system, run:

[source,shell]
....
# /usr/sbin/pkg
....

You must have a working Internet connection for the bootstrap process to succeed.

Otherwise, to install the port, run:

[source,shell]
....
# cd /usr/ports/ports-mgmt/pkg
# make
# make install clean
....

When upgrading an existing system that originally used the older pkg_* tools,
the database must be converted to the new format, so that the new tools are aware of the already installed packages.
Once pkg has been installed, the package database must be converted from the traditional format to the new format by running this command:

[source,shell]
....
# pkg2ng
....

[NOTE]
====
This step is not required for new installations that do not yet have any third-party software installed.
====

[IMPORTANT]
====
This step is not reversible.
Once the package database has been converted to the pkg format, the traditional `pkg_*` tools should no longer be used.
====

[NOTE]
====
The package database conversion may emit errors as the contents are converted to the new version.
Generally, these errors can be safely ignored.
However, a list of software that was not successfully converted is shown after `pkg2ng` finishes.
These applications must be manually reinstalled.
====

To ensure that the Ports Collection registers new software with pkg instead of the traditional packages database,
FreeBSD versions earlier than 10._X_ require this line in [.filename]#/etc/make.conf#:

[.programlisting]
....
WITH_PKGNG=   yes
....

By default, pkg uses the binary packages from the FreeBSD package mirrors (the _repository_).
For information about building a custom package repository, see <<ports-poudriere>>.

Additional pkg configuration options are described in man:pkg.conf[5].

Usage information for pkg is available in the man:pkg[8] manual page or by running `pkg` without additional arguments.

Each pkg command argument is documented in a command-specific manual page.
To read the manual page for `pkg install`, for example, run either of these commands:

[source,shell]
....
# pkg help install
....

[source,shell]
....
# man pkg-install
....

The rest of this section demonstrates common binary package management tasks which can be performed using pkg.
Each demonstrated command provides many switches to customize its use.
Refer to a command's help or man page for details and more examples.

[[quarterly-latest-branch]]
=== Quarterly and Latest Ports Branches

The `Quarterly` branch provides users with a more predictable and stable experience for port and package installation and upgrades.
This is done essentially by only allowing non-feature updates.
Quarterly branches aim to receive security fixes (that may be version updates, or backports of commits), bug fixes and ports compliance or framework changes.
The Quarterly branch is cut from HEAD at the beginning of every (yearly) quarter in January, April, July, and October.
Branches are named according to the year (YYYY) and quarter (Q1-4) they are created in.
For example, the quarterly branch created in January 2016, is named 2016Q1.
And the `Latest` branch provides the latest versions of the packages to the users.

To switch from quarterly to latest run the following commands:

[source,shell]
....
# mkdir -p /usr/local/etc/pkg/repos
# cp /etc/pkg/FreeBSD.conf /usr/local/etc/pkg/repos/FreeBSD.conf
....

Edit the file [.filename]#/usr/local/etc/pkg/repos/FreeBSD.conf# and change the string _quarterly_ to _latest_ in the `url:` line.

The result should be similar to the following:

[.programlisting]
....
FreeBSD: {
  url: ""pkg+http://pkg.FreeBSD.org/${ABI}/latest"",
  mirror_type: ""srv"",
  signature_type: ""fingerprints"",
  fingerprints: ""/usr/share/keys/pkg"",
  enabled: yes
}
....

And finally run this command to update from the new (latest) repository metadata.

[source,shell]
....
# pkg update -f
....

[[pkgng-pkg-info]]
=== Obtaining Information About Installed Packages

Information about the packages installed on a system can be viewed by running `pkg info` which, when run without any switches,
will list the package version for either all installed packages or the specified package.

For example, to see which version of pkg is installed, run:

[source,shell]
....
# pkg info pkg
pkg-1.1.4_1
....

[[pkgng-installing-deinstalling]]
=== Installing and Removing Packages

To install a binary package use the following command, where _packagename_ is the name of the package to install:

[source,shell]
....
# pkg install packagename
....

This command uses repository data to determine which version of the software to install and if it has any uninstalled dependencies.
For example, to install curl:

[source,shell]
....
# pkg install curl
Updating repository catalogue
/usr/local/tmp/All/curl-7.31.0_1.txz          100% of 1181 kB 1380 kBps 00m01s

/usr/local/tmp/All/ca_root_nss-3.15.1_1.txz   100% of  288 kB 1700 kBps 00m00s

Updating repository catalogue
The following 2 packages will be installed:

        Installing ca_root_nss: 3.15.1_1
        Installing curl: 7.31.0_1

The installation will require 3 MB more space

0 B to be downloaded

Proceed with installing packages [y/N]: y
Checking integrity... done
[1/2] Installing ca_root_nss-3.15.1_1... done
[2/2] Installing curl-7.31.0_1... done
Cleaning up cache files...Done
....

The new package and any additional packages that were installed as dependencies can be seen in the installed packages list:

[source,shell]
....
# pkg info
ca_root_nss-3.15.1_1	The root certificate bundle from the Mozilla Project
curl-7.31.0_1	Non-interactive tool to get files from FTP, GOPHER, HTTP(S) servers
pkg-1.1.4_6	New generation package manager
....

Packages that are no longer needed can be removed with `pkg delete`.
For example:

[source,shell]
....
# pkg delete curl
The following packages will be deleted:

	curl-7.31.0_1

The deletion will free 3 MB

Proceed with deleting packages [y/N]: y
[1/1] Deleting curl-7.31.0_1... done
....

[[pkgng-upgrading]]
=== Upgrading Installed Packages

Installed packages can be upgraded to their latest versions by running:

[source,shell]
....
# pkg upgrade
....

This command will compare the installed versions with those available in the repository catalogue and upgrade them from the repository.

[[pkgng-auditing]]
=== Auditing Installed Packages

Software vulnerabilities are regularly discovered in third-party applications.
To address this, pkg includes a built-in auditing mechanism.
To determine if there are any known vulnerabilities for the software installed on the system, run:

[source,shell]
....
# pkg audit -F
....

[[pkgng-autoremove]]
=== Automatically Removing Unused Packages

Removing a package may leave behind dependencies which are no longer required.
Unneeded packages that were installed as dependencies (leaf packages) can be automatically detected and removed using:

[source,shell]
....
# pkg autoremove
Packages to be autoremoved:
	ca_root_nss-3.15.1_1

The autoremoval will free 723 kB

Proceed with autoremoval of packages [y/N]: y
Deinstalling ca_root_nss-3.15.1_1... done
....

Packages installed as dependencies are called _automatic_ packages.
Non-automatic packages, i.e the packages that were explicity installed not as a dependency to another package, can be listed using:

[source,shell]
....
# pkg prime-list
nginx
openvpn
sudo
....

`pkg prime-list` is an alias command declared in [.filename]#/usr/local/etc/pkg.conf#.
There are many others that can be used to query the package database of the system.
For instance, command `pkg prime-origins` can be used to get the origin port directory of the list mentioned above:

[source,shell]
....
# pkg prime-origins
www/nginx
security/openvpn
security/sudo
....

This list can be used to rebuild all packages installed on a system using build tools such as package:ports-mgmt/poudriere[] or package:ports-mgmt/synth[].

Marking an installed package as automatic can be done using:

[source,shell]
....
# pkg set -A 1 devel/cmake
....

Once a package is a leaf package and is marked as automatic, it gets selected by `pkg autoremove`.

Marking an installed package as _not_ automatic can be done using:

[source,shell]
....
# pkg set -A 0 devel/cmake
....

[[pkgng-backup]]
=== Restoring the Package Database

Unlike the traditional package management system, pkg includes its own package database backup mechanism.
This functionality is enabled by default.

[TIP]
====
To disable the periodic script from backing up the package database, set `daily_backup_pkgdb_enable=""NO""` in man:periodic.conf[5].
====

To restore the contents of a previous package database backup,
run the following command replacing _/path/to/pkg.sql_ with the location of the backup:

[source,shell]
....
# pkg backup -r /path/to/pkg.sql
....

[NOTE]
====
If restoring a backup taken by the periodic script, it must be decompressed prior to being restored.
====

To run a manual backup of the pkg database, run the following command,
replacing _/path/to/pkg.sql_ with a suitable file name and location:

[source,shell]
....
# pkg backup -d /path/to/pkg.sql
....

[[pkgng-clean]]
=== Removing Stale Packages

By default, pkg stores binary packages in a cache directory defined by `PKG_CACHEDIR` in man:pkg.conf[5].
Only copies of the latest installed packages are kept. Older versions of pkg kept all previous packages.
To remove these outdated binary packages, run:

[source,shell]
....
# pkg clean
....

The entire cache may be cleared by running:

[source,shell]
....
# pkg clean -a
....

[[pkgng-set]]
=== Modifying Package Metadata

Software within the FreeBSD Ports Collection can undergo major version number changes.
To address this, pkg has a built-in command to update package origins.
This can be useful, for example, if package:lang/php5[] is renamed to package:lang/php53[] so that package:lang/php5[] can now represent version `5.4`.

To change the package origin for the above example, run:

[source,shell]
....
# pkg set -o lang/php5:lang/php53
....

As another example, to update package:lang/ruby18[] to package:lang/ruby19[], run:

[source,shell]
....
# pkg set -o lang/ruby18:lang/ruby19
....

As a final example, to change the origin of the [.filename]#libglut# shared libraries from package:graphics/libglut[] to package:graphics/freeglut[], run:

[source,shell]
....
# pkg set -o graphics/libglut:graphics/freeglut
....

[NOTE]
====
When changing package origins, it is important to reinstall packages that are dependent on the package with the modified origin.
To force a reinstallation of dependent packages, run:

[source,shell]
....
# pkg install -Rf graphics/freeglut
....

====

[[ports-using]]
== Using the Ports Collection

The Ports Collection is a set of [.filename]##Makefile##s, patches, and description files.
Each set of these files is used to compile and install an individual application on FreeBSD, and is called a _port_.

By default, the Ports Collection itself is stored as a subdirectory of [.filename]#/usr/ports#.

[WARNING]
====
Before installing and using the Ports Collection, please be aware that it is generally ill-advised to use the Ports Collection in conjunction with the binary packages provided via pkg to install software.
pkg, by default, tracks quarterly branch-releases of the ports tree and not HEAD.
Dependencies could be different for a port in HEAD compared to its counterpart in a quarterly branch release and this could result in conflicts between dependencies installed by pkg and those from the Ports Collection.
If the Ports Collection and pkg must be used in conjunction, then be sure that your Ports Collection and pkg are on the same branch release of the ports tree.
====

The Ports Collection contains directories for software categories.
Inside each category are subdirectories for individual applications.
Each application subdirectory contains a set of files that tells FreeBSD how to compile and install that program, called a _ports skeleton_.
Each port skeleton includes these files and directories:

* [.filename]#Makefile#: contains statements that specify how the application should be compiled and where its components should be installed.
* [.filename]#distinfo#: contains the names and checksums of the files that must be downloaded to build the port.
* [.filename]#files/#: this directory contains any patches needed for the program to compile and install on FreeBSD. This directory may also contain other files used to build the port.
* [.filename]#pkg-descr#: provides a more detailed description of the program.
* [.filename]#pkg-plist#: a list of all the files that will be installed by the port. It also tells the ports system which files to remove upon deinstallation.

Some ports include [.filename]#pkg-message# or other files to handle special situations.
For more details on these files, and on ports in general, refer to the extref:{porters-handbook}[FreeBSD Porter's Handbook].

The port does not include the actual source code, also known as a [.filename]#distfile#.
The extract portion of building a port will automatically save the downloaded source to [.filename]#/usr/ports/distfiles#.

[[ports-using-installation-methods]]
=== Installing the Ports Collection

Before an application can be compiled using a port, the Ports Collection must first be installed.
If it was not installed during the installation of FreeBSD, use one of the following methods to install it:

[[ports-using-portsnap-method]]
[.procedure]
****
*Procedure: Portsnap Method*

The base system of FreeBSD includes Portsnap.
This is a fast and user-friendly tool for retrieving the Ports Collection and is the recommended choice for most users not running FreeBSD-CURRENT.
This utility connects to a FreeBSD site, verifies the secure key, and downloads a new copy of the Ports Collection.
The key is used to verify the integrity of all downloaded files.

Note that Portsnap updates are generated from a snapshot of the main
branch of the Ports Collection and cannot be configured to use a
different branch (for example, `quarterly`).
If it is necessary to use a different branch of the Ports Collection
(for instance as referenced earlier in conjunction with binary
packages), then the <<ports-using-git-method,Git method>> must be used.

. To download a compressed snapshot of the Ports Collection into [.filename]#/var/db/portsnap#:
+
[source,shell]
....
# portsnap fetch
....
+
. When running Portsnap for the first time, extract the snapshot into [.filename]#/usr/ports#:
+
[source,shell]
....
# portsnap extract
....
+
. After the first use of Portsnap has been completed as shown above, [.filename]#/usr/ports# can be updated as needed by running:
+
[source,shell]
....
# portsnap fetch
# portsnap update
....
+
When using `fetch`, the `extract` or the `update` operation may be run consecutively, like so:
+
[source,shell]
....
# portsnap fetch update
....
****

[[ports-using-git-method]]
[.procedure]
****
*Procedure: Git Method*

If more control over the ports tree is needed or if local changes need to be maintained, or if running FreeBSD-CURRENT,
Git can be used to obtain the Ports Collection.
Refer to extref:{committers-guide}[the Git Primer, git-primer] for a detailed description of Git.

. Git must be installed before it can be used to check out the ports tree. If a copy of the ports tree is already present, install Git like this:
+
[source,shell]
....
# cd /usr/ports/devel/git
# make install clean
....
+
If the ports tree is not available, or pkg is being used to manage packages, Git can be installed as a package:
+
[source,shell]
....
# pkg install git
....
+
. Check out a copy of the HEAD branch of the ports tree:
+
[source,shell]
....
# git clone https://git.FreeBSD.org/ports.git /usr/ports
....
+
. Or, check out a copy of a quarterly branch:
+
[source,shell]
....
# git clone https://git.FreeBSD.org/ports.git -b 2020Q3 /usr/ports
....
+
. As needed, update [.filename]#/usr/ports# after the initial Git checkout:
+
[source,shell]
....
# git -C /usr/ports pull
....
+
. As needed, switch [.filename]#/usr/ports# to a different quarterly branch:
+
[source,shell]
....
# git -C /usr/ports switch 2020Q4
....
****

=== Installing Ports

This section provides basic instructions on using the Ports Collection to install or remove software.
The detailed description of available `make` targets and environment variables is available in man:ports[7].

[WARNING]
====

Before compiling any port, be sure to update the Ports Collection as described in the previous section.
Since the installation of any third-party software can introduce security vulnerabilities, it is recommended to first check https://vuxml.freebsd.org/[] for known security issues related to the port.
Alternately, run `pkg audit -F` before installing a new port.
This command can be configured to automatically perform a security audit and an update of the vulnerability database during the daily security system check. For more information, refer to man:pkg-audit[8] and man:periodic[8].
====

Using the Ports Collection assumes a working Internet connection.
It also requires superuser privilege.

To compile and install the port, change to the directory of the port to be installed, then type `make install` at the prompt.
Messages will indicate the progress:

[source,shell]
....
# cd /usr/ports/sysutils/lsof
# make install
>> lsof_4.88D.freebsd.tar.gz doesn't seem to exist in /usr/ports/distfiles/.
>> Attempting to fetch from ftp://lsof.itap.purdue.edu/pub/tools/unix/lsof/.
===>  Extracting for lsof-4.88
...
[extraction output snipped]
...
>> Checksum OK for lsof_4.88D.freebsd.tar.gz.
===>  Patching for lsof-4.88.d,8
===>  Applying FreeBSD patches for lsof-4.88.d,8
===>  Configuring for lsof-4.88.d,8
...
[configure output snipped]
...
===>  Building for lsof-4.88.d,8
...
[compilation output snipped]
...

===>  Installing for lsof-4.88.d,8
...
[installation output snipped]
...
===>   Generating temporary packing list
===>   Compressing manual pages for lsof-4.88.d,8
===>   Registering installation for lsof-4.88.d,8
===>  SECURITY NOTE:
      This port has installed the following binaries which execute with
      increased privileges.
/usr/local/sbin/lsof
#
....

Since `lsof` is a program that runs with increased privileges, a security warning is displayed as it is installed.
Once the installation is complete, the prompt will be returned.

Some shells keep a cache of the commands that are available in the directories listed in the `PATH` environment variable, to speed up lookup operations for the executable file of these commands.
Users of the `tcsh` shell should type `rehash` so that a newly installed command can be used without specifying its full path.
Use `hash -r` instead for the `sh` shell.
Refer to the documentation for the shell for more information.

During installation, a working subdirectory is created which contains all the temporary files used during compilation.
Removing this directory saves disk space and minimizes the chance of problems later when upgrading to the newer version of the port:

[source,shell]
....
# make clean
===>  Cleaning for lsof-88.d,8
#
....

[NOTE]
====
To save this extra step, instead use `make install clean` when compiling the port.
====

==== Customizing Ports Installation

Some ports provide build options which can be used to enable or disable application components, provide security options, or allow for other customizations.
Examples include package:www/firefox[], package:security/gpgme[], and package:mail/sylpheed-claws[].
If the port depends upon other ports which have configurable options,
it may pause several times for user interaction as the default behavior is to prompt the user to select options from a menu.
To avoid this and do all of the configuration in one batch, run `make config-recursive` within the port skeleton.
Then, run `make install [clean]` to compile and install the port.

[TIP]
====
When using `config-recursive`, the list of ports to configure are gathered by the `all-depends-list` target.
It is recommended to run `make config-recursive` until all dependent ports options have been defined,
and ports options screens no longer appear, to be certain that all dependency options have been configured.
====

There are several ways to revisit a port's build options menu in order to add, remove, or change these options after a port has been built.
One method is to `cd` into the directory containing the port and type `make config`.
Another option is to use `make showconfig`.
Another option is to execute `make rmconfig` which will remove all selected options and allow you to start over.
All of these options, and others, are explained in great detail in man:ports[7].

The ports system uses man:fetch[1] to download the source files, which supports various environment variables.
The `FTP_PASSIVE_MODE`, `FTP_PROXY`, and `FTP_PASSWORD` variables may need to be set if the FreeBSD system is behind a firewall or FTP/HTTP proxy.
See man:fetch[3] for the complete list of supported variables.

For users who cannot be connected to the Internet all the time, `make fetch` can be run within [.filename]#/usr/ports#,
to fetch all distfiles, or within a category, such as [.filename]#/usr/ports/net#, or within the specific port skeleton.
Note that if a port has any dependencies, running this command in a category or ports skeleton will _not_ fetch the distfiles of ports from another category.
Instead, use `make fetch-recursive` to also fetch the distfiles for all the dependencies of a port.

In rare cases, such as when an organization has a local distfiles repository, the `MASTER_SITES` variable can be used to override the download locations specified in the [.filename]#Makefile#.
When using, specify the alternate location:

[source,shell]
....
# cd /usr/ports/directory
# make MASTER_SITE_OVERRIDE= \\
ftp://ftp.organization.org/pub/FreeBSD/ports/distfiles/ fetch
....

The `WRKDIRPREFIX` and `PREFIX` variables can override the default working and target directories. For example:

[source,shell]
....
# make WRKDIRPREFIX=/usr/home/example/ports install
....

will compile the port in [.filename]#/usr/home/example/ports# and install everything under [.filename]#/usr/local#.

[source,shell]
....
# make PREFIX=/usr/home/example/local install
....

will compile the port in [.filename]#/usr/ports# and install it in [.filename]#/usr/home/example/local#. And:

[source,shell]
....
# make WRKDIRPREFIX=../ports PREFIX=../local install
....

will combine the two.

These can also be set as environmental variables.
Refer to the manual page for your shell for instructions on how to set an environmental variable.

[[ports-removing]]
=== Removing Installed Ports

Installed ports can be uninstalled using `pkg delete`.
Examples for using this command can be found in the man:pkg-delete[8] manual page.

Alternately, `make deinstall` can be run in the port's directory:

[source,shell]
....
# cd /usr/ports/sysutils/lsof
# make deinstall
===>  Deinstalling for sysutils/lsof
===>   Deinstalling
Deinstallation has been requested for the following 1 packages:

	lsof-4.88.d,8

The deinstallation will free 229 kB
[1/1] Deleting lsof-4.88.d,8... done
....

It is recommended to read the messages as the port is uninstalled.
If the port has any applications that depend upon it, this information will be displayed but the uninstallation will proceed.
In such cases, it may be better to reinstall the application in order to prevent broken dependencies.

[[ports-upgrading]]
=== Upgrading Ports

Over time, newer versions of software become available in the Ports Collection.
This section describes how to determine which software can be upgraded and how to perform the upgrade.

To determine if newer versions of installed ports are available, ensure that the latest version of the ports tree is installed,
using the updating command described in either <<ports-using-portsnap-method, “Portsnap Method”>> or <<ports-using-git-method, “Git Method”>>.
On FreeBSD 10 and later, or if the system has been converted to pkg, the following command will list the installed ports which are out of date:

[source,shell]
....
# pkg version -l ""<""
....

For FreeBSD 9._X_ and lower, the following command will list the installed ports that are out of date:

[source,shell]
....
# pkg_version -l ""<""
....

[IMPORTANT]
====
Before attempting an upgrade, read [.filename]#/usr/ports/UPDATING# from the top of the file to the date closest to the last time ports were upgraded or the system was installed.
This file describes various issues and additional steps users may encounter and need to perform when updating a port, including such things as file format changes, changes in locations of configuration files, or any incompatibilities with previous versions.
Make note of any instructions which match any of the ports that need upgrading and follow these instructions when performing the upgrade.
====

[[ports-upgrading-tools]]
==== Tools to Upgrade and Manage Ports

The Ports Collection contains several utilities to perform the actual upgrade.
Each has its strengths and weaknesses.

Historically, most installations used either Portmaster or Portupgrade.
Synth is a newer alternative.

[NOTE]
====
The choice of which tool is best for a particular system is up to the system administrator.
It is recommended practice to back up your data before using any of these tools.
====

[[portmaster]]
==== Upgrading Ports Using Portmaster

package:ports-mgmt/portmaster[] is a very small utility for upgrading installed ports.
It is designed to use the tools installed with the FreeBSD base system without depending on other ports or databases.
To install this utility as a port:

[source,shell]
....
# cd /usr/ports/ports-mgmt/portmaster
# make install clean
....

Portmaster defines four categories of ports:

* Root port: has no dependencies and is not a dependency of any other ports.
* Trunk port: has no dependencies, but other ports depend upon it.
* Branch port: has dependencies and other ports depend upon it.
* Leaf port: has dependencies but no other ports depend upon it.

To list these categories and search for updates:

[source,shell]
....
# portmaster -L
===>>> Root ports (No dependencies, not depended on)
===>>> ispell-3.2.06_18
===>>> screen-4.0.3
        ===>>> New version available: screen-4.0.3_1
===>>> tcpflow-0.21_1
===>>> 7 root ports
...
===>>> Branch ports (Have dependencies, are depended on)
===>>> apache22-2.2.3
        ===>>> New version available: apache22-2.2.8
...
===>>> Leaf ports (Have dependencies, not depended on)
===>>> automake-1.9.6_2
===>>> bash-3.1.17
        ===>>> New version available: bash-3.2.33
...
===>>> 32 leaf ports

===>>> 137 total installed ports
        ===>>> 83 have new versions available
....

This command is used to upgrade all outdated ports:

[source,shell]
....
# portmaster -a
....

[NOTE]
====
By default, Portmaster makes a backup package before deleting the existing port.
If the installation of the new version is successful, Portmaster deletes the backup.
Using `-b` instructs Portmaster not to automatically delete the backup.
Adding `-i` starts Portmaster in interactive mode, prompting for confirmation before upgrading each port.
Many other options are available.
Read through the manual page for man:portmaster[8] for details regarding their usage.
====

If errors are encountered during the upgrade process, add `-f` to upgrade and rebuild all ports:

[source,shell]
....
# portmaster -af
....

Portmaster can also be used to install new ports on the system, upgrading all dependencies before building and installing the new port.
To use this function, specify the location of the port in the Ports Collection:

[source,shell]
....
# portmaster shells/bash
....

More information about package:ports-mgmt/portmaster[] may be found in its [.filename]#pkg-descr#.

[[portupgrade]]
==== Upgrading Ports Using Portupgrade

package:ports-mgmt/portupgrade[] is another utility that can be used to upgrade ports.
It installs a suite of applications which can be used to manage ports.
However, it is dependent upon Ruby. To install the port:

[source,shell]
....
# cd /usr/ports/ports-mgmt/portupgrade
# make install clean
....

Before performing an upgrade using this utility, it is recommended to scan the list of installed ports using `pkgdb -F` and to fix all the inconsistencies it reports.

To upgrade all the outdated ports installed on the system, use `portupgrade -a`.
Alternately, include `-i` to be asked for confirmation of every individual upgrade:

[source,shell]
....
# portupgrade -ai
....

To upgrade only a specified application instead of all available ports, use `portupgrade _pkgname_`.
It is very important to include `-R` to first upgrade all the ports required by the given application:

[source,shell]
....
# portupgrade -R firefox
....

If `-P` is included, Portupgrade searches for available packages in the local directories listed in `PKG_PATH`.
If none are available locally, it then fetches packages from a remote site.
If packages can not be found locally or fetched remotely, Portupgrade will use ports.
To avoid using ports entirely, specify `-PP`.
This last set of options tells Portupgrade to abort if no packages are available:

[source,shell]
....
# portupgrade -PP gnome3
....

To just fetch the port distfiles, or packages, if `-P` is specified, without building or installing anything, use `-F`.
For further information on all of the available switches, refer to the manual page for `portupgrade`.

More information about package:ports-mgmt/portupgrade[] may be found in its [.filename]#pkg-descr#.

[[ports-disk-space]]
=== Ports and Disk Space

Using the Ports Collection will use up disk space over time.
After building and installing a port, running `make clean` within the ports skeleton will clean up the temporary [.filename]#work# directory.
If Portmaster is used to install a port, it will automatically remove this directory unless `-K` is specified.
If Portupgrade is installed, this command will remove all [.filename]#work# directories found within the local copy of the Ports Collection:

[source,shell]
....
# portsclean -C
....

In addition, outdated source distribution files accumulate in [.filename]#/usr/ports/distfiles# over time.
To use Portupgrade to delete all the distfiles that are no longer referenced by any ports:

[source,shell]
....
# portsclean -D
....

Portupgrade can remove all distfiles not referenced by any port currently installed on the system:

[source,shell]
....
# portsclean -DD
....

If Portmaster is installed, use:

[source,shell]
....
# portmaster --clean-distfiles
....

By default, this command is interactive and prompts the user to confirm if a distfile should be deleted.

In addition to these commands, package:ports-mgmt/pkg_cutleaves[] automates the task of removing installed ports that are no longer needed.

[[ports-poudriere]]
== Building Packages with Poudriere

Poudriere is a `BSD`-licensed utility for creating and testing FreeBSD packages.
It uses FreeBSD jails to set up isolated compilation environments.
These jails can be used to build packages for versions of FreeBSD that are different from the system on which it is installed, and also to build packages for i386 if the host is an amd64 system.
Once the packages are built, they are in a layout identical to the official mirrors.
These packages are usable by man:pkg[8] and other package management tools.

Poudriere is installed using the package:ports-mgmt/poudriere[] package or port.
The installation includes a sample configuration file [.filename]#/usr/local/etc/poudriere.conf.sample#.
Copy this file to [.filename]#/usr/local/etc/poudriere.conf#.
Edit the copied file to suit the local configuration.

While `ZFS` is not required on the system running poudriere, it is beneficial.
When `ZFS` is used, `ZPOOL` must be specified in [.filename]#/usr/local/etc/poudriere.conf# and `FREEBSD_HOST` should be set to a nearby mirror.
Defining `CCACHE_DIR` enables the use of package:devel/ccache[] to cache compilation and reduce build times for frequently-compiled code.
It may be convenient to put poudriere datasets in an isolated tree mounted at [.filename]#/poudriere#.
Defaults for the other configuration values are adequate.

The number of processor cores detected is used to define how many builds will run in parallel.
Supply enough virtual memory, either with `RAM` or swap space.
If virtual memory runs out, the compilation jails will stop and be torn down, resulting in weird error messages.

[[poudriere-initialization]]
=== Initialize Jails and Port Trees

After configuration, initialize poudriere so that it installs a jail with the required FreeBSD tree and a ports tree.
Specify a name for the jail using `-j` and the FreeBSD version with `-v`.
On systems running FreeBSD/amd64, the architecture can be set with `-a` to either `i386` or `amd64`.
The default is the architecture shown by `uname`.

[source,shell]
....
# poudriere jail -c -j 11amd64 -v 11.4-RELEASE
[00:00:00] Creating 11amd64 fs at /poudriere/jails/11amd64... done
[00:00:00] Using pre-distributed MANIFEST for FreeBSD 11.4-RELEASE amd64
[00:00:00] Fetching base for FreeBSD 11.4-RELEASE amd64
/poudriere/jails/11amd64/fromftp/base.txz              125 MB 4110 kBps    31s
[00:00:33] Extracting base... done
[00:00:54] Fetching src for FreeBSD 11.4-RELEASE amd64
/poudriere/jails/11amd64/fromftp/src.txz               154 MB 4178 kBps    38s
[00:01:33] Extracting src... done
[00:02:31] Fetching lib32 for FreeBSD 11.4-RELEASE amd64
/poudriere/jails/11amd64/fromftp/lib32.txz              24 MB 3969 kBps    06s
[00:02:38] Extracting lib32... done
[00:02:42] Cleaning up... done
[00:02:42] Recording filesystem state for clean... done
[00:02:42] Upgrading using ftp
/etc/resolv.conf -> /poudriere/jails/11amd64/etc/resolv.conf
Looking up update.FreeBSD.org mirrors... 3 mirrors found.
Fetching public key from update4.freebsd.org... done.
Fetching metadata signature for 11.4-RELEASE from update4.freebsd.org... done.
Fetching metadata index... done.
Fetching 2 metadata files... done.
Inspecting system... done.
Preparing to download files... done.
Fetching 124 patches.....10....20....30....40....50....60....70....80....90....100....110....120.. done.
Applying patches... done.
Fetching 6 files... done.
The following files will be added as part of updating to
11.4-RELEASE-p1:
/usr/src/contrib/unbound/.github
/usr/src/contrib/unbound/.github/FUNDING.yml
/usr/src/contrib/unbound/contrib/drop2rpz
/usr/src/contrib/unbound/contrib/unbound_portable.service.in
/usr/src/contrib/unbound/services/rpz.c
/usr/src/contrib/unbound/services/rpz.h
/usr/src/lib/libc/tests/gen/spawnp_enoexec.sh
The following files will be updated as part of updating to
11.4-RELEASE-p1:
[…]
Installing updates...Scanning //usr/share/certs/blacklisted for certificates...
Scanning //usr/share/certs/trusted for certificates...
 done.
11.4-RELEASE-p1
[00:04:06] Recording filesystem state for clean... done
[00:04:07] Jail 11amd64 11.4-RELEASE-p1 amd64 is ready to be used
....

[source,shell]
....
# poudriere ports -c -p local -m git+https
[00:00:00] Creating local fs at /poudriere/ports/local... done
[00:00:00] Checking out the ports tree... done
....

On a single computer, poudriere can build ports with multiple configurations, in multiple jails, and from different port trees.
Custom configurations for these combinations are called _sets_.
See the CUSTOMIZATION section of man:poudriere[8] for details after package:ports-mgmt/poudriere[] or package:ports-mgmt/poudriere-devel[] is installed.

The basic configuration shown here puts a single jail-, port-, and set-specific [.filename]#make.conf# in [.filename]#/usr/local/etc/poudriere.d#.
The filename in this example is created by combining the jail name, port name, and set name: [.filename]#11amd64-local-workstation-make.conf#.
The system [.filename]#make.conf# and this new file are combined at build time to create the [.filename]#make.conf# used by the build jail.

Packages to be built are entered in [.filename]#11amd64-local-workstation-pkglist#:

[.programlisting]
....
editors/emacs
devel/git
ports-mgmt/pkg
...
....

Options and dependencies for the specified ports are configured:

[source,shell]
....
# poudriere options -j 11amd64 -p local -z workstation -f 11amd64-local-workstation-pkglist
....

Finally, packages are built and a package repository is created:

[source,shell]
....
# poudriere bulk -j 11amd64 -p local -z workstation -f 11amd64-local-workstation-pkglist
....

While running, pressing kbd:[Ctrl+t] displays the current state of the build.
Poudriere also builds files in [.filename]#/poudriere/logs/bulk/jailname# that can be used with a web server to display build information.

After completion, the new packages are now available for installation from the poudriere repository.

For more information on using poudriere, see man:poudriere[8] and the main web site, https://github.com/freebsd/poudriere/wiki[].

=== Configuring pkg Clients to Use a Poudriere Repository

While it is possible to use both a custom repository along side of the official repository, sometimes it is useful to disable the official repository.
This is done by creating a configuration file that overrides and disables the official configuration file.
Create [.filename]#/usr/local/etc/pkg/repos/FreeBSD.conf# that contains the following:

[.programlisting]
....
FreeBSD: {
	enabled: no
}
....

Usually it is easiest to serve a poudriere repository to the client machines via HTTP.
Set up a webserver to serve up the package directory, for instance: [.filename]#/usr/local/poudriere/data/packages/11amd64#, where [.filename]#11amd64# is the name of the build.

If the URL to the package repository is: `http://pkg.example.com/11amd64`,
then the repository configuration file in [.filename]#/usr/local/etc/pkg/repos/custom.conf# would look like:

[.programlisting]
....
custom: {
	url: ""http://pkg.example.com/11amd64"",
	enabled: yes,
}
....

[[ports-nextsteps]]
== Post-Installation Considerations

Regardless of whether the software was installed from a binary package or port, most third-party applications require some level of configuration after installation.
The following commands and locations can be used to help determine what was installed with the application.

* Most applications install at least one default configuration file in [.filename]#/usr/local/etc#. In cases where an application has a large number of configuration files, a subdirectory will be created to hold them. Often, sample configuration files are installed which end with a suffix such as [.filename]#.sample#. The configuration files should be reviewed and possibly edited to meet the system's needs. To edit a sample file, first copy it without the [.filename]#.sample# extension.
* Applications which provide documentation will install it into [.filename]#/usr/local/share/doc# and many applications also install manual pages. This documentation should be consulted before continuing.
* Some applications run services which must be added to [.filename]#/etc/rc.conf# before starting the application. These applications usually install a startup script in [.filename]#/usr/local/etc/rc.d#. See crossref:config[configtuning-starting-services,Starting Services] for more information.
+
[NOTE]
====
By design, applications do not run their startup script upon installation, nor do they run their stop script upon deinstallation or upgrade.
This decision is left to the individual system administrator.
====

* Users of man:csh[1] should run `rehash` to rebuild the known binary list in the shells `PATH`.
* Use `pkg info` to determine which files, man pages, and binaries were installed with the application.

[[ports-broken]]
== Dealing with Broken Ports

When a port does not build or install, try the following:

. Search to see if there is a fix pending for the port in the link:https://www.FreeBSD.org/support/[Problem Report database]. If so, implementing the proposed fix may fix the issue.
. Ask the maintainer of the port for help. Type `make maintainer` in the ports skeleton or read the port's [.filename]#Makefile# to find the maintainer's email address. Remember to include the output leading up to the error in the email to the maintainer.
+
[NOTE]
====
Some ports are not maintained by an individual but instead by a group maintainer represented by a extref:{mailing-list-faq}[mailing list].
Many, but not all, of these addresses look like mailto:freebsd-listname@FreeBSD.org[freebsd-listname@FreeBSD.org].
Please take this into account when sending an email.

In particular, ports maintained by mailto:ports@FreeBSD.org[ports@FreeBSD.org] are not maintained by a specific individual.
Instead, any fixes and support come from the general community who subscribe to that mailing list. More volunteers are always needed!
====
+
If there is no response to the email, use Bugzilla to submit a bug report using the instructions in extref:{problem-reports}[Writing FreeBSD Problem Reports].
. Fix it! The extref:{porters-handbook}[Porter's Handbook] includes detailed information on the ports infrastructure so that you can fix the occasional broken port or even submit your own!
. Install the package instead of the port using the instructions in <<pkgng-intro>>.
",12536,False,2306.051717404384,median
"// Copyright (c) 2012 The Chromium 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 <vector>

#include ""base/file_util.h""
#include ""base/path_service.h""
#include ""base/string_number_conversions.h""
#include ""base/time.h""
#include ""base/utf_string_conversions.h""
#include ""chrome/browser/autofill/autofill_profile.h""
#include ""chrome/browser/autofill/autofill_type.h""
#include ""chrome/browser/autofill/credit_card.h""
#include ""chrome/browser/password_manager/encryptor.h""
#include ""chrome/browser/webdata/autofill_change.h""
#include ""chrome/browser/webdata/autofill_entry.h""
#include ""chrome/browser/webdata/autofill_table.h""
#include ""chrome/browser/webdata/web_database.h""
#include ""chrome/common/chrome_paths.h""
#include ""chrome/common/guid.h""
#include ""sql/statement.h""
#include ""testing/gtest/include/gtest/gtest.h""
#include ""webkit/forms/form_field.h""

using base::Time;
using base::TimeDelta;
using webkit::forms::FormField;

// So we can compare AutofillKeys with EXPECT_EQ().
std::ostream& operator<<(std::ostream& os, const AutofillKey& key) {
  return os << UTF16ToASCII(key.name()) << "", "" << UTF16ToASCII(key.value());
}

// So we can compare AutofillChanges with EXPECT_EQ().
std::ostream& operator<<(std::ostream& os, const AutofillChange& change) {
  switch (change.type()) {
    case AutofillChange::ADD: {
      os << ""ADD"";
      break;
    }
    case AutofillChange::UPDATE: {
      os << ""UPDATE"";
      break;
    }
    case AutofillChange::REMOVE: {
      os << ""REMOVE"";
      break;
    }
  }
  return os << "" "" << change.key();
}

namespace {

bool CompareAutofillEntries(const AutofillEntry& a, const AutofillEntry& b) {
  std::set<Time> timestamps1(a.timestamps().begin(), a.timestamps().end());
  std::set<Time> timestamps2(b.timestamps().begin(), b.timestamps().end());

  int compVal = a.key().name().compare(b.key().name());
  if (compVal != 0) {
    return compVal < 0;
  }

  compVal = a.key().value().compare(b.key().value());
  if (compVal != 0) {
    return compVal < 0;
  }

  if (timestamps1.size() != timestamps2.size()) {
    return timestamps1.size() < timestamps2.size();
  }

  std::set<Time>::iterator it;
  for (it = timestamps1.begin(); it != timestamps1.end(); it++) {
    timestamps2.erase(*it);
  }

  return !timestamps2.empty();
}

}  // anonymous namespace

class AutofillTableTest : public testing::Test {
 public:
  AutofillTableTest() {}
  virtual ~AutofillTableTest() {}

 protected:
  typedef std::vector<AutofillChange> AutofillChangeList;
  typedef std::set<AutofillEntry,
    bool (*)(const AutofillEntry&, const AutofillEntry&)> AutofillEntrySet;
  typedef std::set<AutofillEntry, bool (*)(const AutofillEntry&,
    const AutofillEntry&)>::iterator AutofillEntrySetIterator;

  virtual void SetUp() {
#if defined(OS_MACOSX)
    Encryptor::UseMockKeychain(true);
#endif
    PathService::Get(chrome::DIR_TEST_DATA, &file_);
    const std::string test_db = ""TestWebDatabase"" +
        base::Int64ToString(Time::Now().ToTimeT()) +
        "".db"";
    file_ = file_.AppendASCII(test_db);
    file_util::Delete(file_, false);
  }

  virtual void TearDown() {
    file_util::Delete(file_, false);
  }

  static AutofillEntry MakeAutofillEntry(const char* name,
                                         const char* value,
                                         time_t timestamp0,
                                         time_t timestamp1) {
    std::vector<Time> timestamps;
    if (timestamp0 >= 0)
      timestamps.push_back(Time::FromTimeT(timestamp0));
    if (timestamp1 >= 0)
      timestamps.push_back(Time::FromTimeT(timestamp1));
    return AutofillEntry(
        AutofillKey(ASCIIToUTF16(name), ASCIIToUTF16(value)), timestamps);
  }

  FilePath file_;

 private:
  DISALLOW_COPY_AND_ASSIGN(AutofillTableTest);
};

TEST_F(AutofillTableTest, Autofill) {
  WebDatabase db;

  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  Time t1 = Time::Now();

  // Simulate the submission of a handful of entries in a field called ""Name"",
  // some more often than others.
  AutofillChangeList changes;
  FormField field;
  field.name = ASCIIToUTF16(""Name"");
  field.value = ASCIIToUTF16(""Superman"");
  base::Time now = base::Time::Now();
  base::TimeDelta two_seconds = base::TimeDelta::FromSeconds(2);
  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(field, &changes));
  std::vector<string16> v;
  for (int i = 0; i < 5; i++) {
    field.value = ASCIIToUTF16(""Clark Kent"");
    EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(field, &changes,
        now + i * two_seconds));
  }
  for (int i = 0; i < 3; i++) {
    field.value = ASCIIToUTF16(""Clark Sutter"");
    EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(field, &changes,
        now + i * two_seconds));
  }
  for (int i = 0; i < 2; i++) {
    field.name = ASCIIToUTF16(""Favorite Color"");
    field.value = ASCIIToUTF16(""Green"");
    EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(field, &changes,
        now + i * two_seconds));
  }

  int count = 0;
  int64 pair_id = 0;

  // We have added the name Clark Kent 5 times, so count should be 5 and pair_id
  // should be somthing non-zero.
  field.name = ASCIIToUTF16(""Name"");
  field.value = ASCIIToUTF16(""Clark Kent"");
  EXPECT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(field, &pair_id,
                                                                &count));
  EXPECT_EQ(5, count);
  EXPECT_NE(0, pair_id);

  // Storing in the data base should be case sensitive, so there should be no
  // database entry for clark kent lowercase.
  field.value = ASCIIToUTF16(""clark kent"");
  EXPECT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(field, &pair_id,
                                                                &count));
  EXPECT_EQ(0, count);

  field.name = ASCIIToUTF16(""Favorite Color"");
  field.value = ASCIIToUTF16(""Green"");
  EXPECT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(field, &pair_id,
                                                                &count));
  EXPECT_EQ(2, count);

  // This is meant to get a list of suggestions for Name.  The empty prefix
  // in the second argument means it should return all suggestions for a name
  // no matter what they start with.  The order that the names occur in the list
  // should be decreasing order by count.
  EXPECT_TRUE(db.GetAutofillTable()->GetFormValuesForElementName(
      ASCIIToUTF16(""Name""), string16(), &v, 6));
  EXPECT_EQ(3U, v.size());
  if (v.size() == 3) {
    EXPECT_EQ(ASCIIToUTF16(""Clark Kent""), v[0]);
    EXPECT_EQ(ASCIIToUTF16(""Clark Sutter""), v[1]);
    EXPECT_EQ(ASCIIToUTF16(""Superman""), v[2]);
  }

  // If we query again limiting the list size to 1, we should only get the most
  // frequent entry.
  EXPECT_TRUE(db.GetAutofillTable()->GetFormValuesForElementName(
      ASCIIToUTF16(""Name""), string16(), &v, 1));
  EXPECT_EQ(1U, v.size());
  if (v.size() == 1) {
    EXPECT_EQ(ASCIIToUTF16(""Clark Kent""), v[0]);
  }

  // Querying for suggestions given a prefix is case-insensitive, so the prefix
  // ""cLa"" shoud get suggestions for both Clarks.
  EXPECT_TRUE(db.GetAutofillTable()->GetFormValuesForElementName(
      ASCIIToUTF16(""Name""), ASCIIToUTF16(""cLa""), &v, 6));
  EXPECT_EQ(2U, v.size());
  if (v.size() == 2) {
    EXPECT_EQ(ASCIIToUTF16(""Clark Kent""), v[0]);
    EXPECT_EQ(ASCIIToUTF16(""Clark Sutter""), v[1]);
  }

  // Removing all elements since the beginning of this function should remove
  // everything from the database.
  changes.clear();
  EXPECT_TRUE(db.GetAutofillTable()->RemoveFormElementsAddedBetween(
      t1, Time(), &changes));

  const AutofillChange expected_changes[] = {
    AutofillChange(AutofillChange::REMOVE,
                   AutofillKey(ASCIIToUTF16(""Name""),
                               ASCIIToUTF16(""Superman""))),
    AutofillChange(AutofillChange::REMOVE,
                   AutofillKey(ASCIIToUTF16(""Name""),
                               ASCIIToUTF16(""Clark Kent""))),
    AutofillChange(AutofillChange::REMOVE,
                   AutofillKey(ASCIIToUTF16(""Name""),
                               ASCIIToUTF16(""Clark Sutter""))),
    AutofillChange(AutofillChange::REMOVE,
                   AutofillKey(ASCIIToUTF16(""Favorite Color""),
                               ASCIIToUTF16(""Green""))),
  };
  EXPECT_EQ(arraysize(expected_changes), changes.size());
  for (size_t i = 0; i < arraysize(expected_changes); i++) {
    EXPECT_EQ(expected_changes[i], changes[i]);
  }

  field.name = ASCIIToUTF16(""Name"");
  field.value = ASCIIToUTF16(""Clark Kent"");
  EXPECT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(field, &pair_id,
                                                                &count));
  EXPECT_EQ(0, count);

  EXPECT_TRUE(db.GetAutofillTable()->GetFormValuesForElementName(
      ASCIIToUTF16(""Name""), string16(), &v, 6));
  EXPECT_EQ(0U, v.size());

  // Now add some values with empty strings.
  const string16 kValue = ASCIIToUTF16(""  toto   "");
  field.name = ASCIIToUTF16(""blank"");
  field.value = string16();
  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(field, &changes));
  field.name = ASCIIToUTF16(""blank"");
  field.value = ASCIIToUTF16("" "");
  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(field, &changes));
  field.name = ASCIIToUTF16(""blank"");
  field.value = ASCIIToUTF16(""      "");
  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(field, &changes));
  field.name = ASCIIToUTF16(""blank"");
  field.value = kValue;
  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(field, &changes));

  // They should be stored normally as the DB layer does not check for empty
  // values.
  v.clear();
  EXPECT_TRUE(db.GetAutofillTable()->GetFormValuesForElementName(
      ASCIIToUTF16(""blank""), string16(), &v, 10));
  EXPECT_EQ(4U, v.size());

  // Now we'll check that ClearAutofillEmptyValueElements() works as expected.
  db.GetAutofillTable()->ClearAutofillEmptyValueElements();

  v.clear();
  EXPECT_TRUE(db.GetAutofillTable()->GetFormValuesForElementName(
      ASCIIToUTF16(""blank""), string16(), &v, 10));
  ASSERT_EQ(1U, v.size());

  EXPECT_EQ(kValue, v[0]);
}

TEST_F(AutofillTableTest, Autofill_RemoveBetweenChanges) {
  WebDatabase db;
  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  TimeDelta one_day(TimeDelta::FromDays(1));
  Time t1 = Time::Now();
  Time t2 = t1 + one_day;

  AutofillChangeList changes;
  FormField field;
  field.name = ASCIIToUTF16(""Name"");
  field.value = ASCIIToUTF16(""Superman"");
  EXPECT_TRUE(
      db.GetAutofillTable()->AddFormFieldValueTime(field, &changes, t1));
  EXPECT_TRUE(
      db.GetAutofillTable()->AddFormFieldValueTime(field, &changes, t2));

  changes.clear();
  EXPECT_TRUE(db.GetAutofillTable()->RemoveFormElementsAddedBetween(
      t1, t2, &changes));
  ASSERT_EQ(1U, changes.size());
  EXPECT_EQ(AutofillChange(AutofillChange::UPDATE,
                           AutofillKey(ASCIIToUTF16(""Name""),
                                       ASCIIToUTF16(""Superman""))),
            changes[0]);
  changes.clear();

  EXPECT_TRUE(db.GetAutofillTable()->RemoveFormElementsAddedBetween(
      t2, t2 + one_day, &changes));
  ASSERT_EQ(1U, changes.size());
  EXPECT_EQ(AutofillChange(AutofillChange::REMOVE,
                           AutofillKey(ASCIIToUTF16(""Name""),
                                       ASCIIToUTF16(""Superman""))),
            changes[0]);
}

TEST_F(AutofillTableTest, Autofill_AddChanges) {
  WebDatabase db;
  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  TimeDelta one_day(TimeDelta::FromDays(1));
  Time t1 = Time::Now();
  Time t2 = t1 + one_day;

  AutofillChangeList changes;
  FormField field;
  field.name = ASCIIToUTF16(""Name"");
  field.value = ASCIIToUTF16(""Superman"");
  EXPECT_TRUE(
      db.GetAutofillTable()->AddFormFieldValueTime(field, &changes, t1));
  ASSERT_EQ(1U, changes.size());
  EXPECT_EQ(AutofillChange(AutofillChange::ADD,
                           AutofillKey(ASCIIToUTF16(""Name""),
                                       ASCIIToUTF16(""Superman""))),
            changes[0]);

  changes.clear();
  EXPECT_TRUE(
      db.GetAutofillTable()->AddFormFieldValueTime(field, &changes, t2));
  ASSERT_EQ(1U, changes.size());
  EXPECT_EQ(AutofillChange(AutofillChange::UPDATE,
                           AutofillKey(ASCIIToUTF16(""Name""),
                                       ASCIIToUTF16(""Superman""))),
            changes[0]);
}

TEST_F(AutofillTableTest, Autofill_UpdateOneWithOneTimestamp) {
  WebDatabase db;
  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  AutofillEntry entry(MakeAutofillEntry(""foo"", ""bar"", 1, -1));
  std::vector<AutofillEntry> entries;
  entries.push_back(entry);
  ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));

  FormField field;
  field.name = ASCIIToUTF16(""foo"");
  field.value = ASCIIToUTF16(""bar"");
  int64 pair_id;
  int count;
  ASSERT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
      field, &pair_id, &count));
  EXPECT_LE(0, pair_id);
  EXPECT_EQ(1, count);

  std::vector<AutofillEntry> all_entries;
  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&all_entries));
  ASSERT_EQ(1U, all_entries.size());
  EXPECT_TRUE(entry == all_entries[0]);
}

TEST_F(AutofillTableTest, Autofill_UpdateOneWithTwoTimestamps) {
  WebDatabase db;
  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  AutofillEntry entry(MakeAutofillEntry(""foo"", ""bar"", 1, 2));
  std::vector<AutofillEntry> entries;
  entries.push_back(entry);
  ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));

  FormField field;
  field.name = ASCIIToUTF16(""foo"");
  field.value = ASCIIToUTF16(""bar"");
  int64 pair_id;
  int count;
  ASSERT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
      field, &pair_id, &count));
  EXPECT_LE(0, pair_id);
  EXPECT_EQ(2, count);

  std::vector<AutofillEntry> all_entries;
  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&all_entries));
  ASSERT_EQ(1U, all_entries.size());
  EXPECT_TRUE(entry == all_entries[0]);
}

TEST_F(AutofillTableTest, Autofill_GetAutofillTimestamps) {
  WebDatabase db;
  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  AutofillEntry entry(MakeAutofillEntry(""foo"", ""bar"", 1, 2));
  std::vector<AutofillEntry> entries;
  entries.push_back(entry);
  ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));

  std::vector<Time> timestamps;
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillTimestamps(ASCIIToUTF16(""foo""),
                                                           ASCIIToUTF16(""bar""),
                                                           &timestamps));
  ASSERT_EQ(2U, timestamps.size());
  EXPECT_TRUE(Time::FromTimeT(1) == timestamps[0]);
  EXPECT_TRUE(Time::FromTimeT(2) == timestamps[1]);
}

TEST_F(AutofillTableTest, Autofill_UpdateTwo) {
  WebDatabase db;
  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  AutofillEntry entry0(MakeAutofillEntry(""foo"", ""bar0"", 1, -1));
  AutofillEntry entry1(MakeAutofillEntry(""foo"", ""bar1"", 2, 3));
  std::vector<AutofillEntry> entries;
  entries.push_back(entry0);
  entries.push_back(entry1);
  ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));

  FormField field0;
  field0.name = ASCIIToUTF16(""foo"");
  field0.value = ASCIIToUTF16(""bar0"");
  int64 pair_id;
  int count;
  ASSERT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
      field0, &pair_id, &count));
  EXPECT_LE(0, pair_id);
  EXPECT_EQ(1, count);

  FormField field1;
  field1.name = ASCIIToUTF16(""foo"");
  field1.value = ASCIIToUTF16(""bar1"");
  ASSERT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
      field1, &pair_id, &count));
  EXPECT_LE(0, pair_id);
  EXPECT_EQ(2, count);
}

TEST_F(AutofillTableTest, Autofill_UpdateReplace) {
  WebDatabase db;
  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  AutofillChangeList changes;
  // Add a form field.  This will be replaced.
  FormField field;
  field.name = ASCIIToUTF16(""Name"");
  field.value = ASCIIToUTF16(""Superman"");
  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(field, &changes));

  AutofillEntry entry(MakeAutofillEntry(""Name"", ""Superman"", 1, 2));
  std::vector<AutofillEntry> entries;
  entries.push_back(entry);
  ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));

  std::vector<AutofillEntry> all_entries;
  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&all_entries));
  ASSERT_EQ(1U, all_entries.size());
  EXPECT_TRUE(entry == all_entries[0]);
}

TEST_F(AutofillTableTest, Autofill_UpdateDontReplace) {
  WebDatabase db;
  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  Time t = Time::Now();
  AutofillEntry existing(
      MakeAutofillEntry(""Name"", ""Superman"", t.ToTimeT(), -1));

  AutofillChangeList changes;
  // Add a form field.  This will NOT be replaced.
  FormField field;
  field.name = existing.key().name();
  field.value = existing.key().value();
  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(field, &changes, t));
  AutofillEntry entry(MakeAutofillEntry(""Name"", ""Clark Kent"", 1, 2));
  std::vector<AutofillEntry> entries;
  entries.push_back(entry);
  ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));

  std::vector<AutofillEntry> all_entries;
  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&all_entries));
  ASSERT_EQ(2U, all_entries.size());
  AutofillEntrySet expected_entries(all_entries.begin(),
                                    all_entries.end(),
                                    CompareAutofillEntries);
  EXPECT_EQ(1U, expected_entries.count(existing));
  EXPECT_EQ(1U, expected_entries.count(entry));
}

TEST_F(AutofillTableTest, Autofill_AddFormFieldValues) {
  WebDatabase db;
  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  Time t = Time::Now();

  // Add multiple values for ""firstname"" and ""lastname"" names.  Test that only
  // first value of each gets added. Related to security issue:
  // http://crbug.com/51727.
  std::vector<FormField> elements;
  FormField field;
  field.name = ASCIIToUTF16(""firstname"");
  field.value = ASCIIToUTF16(""Joe"");
  elements.push_back(field);

  field.name = ASCIIToUTF16(""firstname"");
  field.value = ASCIIToUTF16(""Jane"");
  elements.push_back(field);

  field.name = ASCIIToUTF16(""lastname"");
  field.value = ASCIIToUTF16(""Smith"");
  elements.push_back(field);

  field.name = ASCIIToUTF16(""lastname"");
  field.value = ASCIIToUTF16(""Jones"");
  elements.push_back(field);

  std::vector<AutofillChange> changes;
  db.GetAutofillTable()->AddFormFieldValuesTime(elements, &changes, t);

  ASSERT_EQ(2U, changes.size());
  EXPECT_EQ(changes[0], AutofillChange(AutofillChange::ADD,
                                       AutofillKey(ASCIIToUTF16(""firstname""),
                                       ASCIIToUTF16(""Joe""))));
  EXPECT_EQ(changes[1], AutofillChange(AutofillChange::ADD,
                                       AutofillKey(ASCIIToUTF16(""lastname""),
                                       ASCIIToUTF16(""Smith""))));

  std::vector<AutofillEntry> all_entries;
  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&all_entries));
  ASSERT_EQ(2U, all_entries.size());
}

TEST_F(AutofillTableTest, AutofillProfile) {
  WebDatabase db;

  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  // Add a 'Home' profile.
  AutofillProfile home_profile;
  home_profile.SetInfo(NAME_FIRST, ASCIIToUTF16(""John""));
  home_profile.SetInfo(NAME_MIDDLE, ASCIIToUTF16(""Q.""));
  home_profile.SetInfo(NAME_LAST, ASCIIToUTF16(""Smith""));
  home_profile.SetInfo(EMAIL_ADDRESS, ASCIIToUTF16(""js@smith.xyz""));
  home_profile.SetInfo(COMPANY_NAME, ASCIIToUTF16(""Google""));
  home_profile.SetInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16(""1234 Apple Way""));
  home_profile.SetInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16(""unit 5""));
  home_profile.SetInfo(ADDRESS_HOME_CITY, ASCIIToUTF16(""Los Angeles""));
  home_profile.SetInfo(ADDRESS_HOME_STATE, ASCIIToUTF16(""CA""));
  home_profile.SetInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16(""90025""));
  home_profile.SetInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16(""US""));
  home_profile.SetInfo(PHONE_HOME_WHOLE_NUMBER, ASCIIToUTF16(""18181234567""));

  Time pre_creation_time = Time::Now();
  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(home_profile));
  Time post_creation_time = Time::Now();

  // Get the 'Home' profile.
  AutofillProfile* db_profile;
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(
      home_profile.guid(), &db_profile));
  EXPECT_EQ(home_profile, *db_profile);
  sql::Statement s_home(db.GetSQLConnection()->GetUniqueStatement(
      ""SELECT date_modified ""
      ""FROM autofill_profiles WHERE guid=?""));
  s_home.BindString(0, home_profile.guid());
  ASSERT_TRUE(s_home.is_valid());
  ASSERT_TRUE(s_home.Step());
  EXPECT_GE(s_home.ColumnInt64(0), pre_creation_time.ToTimeT());
  EXPECT_LE(s_home.ColumnInt64(0), post_creation_time.ToTimeT());
  EXPECT_FALSE(s_home.Step());
  delete db_profile;

  // Add a 'Billing' profile.
  AutofillProfile billing_profile = home_profile;
  billing_profile.set_guid(guid::GenerateGUID());
  billing_profile.SetInfo(ADDRESS_HOME_LINE1,
                          ASCIIToUTF16(""5678 Bottom Street""));
  billing_profile.SetInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16(""suite 3""));

  pre_creation_time = Time::Now();
  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(billing_profile));
  post_creation_time = Time::Now();

  // Get the 'Billing' profile.
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(
      billing_profile.guid(), &db_profile));
  EXPECT_EQ(billing_profile, *db_profile);
  sql::Statement s_billing(db.GetSQLConnection()->GetUniqueStatement(
      ""SELECT date_modified FROM autofill_profiles WHERE guid=?""));
  s_billing.BindString(0, billing_profile.guid());
  ASSERT_TRUE(s_billing.is_valid());
  ASSERT_TRUE(s_billing.Step());
  EXPECT_GE(s_billing.ColumnInt64(0), pre_creation_time.ToTimeT());
  EXPECT_LE(s_billing.ColumnInt64(0), post_creation_time.ToTimeT());
  EXPECT_FALSE(s_billing.Step());
  delete db_profile;

  // Update the 'Billing' profile, name only.
  billing_profile.SetInfo(NAME_FIRST, ASCIIToUTF16(""Jane""));
  Time pre_modification_time = Time::Now();
  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(
      billing_profile));
  Time post_modification_time = Time::Now();
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(
      billing_profile.guid(), &db_profile));
  EXPECT_EQ(billing_profile, *db_profile);
  sql::Statement s_billing_updated(db.GetSQLConnection()->GetUniqueStatement(
      ""SELECT date_modified FROM autofill_profiles WHERE guid=?""));
  s_billing_updated.BindString(0, billing_profile.guid());
  ASSERT_TRUE(s_billing_updated.is_valid());
  ASSERT_TRUE(s_billing_updated.Step());
  EXPECT_GE(s_billing_updated.ColumnInt64(0),
            pre_modification_time.ToTimeT());
  EXPECT_LE(s_billing_updated.ColumnInt64(0),
            post_modification_time.ToTimeT());
  EXPECT_FALSE(s_billing_updated.Step());
  delete db_profile;

  // Update the 'Billing' profile.
  billing_profile.SetInfo(NAME_FIRST, ASCIIToUTF16(""Janice""));
  billing_profile.SetInfo(NAME_MIDDLE, ASCIIToUTF16(""C.""));
  billing_profile.SetInfo(NAME_FIRST, ASCIIToUTF16(""Joplin""));
  billing_profile.SetInfo(EMAIL_ADDRESS, ASCIIToUTF16(""jane@singer.com""));
  billing_profile.SetInfo(COMPANY_NAME, ASCIIToUTF16(""Indy""));
  billing_profile.SetInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16(""Open Road""));
  billing_profile.SetInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16(""Route 66""));
  billing_profile.SetInfo(ADDRESS_HOME_CITY, ASCIIToUTF16(""NFA""));
  billing_profile.SetInfo(ADDRESS_HOME_STATE, ASCIIToUTF16(""NY""));
  billing_profile.SetInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16(""10011""));
  billing_profile.SetInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16(""United States""));
  billing_profile.SetInfo(PHONE_HOME_WHOLE_NUMBER, ASCIIToUTF16(""18181230000""));
  Time pre_modification_time_2 = Time::Now();
  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(
      billing_profile));
  Time post_modification_time_2 = Time::Now();
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(
      billing_profile.guid(), &db_profile));
  EXPECT_EQ(billing_profile, *db_profile);
  sql::Statement s_billing_updated_2(db.GetSQLConnection()->GetUniqueStatement(
      ""SELECT date_modified FROM autofill_profiles WHERE guid=?""));
  s_billing_updated_2.BindString(0, billing_profile.guid());
  ASSERT_TRUE(s_billing_updated_2.is_valid());
  ASSERT_TRUE(s_billing_updated_2.Step());
  EXPECT_GE(s_billing_updated_2.ColumnInt64(0),
            pre_modification_time_2.ToTimeT());
  EXPECT_LE(s_billing_updated_2.ColumnInt64(0),
            post_modification_time_2.ToTimeT());
  EXPECT_FALSE(s_billing_updated_2.Step());
  delete db_profile;

  // Remove the 'Billing' profile.
  EXPECT_TRUE(db.GetAutofillTable()->RemoveAutofillProfile(
      billing_profile.guid()));
  EXPECT_FALSE(db.GetAutofillTable()->GetAutofillProfile(
      billing_profile.guid(), &db_profile));
}

TEST_F(AutofillTableTest, AutofillProfileMultiValueNames) {
  WebDatabase db;
  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  AutofillProfile p;
  const string16 kJohnDoe(ASCIIToUTF16(""John Doe""));
  const string16 kJohnPDoe(ASCIIToUTF16(""John P. Doe""));
  std::vector<string16> set_values;
  set_values.push_back(kJohnDoe);
  set_values.push_back(kJohnPDoe);
  p.SetMultiInfo(NAME_FULL, set_values);

  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(p));

  AutofillProfile* db_profile;
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
  EXPECT_EQ(p, *db_profile);
  EXPECT_EQ(0, p.Compare(*db_profile));
  delete db_profile;

  // Update the values.
  const string16 kNoOne(ASCIIToUTF16(""No One""));
  set_values[1] = kNoOne;
  p.SetMultiInfo(NAME_FULL, set_values);
  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(p));
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
  EXPECT_EQ(p, *db_profile);
  EXPECT_EQ(0, p.Compare(*db_profile));
  delete db_profile;

  // Delete values.
  set_values.clear();
  p.SetMultiInfo(NAME_FULL, set_values);
  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(p));
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
  EXPECT_EQ(p, *db_profile);
  EXPECT_EQ(0, p.Compare(*db_profile));
  EXPECT_EQ(string16(), db_profile->GetInfo(NAME_FULL));
  delete db_profile;
}

TEST_F(AutofillTableTest, AutofillProfileSingleValue) {
  WebDatabase db;
  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  AutofillProfile p;
  const string16 kJohnDoe(ASCIIToUTF16(""John Doe""));
  const string16 kJohnPDoe(ASCIIToUTF16(""John P. Doe""));
  std::vector<string16> set_values;
  set_values.push_back(kJohnDoe);
  set_values.push_back(kJohnPDoe);
  p.SetMultiInfo(NAME_FULL, set_values);

  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(p));

  AutofillProfile* db_profile;
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
  EXPECT_EQ(p, *db_profile);
  EXPECT_EQ(0, p.Compare(*db_profile));
  delete db_profile;

  const string16 kNoOne(ASCIIToUTF16(""No One""));
  set_values.resize(1);
  set_values[0] = kNoOne;
  p.SetMultiInfo(NAME_FULL, set_values);
  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfile(p));
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
  EXPECT_EQ(p.PrimaryValue(), db_profile->PrimaryValue());
  EXPECT_EQ(p.guid(), db_profile->guid());
  EXPECT_NE(0, p.Compare(*db_profile));
  db_profile->GetMultiInfo(NAME_FULL, &set_values);
  ASSERT_EQ(2UL, set_values.size());
  EXPECT_EQ(kNoOne, set_values[0]);
  EXPECT_EQ(kJohnPDoe, set_values[1]);
  delete db_profile;
}

TEST_F(AutofillTableTest, AutofillProfileMultiValueEmails) {
  WebDatabase db;
  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  AutofillProfile p;
  const string16 kJohnDoe(ASCIIToUTF16(""john@doe.com""));
  const string16 kJohnPDoe(ASCIIToUTF16(""john_p@doe.com""));
  std::vector<string16> set_values;
  set_values.push_back(kJohnDoe);
  set_values.push_back(kJohnPDoe);
  p.SetMultiInfo(EMAIL_ADDRESS, set_values);

  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(p));

  AutofillProfile* db_profile;
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
  EXPECT_EQ(p, *db_profile);
  EXPECT_EQ(0, p.Compare(*db_profile));
  delete db_profile;

  // Update the values.
  const string16 kNoOne(ASCIIToUTF16(""no@one.com""));
  set_values[1] = kNoOne;
  p.SetMultiInfo(EMAIL_ADDRESS, set_values);
  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(p));
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
  EXPECT_EQ(p, *db_profile);
  EXPECT_EQ(0, p.Compare(*db_profile));
  delete db_profile;

  // Delete values.
  set_values.clear();
  p.SetMultiInfo(EMAIL_ADDRESS, set_values);
  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(p));
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
  EXPECT_EQ(p, *db_profile);
  EXPECT_EQ(0, p.Compare(*db_profile));
  EXPECT_EQ(string16(), db_profile->GetInfo(EMAIL_ADDRESS));
  delete db_profile;
}

TEST_F(AutofillTableTest, AutofillProfileMultiValuePhone) {
  WebDatabase db;
  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  AutofillProfile p;
  const string16 kJohnDoe(ASCIIToUTF16(""4151112222""));
  const string16 kJohnPDoe(ASCIIToUTF16(""4151113333""));
  std::vector<string16> set_values;
  set_values.push_back(kJohnDoe);
  set_values.push_back(kJohnPDoe);
  p.SetMultiInfo(PHONE_HOME_WHOLE_NUMBER, set_values);

  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(p));

  AutofillProfile* db_profile;
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
  EXPECT_EQ(p, *db_profile);
  EXPECT_EQ(0, p.Compare(*db_profile));
  delete db_profile;

  // Update the values.
  const string16 kNoOne(ASCIIToUTF16(""4151110000""));
  set_values[1] = kNoOne;
  p.SetMultiInfo(PHONE_HOME_WHOLE_NUMBER, set_values);
  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(p));
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
  EXPECT_EQ(p, *db_profile);
  EXPECT_EQ(0, p.Compare(*db_profile));
  delete db_profile;

  // Delete values.
  set_values.clear();
  p.SetMultiInfo(PHONE_HOME_WHOLE_NUMBER, set_values);
  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(p));
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
  EXPECT_EQ(p, *db_profile);
  EXPECT_EQ(0, p.Compare(*db_profile));
  EXPECT_EQ(string16(), db_profile->GetInfo(EMAIL_ADDRESS));
  delete db_profile;
}

TEST_F(AutofillTableTest, AutofillProfileTrash) {
  WebDatabase db;

  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  std::vector<std::string> guids;
  db.GetAutofillTable()->GetAutofillProfilesInTrash(&guids);
  EXPECT_TRUE(guids.empty());

  ASSERT_TRUE(db.GetAutofillTable()->AddAutofillGUIDToTrash(
      ""00000000-0000-0000-0000-000000000000""));
  ASSERT_TRUE(db.GetAutofillTable()->AddAutofillGUIDToTrash(
      ""00000000-0000-0000-0000-000000000001""));
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfilesInTrash(&guids));
  EXPECT_EQ(2UL, guids.size());
  EXPECT_EQ(""00000000-0000-0000-0000-000000000000"", guids[0]);
  EXPECT_EQ(""00000000-0000-0000-0000-000000000001"", guids[1]);

  ASSERT_TRUE(db.GetAutofillTable()->EmptyAutofillProfilesTrash());
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfilesInTrash(&guids));
  EXPECT_TRUE(guids.empty());
}

TEST_F(AutofillTableTest, AutofillProfileTrashInteraction) {
  WebDatabase db;

  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  std::vector<std::string> guids;
  db.GetAutofillTable()->GetAutofillProfilesInTrash(&guids);
  EXPECT_TRUE(guids.empty());

  AutofillProfile profile;
  profile.SetInfo(NAME_FIRST, ASCIIToUTF16(""John""));
  profile.SetInfo(NAME_MIDDLE, ASCIIToUTF16(""Q.""));
  profile.SetInfo(NAME_LAST, ASCIIToUTF16(""Smith""));
  profile.SetInfo(EMAIL_ADDRESS,ASCIIToUTF16(""js@smith.xyz""));
  profile.SetInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16(""1 Main St""));
  profile.SetInfo(ADDRESS_HOME_CITY, ASCIIToUTF16(""Los Angeles""));
  profile.SetInfo(ADDRESS_HOME_STATE, ASCIIToUTF16(""CA""));
  profile.SetInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16(""90025""));
  profile.SetInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16(""US""));

  // Mark this profile as in the trash.  This stops |AddAutofillProfile| from
  // adding it.
  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillGUIDToTrash(profile.guid()));
  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(profile));
  AutofillProfile* added_profile = NULL;
  EXPECT_FALSE(db.GetAutofillTable()->GetAutofillProfile(
      profile.guid(), &added_profile));
  EXPECT_EQ(static_cast<AutofillProfile*>(NULL), added_profile);

  // Add the profile for real this time.
  EXPECT_TRUE(db.GetAutofillTable()->EmptyAutofillProfilesTrash());
  EXPECT_TRUE(db.GetAutofillTable()->GetAutofillProfilesInTrash(&guids));
  EXPECT_TRUE(guids.empty());
  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(profile));
  EXPECT_TRUE(db.GetAutofillTable()->GetAutofillProfile(profile.guid(),
                                                        &added_profile));
  ASSERT_NE(static_cast<AutofillProfile*>(NULL), added_profile);
  delete added_profile;

  // Mark this profile as in the trash.  This stops |UpdateAutofillProfileMulti|
  // from updating it.  In normal operation a profile should not be both in the
  // trash and in the profiles table simultaneously.
  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillGUIDToTrash(profile.guid()));
  profile.SetInfo(NAME_FIRST, ASCIIToUTF16(""Jane""));
  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(profile));
  AutofillProfile* updated_profile = NULL;
  EXPECT_TRUE(db.GetAutofillTable()->GetAutofillProfile(
      profile.guid(), &updated_profile));
  ASSERT_NE(static_cast<AutofillProfile*>(NULL), added_profile);
  EXPECT_EQ(ASCIIToUTF16(""John""), updated_profile->GetInfo(NAME_FIRST));
  delete updated_profile;

  // Try to delete the trashed profile.  This stops |RemoveAutofillProfile| from
  // deleting it.  In normal operation deletion is done by migration step, and
  // removal from trash is done by |WebDataService|.  |RemoveAutofillProfile|
  // does remove the item from the trash if it is found however, so that if
  // other clients remove it (via Sync say) then it is gone and doesn't need to
  // be processed further by |WebDataService|.
  EXPECT_TRUE(db.GetAutofillTable()->RemoveAutofillProfile(profile.guid()));
  AutofillProfile* removed_profile = NULL;
  EXPECT_TRUE(db.GetAutofillTable()->GetAutofillProfile(profile.guid(),
                                                        &removed_profile));
  EXPECT_FALSE(db.GetAutofillTable()->IsAutofillGUIDInTrash(profile.guid()));
  ASSERT_NE(static_cast<AutofillProfile*>(NULL), removed_profile);
  delete removed_profile;

  // Check that emptying the trash now allows removal to occur.
  EXPECT_TRUE(db.GetAutofillTable()->EmptyAutofillProfilesTrash());
  EXPECT_TRUE(db.GetAutofillTable()->RemoveAutofillProfile(profile.guid()));
  removed_profile = NULL;
  EXPECT_FALSE(db.GetAutofillTable()->GetAutofillProfile(profile.guid(),
                                                         &removed_profile));
  EXPECT_EQ(static_cast<AutofillProfile*>(NULL), removed_profile);
}

TEST_F(AutofillTableTest, CreditCard) {
  WebDatabase db;

  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  // Add a 'Work' credit card.
  CreditCard work_creditcard;
  work_creditcard.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16(""Jack Torrance""));
  work_creditcard.SetInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16(""1234567890123456""));
  work_creditcard.SetInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16(""04""));
  work_creditcard.SetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16(""2013""));

  Time pre_creation_time = Time::Now();
  EXPECT_TRUE(db.GetAutofillTable()->AddCreditCard(work_creditcard));
  Time post_creation_time = Time::Now();

  // Get the 'Work' credit card.
  CreditCard* db_creditcard;
  ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(work_creditcard.guid(),
                                                   &db_creditcard));
  EXPECT_EQ(work_creditcard, *db_creditcard);
  sql::Statement s_work(db.GetSQLConnection()->GetUniqueStatement(
      ""SELECT guid, name_on_card, expiration_month, expiration_year, ""
      ""card_number_encrypted, date_modified ""
      ""FROM credit_cards WHERE guid=?""));
  s_work.BindString(0, work_creditcard.guid());
  ASSERT_TRUE(s_work.is_valid());
  ASSERT_TRUE(s_work.Step());
  EXPECT_GE(s_work.ColumnInt64(5), pre_creation_time.ToTimeT());
  EXPECT_LE(s_work.ColumnInt64(5), post_creation_time.ToTimeT());
  EXPECT_FALSE(s_work.Step());
  delete db_creditcard;

  // Add a 'Target' credit card.
  CreditCard target_creditcard;
  target_creditcard.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16(""Jack Torrance""));
  target_creditcard.SetInfo(CREDIT_CARD_NUMBER,
                            ASCIIToUTF16(""1111222233334444""));
  target_creditcard.SetInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16(""06""));
  target_creditcard.SetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16(""2012""));

  pre_creation_time = Time::Now();
  EXPECT_TRUE(db.GetAutofillTable()->AddCreditCard(target_creditcard));
  post_creation_time = Time::Now();
  ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(target_creditcard.guid(),
                                                   &db_creditcard));
  EXPECT_EQ(target_creditcard, *db_creditcard);
  sql::Statement s_target(db.GetSQLConnection()->GetUniqueStatement(
      ""SELECT guid, name_on_card, expiration_month, expiration_year, ""
      ""card_number_encrypted, date_modified ""
      ""FROM credit_cards WHERE guid=?""));
  s_target.BindString(0, target_creditcard.guid());
  ASSERT_TRUE(s_target.is_valid());
  ASSERT_TRUE(s_target.Step());
  EXPECT_GE(s_target.ColumnInt64(5), pre_creation_time.ToTimeT());
  EXPECT_LE(s_target.ColumnInt64(5), post_creation_time.ToTimeT());
  EXPECT_FALSE(s_target.Step());
  delete db_creditcard;

  // Update the 'Target' credit card.
  target_creditcard.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16(""Charles Grady""));
  Time pre_modification_time = Time::Now();
  EXPECT_TRUE(db.GetAutofillTable()->UpdateCreditCard(target_creditcard));
  Time post_modification_time = Time::Now();
  ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(target_creditcard.guid(),
                                                   &db_creditcard));
  EXPECT_EQ(target_creditcard, *db_creditcard);
  sql::Statement s_target_updated(db.GetSQLConnection()->GetUniqueStatement(
      ""SELECT guid, name_on_card, expiration_month, expiration_year, ""
      ""card_number_encrypted, date_modified ""
      ""FROM credit_cards WHERE guid=?""));
  s_target_updated.BindString(0, target_creditcard.guid());
  ASSERT_TRUE(s_target_updated.is_valid());
  ASSERT_TRUE(s_target_updated.Step());
  EXPECT_GE(s_target_updated.ColumnInt64(5), pre_modification_time.ToTimeT());
  EXPECT_LE(s_target_updated.ColumnInt64(5), post_modification_time.ToTimeT());
  EXPECT_FALSE(s_target_updated.Step());
  delete db_creditcard;

  // Remove the 'Target' credit card.
  EXPECT_TRUE(db.GetAutofillTable()->RemoveCreditCard(
      target_creditcard.guid()));
  EXPECT_FALSE(db.GetAutofillTable()->GetCreditCard(target_creditcard.guid(),
                                                    &db_creditcard));
}

TEST_F(AutofillTableTest, UpdateAutofillProfile) {
  WebDatabase db;
  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  // Add a profile to the db.
  AutofillProfile profile;
  profile.SetInfo(NAME_FIRST, ASCIIToUTF16(""John""));
  profile.SetInfo(NAME_MIDDLE, ASCIIToUTF16(""Q.""));
  profile.SetInfo(NAME_LAST, ASCIIToUTF16(""Smith""));
  profile.SetInfo(EMAIL_ADDRESS, ASCIIToUTF16(""js@example.com""));
  profile.SetInfo(COMPANY_NAME, ASCIIToUTF16(""Google""));
  profile.SetInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16(""1234 Apple Way""));
  profile.SetInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16(""unit 5""));
  profile.SetInfo(ADDRESS_HOME_CITY, ASCIIToUTF16(""Los Angeles""));
  profile.SetInfo(ADDRESS_HOME_STATE, ASCIIToUTF16(""CA""));
  profile.SetInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16(""90025""));
  profile.SetInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16(""US""));
  profile.SetInfo(PHONE_HOME_WHOLE_NUMBER, ASCIIToUTF16(""18181234567""));
  db.GetAutofillTable()->AddAutofillProfile(profile);

  // Set a mocked value for the profile's creation time.
  const time_t mock_creation_date = Time::Now().ToTimeT() - 13;
  sql::Statement s_mock_creation_date(db.GetSQLConnection()->GetUniqueStatement(
      ""UPDATE autofill_profiles SET date_modified = ?""));
  ASSERT_TRUE(s_mock_creation_date.is_valid());
  s_mock_creation_date.BindInt64(0, mock_creation_date);
  ASSERT_TRUE(s_mock_creation_date.Run());

  // Get the profile.
  AutofillProfile* tmp_profile;
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(profile.guid(),
                                                        &tmp_profile));
  scoped_ptr<AutofillProfile> db_profile(tmp_profile);
  EXPECT_EQ(profile, *db_profile);
  sql::Statement s_original(db.GetSQLConnection()->GetUniqueStatement(
      ""SELECT date_modified FROM autofill_profiles""));
  ASSERT_TRUE(s_original.is_valid());
  ASSERT_TRUE(s_original.Step());
  EXPECT_EQ(mock_creation_date, s_original.ColumnInt64(0));
  EXPECT_FALSE(s_original.Step());

  // Now, update the profile and save the update to the database.
  // The modification date should change to reflect the update.
  profile.SetInfo(EMAIL_ADDRESS, ASCIIToUTF16(""js@smith.xyz""));
  db.GetAutofillTable()->UpdateAutofillProfileMulti(profile);

  // Get the profile.
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(profile.guid(),
                                                        &tmp_profile));
  db_profile.reset(tmp_profile);
  EXPECT_EQ(profile, *db_profile);
  sql::Statement s_updated(db.GetSQLConnection()->GetUniqueStatement(
      ""SELECT date_modified FROM autofill_profiles""));
  ASSERT_TRUE(s_updated.is_valid());
  ASSERT_TRUE(s_updated.Step());
  EXPECT_LT(mock_creation_date, s_updated.ColumnInt64(0));
  EXPECT_FALSE(s_updated.Step());

  // Set a mocked value for the profile's modification time.
  const time_t mock_modification_date = Time::Now().ToTimeT() - 7;
  sql::Statement s_mock_modification_date(
      db.GetSQLConnection()->GetUniqueStatement(
          ""UPDATE autofill_profiles SET date_modified = ?""));
  ASSERT_TRUE(s_mock_modification_date.is_valid());
  s_mock_modification_date.BindInt64(0, mock_modification_date);
  ASSERT_TRUE(s_mock_modification_date.Run());

  // Finally, call into |UpdateAutofillProfileMulti()| without changing the
  // profile.  The modification date should not change.
  db.GetAutofillTable()->UpdateAutofillProfileMulti(profile);

  // Get the profile.
  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(profile.guid(),
                                                        &tmp_profile));
  db_profile.reset(tmp_profile);
  EXPECT_EQ(profile, *db_profile);
  sql::Statement s_unchanged(db.GetSQLConnection()->GetUniqueStatement(
      ""SELECT date_modified FROM autofill_profiles""));
  ASSERT_TRUE(s_unchanged.is_valid());
  ASSERT_TRUE(s_unchanged.Step());
  EXPECT_EQ(mock_modification_date, s_unchanged.ColumnInt64(0));
  EXPECT_FALSE(s_unchanged.Step());
}

TEST_F(AutofillTableTest, UpdateCreditCard) {
  WebDatabase db;
  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  // Add a credit card to the db.
  CreditCard credit_card;
  credit_card.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16(""Jack Torrance""));
  credit_card.SetInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16(""1234567890123456""));
  credit_card.SetInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16(""04""));
  credit_card.SetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16(""2013""));
  db.GetAutofillTable()->AddCreditCard(credit_card);

  // Set a mocked value for the credit card's creation time.
  const time_t mock_creation_date = Time::Now().ToTimeT() - 13;
  sql::Statement s_mock_creation_date(db.GetSQLConnection()->GetUniqueStatement(
      ""UPDATE credit_cards SET date_modified = ?""));
  ASSERT_TRUE(s_mock_creation_date.is_valid());
  s_mock_creation_date.BindInt64(0, mock_creation_date);
  ASSERT_TRUE(s_mock_creation_date.Run());

  // Get the credit card.
  CreditCard* tmp_credit_card;
  ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(credit_card.guid(),
                                                   &tmp_credit_card));
  scoped_ptr<CreditCard> db_credit_card(tmp_credit_card);
  EXPECT_EQ(credit_card, *db_credit_card);
  sql::Statement s_original(db.GetSQLConnection()->GetUniqueStatement(
      ""SELECT date_modified FROM credit_cards""));
  ASSERT_TRUE(s_original.is_valid());
  ASSERT_TRUE(s_original.Step());
  EXPECT_EQ(mock_creation_date, s_original.ColumnInt64(0));
  EXPECT_FALSE(s_original.Step());

  // Now, update the credit card and save the update to the database.
  // The modification date should change to reflect the update.
  credit_card.SetInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16(""01""));
  db.GetAutofillTable()->UpdateCreditCard(credit_card);

  // Get the credit card.
  ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(credit_card.guid(),
                                                   &tmp_credit_card));
  db_credit_card.reset(tmp_credit_card);
  EXPECT_EQ(credit_card, *db_credit_card);
  sql::Statement s_updated(db.GetSQLConnection()->GetUniqueStatement(
      ""SELECT date_modified FROM credit_cards""));
  ASSERT_TRUE(s_updated.is_valid());
  ASSERT_TRUE(s_updated.Step());
  EXPECT_LT(mock_creation_date, s_updated.ColumnInt64(0));
  EXPECT_FALSE(s_updated.Step());

  // Set a mocked value for the credit card's modification time.
  const time_t mock_modification_date = Time::Now().ToTimeT() - 7;
  sql::Statement s_mock_modification_date(
      db.GetSQLConnection()->GetUniqueStatement(
          ""UPDATE credit_cards SET date_modified = ?""));
  ASSERT_TRUE(s_mock_modification_date.is_valid());
  s_mock_modification_date.BindInt64(0, mock_modification_date);
  ASSERT_TRUE(s_mock_modification_date.Run());

  // Finally, call into |UpdateCreditCard()| without changing the credit card.
  // The modification date should not change.
  db.GetAutofillTable()->UpdateCreditCard(credit_card);

  // Get the profile.
  ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(credit_card.guid(),
                                                   &tmp_credit_card));
  db_credit_card.reset(tmp_credit_card);
  EXPECT_EQ(credit_card, *db_credit_card);
  sql::Statement s_unchanged(db.GetSQLConnection()->GetUniqueStatement(
      ""SELECT date_modified FROM credit_cards""));
  ASSERT_TRUE(s_unchanged.is_valid());
  ASSERT_TRUE(s_unchanged.Step());
  EXPECT_EQ(mock_modification_date, s_unchanged.ColumnInt64(0));
  EXPECT_FALSE(s_unchanged.Step());
}

TEST_F(AutofillTableTest, RemoveAutofillProfilesAndCreditCardsModifiedBetween) {
  WebDatabase db;
  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  // Populate the autofill_profiles and credit_cards tables.
  ASSERT_TRUE(db.GetSQLConnection()->Execute(
      ""INSERT INTO autofill_profiles (guid, date_modified) ""
      ""VALUES('00000000-0000-0000-0000-000000000000', 11);""
      ""INSERT INTO autofill_profiles (guid, date_modified) ""
      ""VALUES('00000000-0000-0000-0000-000000000001', 21);""
      ""INSERT INTO autofill_profiles (guid, date_modified) ""
      ""VALUES('00000000-0000-0000-0000-000000000002', 31);""
      ""INSERT INTO autofill_profiles (guid, date_modified) ""
      ""VALUES('00000000-0000-0000-0000-000000000003', 41);""
      ""INSERT INTO autofill_profiles (guid, date_modified) ""
      ""VALUES('00000000-0000-0000-0000-000000000004', 51);""
      ""INSERT INTO autofill_profiles (guid, date_modified) ""
      ""VALUES('00000000-0000-0000-0000-000000000005', 61);""
      ""INSERT INTO credit_cards (guid, date_modified) ""
      ""VALUES('00000000-0000-0000-0000-000000000006', 17);""
      ""INSERT INTO credit_cards (guid, date_modified) ""
      ""VALUES('00000000-0000-0000-0000-000000000007', 27);""
      ""INSERT INTO credit_cards (guid, date_modified) ""
      ""VALUES('00000000-0000-0000-0000-000000000008', 37);""
      ""INSERT INTO credit_cards (guid, date_modified) ""
      ""VALUES('00000000-0000-0000-0000-000000000009', 47);""
      ""INSERT INTO credit_cards (guid, date_modified) ""
      ""VALUES('00000000-0000-0000-0000-000000000010', 57);""
      ""INSERT INTO credit_cards (guid, date_modified) ""
      ""VALUES('00000000-0000-0000-0000-000000000011', 67);""));

  // Remove all entries modified in the bounded time range [17,41).
  std::vector<std::string> profile_guids;
  std::vector<std::string> credit_card_guids;
  db.GetAutofillTable()->RemoveAutofillProfilesAndCreditCardsModifiedBetween(
      Time::FromTimeT(17), Time::FromTimeT(41),
      &profile_guids, &credit_card_guids);
  ASSERT_EQ(2UL, profile_guids.size());
  EXPECT_EQ(""00000000-0000-0000-0000-000000000001"", profile_guids[0]);
  EXPECT_EQ(""00000000-0000-0000-0000-000000000002"", profile_guids[1]);
  sql::Statement s_autofill_profiles_bounded(
      db.GetSQLConnection()->GetUniqueStatement(
          ""SELECT date_modified FROM autofill_profiles""));
  ASSERT_TRUE(s_autofill_profiles_bounded.is_valid());
  ASSERT_TRUE(s_autofill_profiles_bounded.Step());
  EXPECT_EQ(11, s_autofill_profiles_bounded.ColumnInt64(0));
  ASSERT_TRUE(s_autofill_profiles_bounded.Step());
  EXPECT_EQ(41, s_autofill_profiles_bounded.ColumnInt64(0));
  ASSERT_TRUE(s_autofill_profiles_bounded.Step());
  EXPECT_EQ(51, s_autofill_profiles_bounded.ColumnInt64(0));
  ASSERT_TRUE(s_autofill_profiles_bounded.Step());
  EXPECT_EQ(61, s_autofill_profiles_bounded.ColumnInt64(0));
  EXPECT_FALSE(s_autofill_profiles_bounded.Step());
  ASSERT_EQ(3UL, credit_card_guids.size());
  EXPECT_EQ(""00000000-0000-0000-0000-000000000006"", credit_card_guids[0]);
  EXPECT_EQ(""00000000-0000-0000-0000-000000000007"", credit_card_guids[1]);
  EXPECT_EQ(""00000000-0000-0000-0000-000000000008"", credit_card_guids[2]);
  sql::Statement s_credit_cards_bounded(
      db.GetSQLConnection()->GetUniqueStatement(
          ""SELECT date_modified FROM credit_cards""));
  ASSERT_TRUE(s_credit_cards_bounded.is_valid());
  ASSERT_TRUE(s_credit_cards_bounded.Step());
  EXPECT_EQ(47, s_credit_cards_bounded.ColumnInt64(0));
  ASSERT_TRUE(s_credit_cards_bounded.Step());
  EXPECT_EQ(57, s_credit_cards_bounded.ColumnInt64(0));
  ASSERT_TRUE(s_credit_cards_bounded.Step());
  EXPECT_EQ(67, s_credit_cards_bounded.ColumnInt64(0));
  EXPECT_FALSE(s_credit_cards_bounded.Step());

  // Remove all entries modified on or after time 51 (unbounded range).
  db.GetAutofillTable()->RemoveAutofillProfilesAndCreditCardsModifiedBetween(
      Time::FromTimeT(51), Time(),
      &profile_guids, &credit_card_guids);
  ASSERT_EQ(2UL, profile_guids.size());
  EXPECT_EQ(""00000000-0000-0000-0000-000000000004"", profile_guids[0]);
  EXPECT_EQ(""00000000-0000-0000-0000-000000000005"", profile_guids[1]);
  sql::Statement s_autofill_profiles_unbounded(
      db.GetSQLConnection()->GetUniqueStatement(
          ""SELECT date_modified FROM autofill_profiles""));
  ASSERT_TRUE(s_autofill_profiles_unbounded.is_valid());
  ASSERT_TRUE(s_autofill_profiles_unbounded.Step());
  EXPECT_EQ(11, s_autofill_profiles_unbounded.ColumnInt64(0));
  ASSERT_TRUE(s_autofill_profiles_unbounded.Step());
  EXPECT_EQ(41, s_autofill_profiles_unbounded.ColumnInt64(0));
  EXPECT_FALSE(s_autofill_profiles_unbounded.Step());
  ASSERT_EQ(2UL, credit_card_guids.size());
  EXPECT_EQ(""00000000-0000-0000-0000-000000000010"", credit_card_guids[0]);
  EXPECT_EQ(""00000000-0000-0000-0000-000000000011"", credit_card_guids[1]);
  sql::Statement s_credit_cards_unbounded(
      db.GetSQLConnection()->GetUniqueStatement(
          ""SELECT date_modified FROM credit_cards""));
  ASSERT_TRUE(s_credit_cards_unbounded.is_valid());
  ASSERT_TRUE(s_credit_cards_unbounded.Step());
  EXPECT_EQ(47, s_credit_cards_unbounded.ColumnInt64(0));
  EXPECT_FALSE(s_credit_cards_unbounded.Step());

  // Remove all remaining entries.
  db.GetAutofillTable()->RemoveAutofillProfilesAndCreditCardsModifiedBetween(
      Time(), Time(),
      &profile_guids, &credit_card_guids);
  ASSERT_EQ(2UL, profile_guids.size());
  EXPECT_EQ(""00000000-0000-0000-0000-000000000000"", profile_guids[0]);
  EXPECT_EQ(""00000000-0000-0000-0000-000000000003"", profile_guids[1]);
  sql::Statement s_autofill_profiles_empty(
      db.GetSQLConnection()->GetUniqueStatement(
          ""SELECT date_modified FROM autofill_profiles""));
  ASSERT_TRUE(s_autofill_profiles_empty.is_valid());
  EXPECT_FALSE(s_autofill_profiles_empty.Step());
  ASSERT_EQ(1UL, credit_card_guids.size());
  EXPECT_EQ(""00000000-0000-0000-0000-000000000009"", credit_card_guids[0]);
  sql::Statement s_credit_cards_empty(
      db.GetSQLConnection()->GetUniqueStatement(
          ""SELECT date_modified FROM credit_cards""));
  ASSERT_TRUE(s_credit_cards_empty.is_valid());
  EXPECT_FALSE(s_credit_cards_empty.Step());
}

TEST_F(AutofillTableTest, Autofill_GetAllAutofillEntries_NoResults) {
  WebDatabase db;

  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  std::vector<AutofillEntry> entries;
  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&entries));

  EXPECT_EQ(0U, entries.size());
}

TEST_F(AutofillTableTest, Autofill_GetAllAutofillEntries_OneResult) {
  WebDatabase db;

  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  AutofillChangeList changes;
  std::map<std::string, std::vector<Time> > name_value_times_map;

  time_t start = 0;
  std::vector<Time> timestamps1;
  FormField field;
  field.name = ASCIIToUTF16(""Name"");
  field.value = ASCIIToUTF16(""Superman"");
  EXPECT_TRUE(
      db.GetAutofillTable()->AddFormFieldValueTime(field, &changes,
                                                   Time::FromTimeT(start)));
  timestamps1.push_back(Time::FromTimeT(start));
  std::string key1(""NameSuperman"");
  name_value_times_map.insert(std::pair<std::string,
    std::vector<Time> > (key1, timestamps1));

  AutofillEntrySet expected_entries(CompareAutofillEntries);
  AutofillKey ak1(ASCIIToUTF16(""Name""), ASCIIToUTF16(""Superman""));
  AutofillEntry ae1(ak1, timestamps1);

  expected_entries.insert(ae1);

  std::vector<AutofillEntry> entries;
  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&entries));
  AutofillEntrySet entry_set(entries.begin(), entries.end(),
    CompareAutofillEntries);

  // make sure the lists of entries match
  ASSERT_EQ(expected_entries.size(), entry_set.size());
  AutofillEntrySetIterator it;
  for (it = entry_set.begin(); it != entry_set.end(); it++) {
    expected_entries.erase(*it);
  }

  EXPECT_EQ(0U, expected_entries.size());
}

TEST_F(AutofillTableTest, Autofill_GetAllAutofillEntries_TwoDistinct) {
  WebDatabase db;

  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  AutofillChangeList changes;
  std::map<std::string, std::vector<Time> > name_value_times_map;
  time_t start = 0;

  std::vector<Time> timestamps1;
  FormField field;
  field.name = ASCIIToUTF16(""Name"");
  field.value = ASCIIToUTF16(""Superman"");
  EXPECT_TRUE(
      db.GetAutofillTable()->AddFormFieldValueTime(field, &changes,
                                                   Time::FromTimeT(start)));
  timestamps1.push_back(Time::FromTimeT(start));
  std::string key1(""NameSuperman"");
  name_value_times_map.insert(std::pair<std::string,
    std::vector<Time> > (key1, timestamps1));

  start++;
  std::vector<Time> timestamps2;
  field.name = ASCIIToUTF16(""Name"");
  field.value = ASCIIToUTF16(""Clark Kent"");
  EXPECT_TRUE(
      db.GetAutofillTable()->AddFormFieldValueTime(field, &changes,
                                                   Time::FromTimeT(start)));
  timestamps2.push_back(Time::FromTimeT(start));
  std::string key2(""NameClark Kent"");
  name_value_times_map.insert(std::pair<std::string,
    std::vector<Time> > (key2, timestamps2));

  AutofillEntrySet expected_entries(CompareAutofillEntries);
  AutofillKey ak1(ASCIIToUTF16(""Name""), ASCIIToUTF16(""Superman""));
  AutofillKey ak2(ASCIIToUTF16(""Name""), ASCIIToUTF16(""Clark Kent""));
  AutofillEntry ae1(ak1, timestamps1);
  AutofillEntry ae2(ak2, timestamps2);

  expected_entries.insert(ae1);
  expected_entries.insert(ae2);

  std::vector<AutofillEntry> entries;
  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&entries));
  AutofillEntrySet entry_set(entries.begin(), entries.end(),
    CompareAutofillEntries);

  // make sure the lists of entries match
  ASSERT_EQ(expected_entries.size(), entry_set.size());
  AutofillEntrySetIterator it;
  for (it = entry_set.begin(); it != entry_set.end(); it++) {
    expected_entries.erase(*it);
  }

  EXPECT_EQ(0U, expected_entries.size());
}

TEST_F(AutofillTableTest, Autofill_GetAllAutofillEntries_TwoSame) {
  WebDatabase db;

  ASSERT_EQ(sql::INIT_OK, db.Init(file_));

  AutofillChangeList changes;
  std::map<std::string, std::vector<Time> > name_value_times_map;

  time_t start = 0;
  std::vector<Time> timestamps;
  for (int i = 0; i < 2; i++) {
    FormField field;
    field.name = ASCIIToUTF16(""Name"");
    field.value = ASCIIToUTF16(""Superman"");
    EXPECT_TRUE(
        db.GetAutofillTable()->AddFormFieldValueTime(field, &changes,
                                                     Time::FromTimeT(start)));
    timestamps.push_back(Time::FromTimeT(start));
    start++;
  }

  std::string key(""NameSuperman"");
  name_value_times_map.insert(std::pair<std::string,
      std::vector<Time> > (key, timestamps));

  AutofillEntrySet expected_entries(CompareAutofillEntries);
  AutofillKey ak1(ASCIIToUTF16(""Name""), ASCIIToUTF16(""Superman""));
  AutofillEntry ae1(ak1, timestamps);

  expected_entries.insert(ae1);

  std::vector<AutofillEntry> entries;
  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&entries));
  AutofillEntrySet entry_set(entries.begin(), entries.end(),
    CompareAutofillEntries);

  // make sure the lists of entries match
  ASSERT_EQ(expected_entries.size(), entry_set.size());
  AutofillEntrySetIterator it;
  for (it = entry_set.begin(); it != entry_set.end(); it++) {
    expected_entries.erase(*it);
  }

  EXPECT_EQ(0U, expected_entries.size());
}
",16339,True,3264.9318866553713,median
"[[main-component]]
= Main Component
:docTitle: Main
:artifactId: camel-main
:description: Camel Main support
:since: 3.0
:supportLevel: Stable
//Manually maintained attributes
:group: Core

*Since Camel {since}*

This module is used for running Camel standalone via a main class extended from `camel-main`.

== Configuration options

When running Camel via `camel-main` you can configure Camel in the `application.properties` file.

The following table lists all the options:

// main options: START
[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *camel.main.allowUseOriginal{zwsp}Message* | Sets whether to allow access to the original message from Camel's error handler, or from org.apache.camel.spi.UnitOfWork.getOriginalInMessage(). Turning this off can optimize performance, as defensive copy of the original message is not needed. Default is false. |  | boolean
| *camel.main.autoConfiguration{zwsp}Enabled* | Whether auto configuration of components, dataformats, languages is enabled or not. When enabled the configuration parameters are loaded from the properties component and optionally from the classpath file META-INF/services/org/apache/camel/autowire.properties. You can prefix the parameters in the properties file with: - camel.component.name.option1=value1 - camel.component.name.option2=value2 - camel.dataformat.name.option1=value1 - camel.dataformat.name.option2=value2 - camel.language.name.option1=value1 - camel.language.name.option2=value2 Where name is the name of the component, dataformat or language such as seda,direct,jaxb. The auto configuration also works for any options on components that is a complex type (not standard Java type) and there has been an explicit single bean instance registered to the Camel registry via the org.apache.camel.spi.Registry#bind(String,Object) method or by using the org.apache.camel.BindToRegistry annotation style. This option is default enabled. | true | boolean
| *camel.main.autoConfiguration{zwsp}EnvironmentVariablesEnabled* | Whether auto configuration should include OS environment variables as well. When enabled this allows to overrule any configuration using an OS environment variable. For example to set a shutdown timeout of 5 seconds: CAMEL_MAIN_SHUTDOWNTIMEOUT=5. This option is default enabled. | true | boolean
| *camel.main.autoConfiguration{zwsp}FailFast* | Whether auto configuration should fail fast when configuring one ore more properties fails for whatever reason such as a invalid property name, etc. This option is default enabled. | true | boolean
| *camel.main.autoConfiguration{zwsp}LogSummary* | Whether auto configuration should log a summary with the configured properties. This option is default enabled. | true | boolean
| *camel.main.autoStartup* | Sets whether the object should automatically start when Camel starts. Important: Currently only routes can be disabled, as CamelContext's are always started. Note: When setting auto startup false on CamelContext then that takes precedence and no routes are started. You would need to start CamelContext explicit using the org.apache.camel.CamelContext.start() method, to start the context, and then you would need to start the routes manually using CamelContext.getRouteController().startRoute(String). Default is true to always start up. | true | boolean
| *camel.main.autowiredEnabled* | Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. Default is true. | true | boolean
| *camel.main.backlogTracing* | Sets whether backlog tracing is enabled or not. Default is false. |  | boolean
| *camel.main.beanIntrospection{zwsp}ExtendedStatistics* | Sets whether bean introspection uses extended statistics. The default is false. |  | boolean
| *camel.main.beanIntrospection{zwsp}LoggingLevel* | Sets the logging level used by bean introspection, logging activity of its usage. The default is TRACE. |  | LoggingLevel
| *camel.main.beanPostProcessor{zwsp}Enabled* | Can be used to turn off bean post processing. Be careful to turn this off, as this means that beans that use Camel annotations such as org.apache.camel.EndpointInject , org.apache.camel.ProducerTemplate , org.apache.camel.Produce , org.apache.camel.Consume etc will not be injected and in use. Turning this off should only be done if you are sure you do not use any of these Camel features. Not all runtimes allow turning this off (such as camel-blueprint or camel-cdi with XML). The default value is true (enabled). | true | boolean
| *camel.main.caseInsensitive{zwsp}Headers* | Whether to use case sensitive or insensitive headers. Important: When using case sensitive (this is set to false). Then the map is case sensitive which means headers such as content-type and Content-Type are two different keys which can be a problem for some protocols such as HTTP based, which rely on case insensitive headers. However case sensitive implementations can yield faster performance. Therefore use case sensitive implementation with care. Default is true. | true | boolean
| *camel.main.configuration{zwsp}Classes* | Sets classes names that will be used to configure the camel context as example by providing custom beans through org.apache.camel.BindToRegistry annotation. |  | String
| *camel.main.configurations* | Sets the configuration objects used to configure the camel context. |  | List
| *camel.main.consumerTemplate{zwsp}CacheSize* | Consumer template endpoints cache size. | 1000 | int
| *camel.main.durationHitExitCode* | Sets the exit code for the application if duration was hit |  | int
| *camel.main.durationMaxIdle{zwsp}Seconds* | To specify for how long time in seconds Camel can be idle before automatic terminating the JVM. You can use this to run Camel for a short while. |  | int
| *camel.main.durationMaxMessages* | To specify how many messages to process by Camel before automatic terminating the JVM. You can use this to run Camel for a short while. |  | int
| *camel.main.durationMaxSeconds* | To specify for how long time in seconds to keep running the JVM before automatic terminating the JVM. You can use this to run Camel for a short while. |  | int
| *camel.main.endpointBridgeError{zwsp}Handler* | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN/ERROR level and ignored. The default value is false. |  | boolean
| *camel.main.endpointLazyStart{zwsp}Producer* | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. The default value is false. |  | boolean
| *camel.main.endpointRuntime{zwsp}StatisticsEnabled* | Sets whether endpoint runtime statistics is enabled (gathers runtime usage of each incoming and outgoing endpoints). The default value is false. |  | boolean
| *camel.main.fileConfigurations* | Directory to load additional configuration files that contains configuration values that takes precedence over any other configuration. This can be used to refer to files that may have secret configuration that has been mounted on the file system for containers. You can specify a pattern to load from sub directories and a name pattern such as /var/app/secret/.properties, multiple directories can be separated by comma. |  | String
| *camel.main.inflightRepository{zwsp}BrowseEnabled* | Sets whether the inflight repository should allow browsing each inflight exchange. This is by default disabled as there is a very slight performance overhead when enabled. |  | boolean
| *camel.main.javaRoutesExclude{zwsp}Pattern* | Used for exclusive filtering component scanning of RouteBuilder classes with Component annotation. The exclusive filtering takes precedence over inclusive filtering. The pattern is using Ant-path style pattern. Multiple patterns can be specified separated by comma. For example to exclude all classes starting with Bar use: &#42;&#42;/Bar&#42; To exclude all routes form a specific package use: com/mycompany/bar/&#42; To exclude all routes form a specific package and its sub-packages use double wildcards: com/mycompany/bar/&#42;&#42; And to exclude all routes from two specific packages use: com/mycompany/bar/&#42;,com/mycompany/stuff/&#42; |  | String
| *camel.main.javaRoutesInclude{zwsp}Pattern* | Used for inclusive filtering component scanning of RouteBuilder classes with Component annotation. The exclusive filtering takes precedence over inclusive filtering. The pattern is using Ant-path style pattern. Multiple patterns can be specified separated by comma. For example to include all classes starting with Foo use: &#42;&#42;/Foo To include all routes form a specific package use: com/mycompany/foo/&#42; To include all routes form a specific package and its sub-packages use double wildcards: com/mycompany/foo/&#42;&#42; And to include all routes from two specific packages use: com/mycompany/foo/&#42;,com/mycompany/stuff/&#42; |  | String
| *camel.main.jmxEnabled* | Enable JMX in your Camel application. | true | boolean
| *camel.main.jmxManagementName{zwsp}Pattern* | The naming pattern for creating the CamelContext JMX management name. The default pattern is #name# | #name# | String
| *camel.main.jmxManagement{zwsp}StatisticsLevel* | Sets the JMX statistics level, the level can be set to Extended to gather additional information The default value is Default. | Default | ManagementStatisticsLevel
| *camel.main.lightweight* | Experimental: Configure the context to be lightweight. This will trigger some optimizations and memory reduction options. Lightweight context have some limitations. At this moment, dynamic endpoint destinations are not supported. |  | boolean
| *camel.main.loadTypeConverters* | Whether to load custom type converters by scanning classpath. This is used for backwards compatibility with Camel 2.x. Its recommended to migrate to use fast type converter loading by setting Converter(loader = true) on your custom type converter classes. |  | boolean
| *camel.main.logDebugMaxChars* | Is used to limit the maximum length of the logging Camel message bodies. If the message body is longer than the limit, the log message is clipped. Use -1 to have unlimited length. Use for example 1000 to log at most 1000 characters. |  | int
| *camel.main.logExhaustedMessage{zwsp}Body* | Sets whether to log exhausted message body with message history. Default is false. |  | boolean
| *camel.main.logMask* | Sets whether log mask is enabled or not. Default is false. |  | boolean
| *camel.main.mdcLoggingKeys{zwsp}Pattern* | Sets the pattern used for determine which custom MDC keys to propagate during message routing when the routing engine continues routing asynchronously for the given message. Setting this pattern to will propagate all custom keys. Or setting the pattern to foo,bar will propagate any keys starting with either foo or bar. Notice that a set of standard Camel MDC keys are always propagated which starts with camel. as key name. The match rules are applied in this order (case insensitive): 1. exact match, returns true 2. wildcard match (pattern ends with a and the name starts with the pattern), returns true 3. regular expression match, returns true 4. otherwise returns false |  | String
| *camel.main.messageHistory* | Sets whether message history is enabled or not. Default is false. |  | boolean
| *camel.main.name* | Sets the name of the CamelContext. |  | String
| *camel.main.packageScanRoute{zwsp}Builders* | Sets package names for scanning for org.apache.camel.builder.RouteBuilder classes as candidates to be included. If you are using Spring Boot then its instead recommended to use Spring Boots component scanning and annotate your route builder classes with Component. In other words only use this for Camel Main in standalone mode. |  | String
| *camel.main.producerTemplate{zwsp}CacheSize* | Producer template endpoints cache size. | 1000 | int
| *camel.main.routeControllerBack{zwsp}OffDelay* | Backoff delay in millis when restarting a route that failed to startup. |  | long
| *camel.main.routeControllerBack{zwsp}OffMaxAttempts* | Backoff maximum number of attempts to restart a route that failed to startup. When this threshold has been exceeded then the controller will give up attempting to restart the route, and the route will remain as stopped. |  | long
| *camel.main.routeControllerBack{zwsp}OffMaxDelay* | Backoff maximum delay in millis when restarting a route that failed to startup. |  | long
| *camel.main.routeControllerBack{zwsp}OffMaxElapsedTime* | Backoff maximum elapsed time in millis, after which the backoff should be considered exhausted and no more attempts should be made. |  | long
| *camel.main.routeControllerBack{zwsp}OffMultiplier* | Backoff multiplier to use for exponential backoff. This is used to extend the delay between restart attempts. |  | double
| *camel.main.routeController{zwsp}ExcludeRoutes* | Pattern for filtering routes to be excluded as supervised. The pattern is matching on route id, and endpoint uri for the route. Multiple patterns can be separated by comma. For example to exclude all JMS routes, you can say jms:. And to exclude routes with specific route ids mySpecialRoute,myOtherSpecialRoute. The pattern supports wildcards and uses the matcher from org.apache.camel.support.PatternHelper#matchPattern. |  | String
| *camel.main.routeController{zwsp}IncludeRoutes* | Pattern for filtering routes to be included as supervised. The pattern is matching on route id, and endpoint uri for the route. Multiple patterns can be separated by comma. For example to include all kafka routes, you can say kafka:. And to include routes with specific route ids myRoute,myOtherRoute. The pattern supports wildcards and uses the matcher from org.apache.camel.support.PatternHelper#matchPattern. |  | String
| *camel.main.routeController{zwsp}InitialDelay* | Initial delay in milli seconds before the route controller starts, after CamelContext has been started. |  | long
| *camel.main.routeController{zwsp}RouteStartupLoggingLevel* | Sets the logging level used for logging route startup activity. By default INFO level is used. You can use this to change the level for example to OFF if this kind of logging is not wanted. | INFO | LoggingLevel
| *camel.main.routeController{zwsp}SuperviseEnabled* | To enable using supervising route controller which allows Camel to startup and then the controller takes care of starting the routes in a safe manner. This can be used when you want to startup Camel despite a route may otherwise fail fast during startup and cause Camel to fail to startup as well. By delegating the route startup to the supervising route controller then its manages the startup using a background thread. The controller allows to be configured with various settings to attempt to restart failing routes. |  | boolean
| *camel.main.routeController{zwsp}ThreadPoolSize* | The number of threads used by the route controller scheduled thread pool that are used for restarting routes. The pool uses 1 thread by default, but you can increase this to allow the controller to concurrently attempt to restart multiple routes in case more than one route has problems starting. |  | int
| *camel.main.routeController{zwsp}UnhealthyOnExhausted* | Whether to mark the route as unhealthy (down) when all restarting attempts (backoff) have failed and the route is not successfully started and the route manager is giving up. Setting this to true allows health checks to know about this and can report the Camel application as DOWN. The default is false. |  | boolean
| *camel.main.routeFilterExclude{zwsp}Pattern* | Used for filtering routes routes matching the given pattern, which follows the following rules: - Match by route id - Match by route input endpoint uri The matching is using exact match, by wildcard and regular expression as documented by PatternHelper#matchPattern(String,String) . For example to only include routes which starts with foo in their route id's, use: include=foo&#42; And to exclude routes which starts from JMS endpoints, use: exclude=jms:&#42; Multiple patterns can be separated by comma, for example to exclude both foo and bar routes, use: exclude=foo&#42;,bar&#42; Exclude takes precedence over include. |  | String
| *camel.main.routeFilterInclude{zwsp}Pattern* | Used for filtering routes matching the given pattern, which follows the following rules: - Match by route id - Match by route input endpoint uri The matching is using exact match, by wildcard and regular expression as documented by PatternHelper#matchPattern(String,String) . For example to only include routes which starts with foo in their route id's, use: include=foo&#42; And to exclude routes which starts from JMS endpoints, use: exclude=jms:&#42; Multiple patterns can be separated by comma, for example to exclude both foo and bar routes, use: exclude=foo&#42;,bar&#42; Exclude takes precedence over include. |  | String
| *camel.main.routesBuilder{zwsp}Classes* | Sets classes names that implement RoutesBuilder . |  | String
| *camel.main.routesBuilders* | Sets the RoutesBuilder instances. |  | List
| *camel.main.routesCollector{zwsp}Enabled* | Whether the routes collector is enabled or not. When enabled Camel will auto-discover routes (RouteBuilder instances from the registry and also load additional XML routes from the file system. The routes collector is default enabled. | true | boolean
| *camel.main.shutdownLogInflight{zwsp}ExchangesOnTimeout* | Sets whether to log information about the inflight Exchanges which are still running during a shutdown which didn't complete without the given timeout. This requires to enable the option inflightRepositoryBrowseEnabled. | true | boolean
| *camel.main.shutdownNowOn{zwsp}Timeout* | Sets whether to force shutdown of all consumers when a timeout occurred and thus not all consumers was shutdown within that period. You should have good reasons to set this option to false as it means that the routes keep running and is halted abruptly when CamelContext has been shutdown. | true | boolean
| *camel.main.shutdownRoutesIn{zwsp}ReverseOrder* | Sets whether routes should be shutdown in reverse or the same order as they were started. | true | boolean
| *camel.main.shutdownSuppress{zwsp}LoggingOnTimeout* | Whether Camel should try to suppress logging during shutdown and timeout was triggered, meaning forced shutdown is happening. And during forced shutdown we want to avoid logging errors/warnings et all in the logs as a side-effect of the forced timeout. Notice the suppress is a best effort as there may still be some logs coming from 3rd party libraries and whatnot, which Camel cannot control. This option is default false. |  | boolean
| *camel.main.shutdownTimeout* | Timeout in seconds to graceful shutdown Camel. | 45 | int
| *camel.main.streamCachingAny{zwsp}SpoolRules* | Sets whether if just any of the org.apache.camel.spi.StreamCachingStrategy.SpoolRule rules returns true then shouldSpoolCache(long) returns true, to allow spooling to disk. If this option is false, then all the org.apache.camel.spi.StreamCachingStrategy.SpoolRule must return true. The default value is false which means that all the rules must return true. |  | boolean
| *camel.main.streamCachingBuffer{zwsp}Size* | Sets the stream caching buffer size to use when allocating in-memory buffers used for in-memory stream caches. The default size is 4096. |  | int
| *camel.main.streamCaching{zwsp}Enabled* | Sets whether stream caching is enabled or not. Default is false. |  | boolean
| *camel.main.streamCachingRemove{zwsp}SpoolDirectoryWhenStopping* | Whether to remove stream caching temporary directory when stopping. This option is default true. | true | boolean
| *camel.main.streamCachingSpool{zwsp}Cipher* | Sets a stream caching cipher name to use when spooling to disk to write with encryption. By default the data is not encrypted. |  | String
| *camel.main.streamCachingSpool{zwsp}Directory* | Sets the stream caching spool (temporary) directory to use for overflow and spooling to disk. If no spool directory has been explicit configured, then a temporary directory is created in the java.io.tmpdir directory. |  | String
| *camel.main.streamCachingSpool{zwsp}Threshold* | Stream caching threshold in bytes when overflow to disk is activated. The default threshold is 128kb. Use -1 to disable overflow to disk. |  | long
| *camel.main.streamCachingSpool{zwsp}UsedHeapMemoryLimit* | Sets what the upper bounds should be when streamCachingSpoolUsedHeapMemoryThreshold is in use. |  | String
| *camel.main.streamCachingSpool{zwsp}UsedHeapMemoryThreshold* | Sets a percentage (1-99) of used heap memory threshold to activate stream caching spooling to disk. |  | int
| *camel.main.streamCaching{zwsp}StatisticsEnabled* | Sets whether stream caching statistics is enabled. |  | boolean
| *camel.main.threadNamePattern* | Sets the thread name pattern used for creating the full thread name. The default pattern is: Camel (#camelId#) thread ##counter# - #name# Where #camelId# is the name of the CamelContext. and #counter# is a unique incrementing counter. and #name# is the regular thread name. You can also use #longName# which is the long thread name which can includes endpoint parameters etc. |  | String
| *camel.main.tracing* | Sets whether tracing is enabled or not. Default is false. |  | boolean
| *camel.main.tracingPattern* | Tracing pattern to match which node EIPs to trace. For example to match all To EIP nodes, use to. The pattern matches by node and route id's Multiple patterns can be separated by comma. |  | String
| *camel.main.useBreadcrumb* | Set whether breadcrumb is enabled. The default value is false. |  | boolean
| *camel.main.useDataType* | Whether to enable using data type on Camel messages. Data type are automatic turned on if one ore more routes has been explicit configured with input and output types. Otherwise data type is default off. |  | boolean
| *camel.main.useMdcLogging* | To turn on MDC logging |  | boolean
| *camel.main.xmlRests* | Directory to scan for adding additional XML rests. You can turn this off by setting the value to false. Files can be loaded from either classpath or file by prefixing with classpath: or file: Wildcards is supported using a ANT pattern style paths, such as classpath:&#42;&#42;/&#42;camel&#42;.xml Notice when using wildcards, then there is additional overhead as the classpath is scanned, where as if you specific the exact name for each XML file is faster as no classpath scanning is needed. Multiple directories can be specified and separated by comma, such as: file:/myapp/mycamel/&#42;.xml,file:/myapp/myothercamel/&#42;.xml | classpath:camel-rest/*.xml | String
| *camel.main.xmlRoutes* | Directory to scan for adding additional XML routes. You can turn this off by setting the value to false. Files can be loaded from either classpath or file by prefixing with classpath: or file: Wildcards is supported using a ANT pattern style paths, such as classpath:&#42;&#42;/&#42;camel&#42;.xml Notice when using wildcards, then there is additional overhead as the classpath is scanned, where as if you specific the exact name for each XML file is faster as no classpath scanning is needed. Multiple directories can be specified and separated by comma, such as: file:/myapp/mycamel/&#42;.xml,file:/myapp/myothercamel/&#42;.xml | classpath:camel/*.xml | String
| *camel.main.xmlRouteTemplates* | Directory to scan for adding additional XML route templates. You can turn this off by setting the value to false. Files can be loaded from either classpath or file by prefixing with classpath: or file: Wildcards is supported using a ANT pattern style paths, such as classpath:&#42;&#42;/&#42;template-&#42;.xml Notice when using wildcards, then there is additional overhead as the classpath is scanned, where as if you specific the exact name for each XML file is faster as no classpath scanning is needed. Multiple directories can be specified and separated by comma, such as: file:/myapp/mycamel/&#42;.xml,file:/myapp/myothercamel/&#42;.xml | classpath:camel-template/*.xml | String
| *camel.faulttolerance.bulkhead{zwsp}Enabled* | Whether bulkhead is enabled or not on the circuit breaker. Default is false. | false | Boolean
| *camel.faulttolerance.bulkhead{zwsp}ExecutorServiceRef* | References to a custom thread pool to use when bulkhead is enabled. |  | String
| *camel.faulttolerance.bulkhead{zwsp}MaxConcurrentCalls* | Configures the max amount of concurrent calls the bulkhead will support. Default value is 10. | 10 | Integer
| *camel.faulttolerance.bulkhead{zwsp}WaitingTaskQueue* | Configures the task queue size for holding waiting tasks to be processed by the bulkhead. Default value is 10. | 10 | Integer
| *camel.faulttolerance.circuit{zwsp}BreakerRef* | Refers to an existing io.smallrye.faulttolerance.core.circuit.breaker.CircuitBreaker instance to lookup and use from the registry. When using this, then any other circuit breaker options are not in use. |  | String
| *camel.faulttolerance.delay* | Control how long the circuit breaker stays open. The value are in seconds and the default is 5 seconds. | 5 | Long
| *camel.faulttolerance.failure{zwsp}Ratio* | Configures the failure rate threshold in percentage. If the failure rate is equal or greater than the threshold the CircuitBreaker transitions to open and starts short-circuiting calls. The threshold must be greater than 0 and not greater than 100. Default value is 50 percentage. | 50 | Integer
| *camel.faulttolerance.request{zwsp}VolumeThreshold* | Controls the size of the rolling window used when the circuit breaker is closed Default value is 20. | 20 | Integer
| *camel.faulttolerance.success{zwsp}Threshold* | Controls the number of trial calls which are allowed when the circuit breaker is half-open Default value is 1. | 1 | Integer
| *camel.faulttolerance.timeout{zwsp}Duration* | Configures the thread execution timeout. Default value is 1000 milliseconds. | 1000 | Long
| *camel.faulttolerance.timeout{zwsp}Enabled* | Whether timeout is enabled or not on the circuit breaker. Default is false. | false | Boolean
| *camel.faulttolerance.timeout{zwsp}PoolSize* | Configures the pool size of the thread pool when timeout is enabled. Default value is 10. | 10 | Integer
| *camel.faulttolerance.timeout{zwsp}ScheduledExecutorServiceRef* | References to a custom thread pool to use when timeout is enabled |  | String
| *camel.health.config* | Set additional HealthConfigurationProperties for fine grained configuration of health checks. |  | Map
| *camel.health.contextEnabled* | Whether context health check is enabled | true | Boolean
| *camel.health.enabled* | Whether health check is enabled globally | true | Boolean
| *camel.health.registryEnabled* | Whether registry health check is enabled | true | Boolean
| *camel.health.routesEnabled* | Whether routes health check is enabled | true | Boolean
| *camel.hystrix.allowMaximumSize{zwsp}ToDivergeFromCoreSize* | Allows the configuration for maximumSize to take effect. That value can then be equal to, or higher, than coreSize |  | Boolean
| *camel.hystrix.circuitBreaker{zwsp}Enabled* | Whether to use a HystrixCircuitBreaker or not. If false no circuit-breaker logic will be used and all requests permitted. This is similar in effect to circuitBreakerForceClosed() except that continues tracking metrics and knowing whether it should be open/closed, this property results in not even instantiating a circuit-breaker. |  | Boolean
| *camel.hystrix.circuitBreaker{zwsp}ErrorThresholdPercentage* | Error percentage threshold (as whole number such as 50) at which point the circuit breaker will trip open and reject requests. It will stay tripped for the duration defined in circuitBreakerSleepWindowInMilliseconds; The error percentage this is compared against comes from HystrixCommandMetrics.getHealthCounts(). |  | Integer
| *camel.hystrix.circuitBreaker{zwsp}ForceClosed* | If true the HystrixCircuitBreaker#allowRequest() will always return true to allow requests regardless of the error percentage from HystrixCommandMetrics.getHealthCounts(). The circuitBreakerForceOpen() property takes precedence so if it set to true this property does nothing. |  | Boolean
| *camel.hystrix.circuitBreaker{zwsp}ForceOpen* | If true the HystrixCircuitBreaker.allowRequest() will always return false, causing the circuit to be open (tripped) and reject all requests. This property takes precedence over circuitBreakerForceClosed(); |  | Boolean
| *camel.hystrix.circuitBreaker{zwsp}RequestVolumeThreshold* | Minimum number of requests in the metricsRollingStatisticalWindowInMilliseconds() that must exist before the HystrixCircuitBreaker will trip. If below this number the circuit will not trip regardless of error percentage. |  | Integer
| *camel.hystrix.circuitBreaker{zwsp}SleepWindowInMilliseconds* | The time in milliseconds after a HystrixCircuitBreaker trips open that it should wait before trying requests again. |  | Integer
| *camel.hystrix.corePoolSize* | Core thread-pool size that gets passed to java.util.concurrent.ThreadPoolExecutor#setCorePoolSize(int) |  | Integer
| *camel.hystrix.execution{zwsp}IsolationSemaphoreMax{zwsp}ConcurrentRequests* | Number of concurrent requests permitted to HystrixCommand.run(). Requests beyond the concurrent limit will be rejected. Applicable only when executionIsolationStrategy == SEMAPHORE. |  | Integer
| *camel.hystrix.execution{zwsp}IsolationStrategy* | What isolation strategy HystrixCommand.run() will be executed with. If THREAD then it will be executed on a separate thread and concurrent requests limited by the number of threads in the thread-pool. If SEMAPHORE then it will be executed on the calling thread and concurrent requests limited by the semaphore count. |  | String
| *camel.hystrix.execution{zwsp}IsolationThreadInterruptOn{zwsp}Timeout* | Whether the execution thread should attempt an interrupt (using Future#cancel ) when a thread times out. Applicable only when executionIsolationStrategy() == THREAD. |  | Boolean
| *camel.hystrix.executionTimeout{zwsp}Enabled* | Whether the timeout mechanism is enabled for this command |  | Boolean
| *camel.hystrix.executionTimeout{zwsp}InMilliseconds* | Time in milliseconds at which point the command will timeout and halt execution. If executionIsolationThreadInterruptOnTimeout == true and the command is thread-isolated, the executing thread will be interrupted. If the command is semaphore-isolated and a HystrixObservableCommand, that command will get unsubscribed. |  | Integer
| *camel.hystrix.fallbackEnabled* | Whether HystrixCommand.getFallback() should be attempted when failure occurs. |  | Boolean
| *camel.hystrix.fallback{zwsp}IsolationSemaphoreMax{zwsp}ConcurrentRequests* | Number of concurrent requests permitted to HystrixCommand.getFallback(). Requests beyond the concurrent limit will fail-fast and not attempt retrieving a fallback. |  | Integer
| *camel.hystrix.groupKey* | Sets the group key to use. The default value is CamelHystrix. |  | String
| *camel.hystrix.keepAliveTime* | Keep-alive time in minutes that gets passed to ThreadPoolExecutor#setKeepAliveTime(long,TimeUnit) |  | Integer
| *camel.hystrix.maximumSize* | Maximum thread-pool size that gets passed to ThreadPoolExecutor#setMaximumPoolSize(int) . This is the maximum amount of concurrency that can be supported without starting to reject HystrixCommands. Please note that this setting only takes effect if you also set allowMaximumSizeToDivergeFromCoreSize |  | Integer
| *camel.hystrix.maxQueueSize* | Max queue size that gets passed to BlockingQueue in HystrixConcurrencyStrategy.getBlockingQueue(int) This should only affect the instantiation of a threadpool - it is not eliglible to change a queue size on the fly. For that, use queueSizeRejectionThreshold(). |  | Integer
| *camel.hystrix.metricsHealth{zwsp}SnapshotIntervalInMilliseconds* | Time in milliseconds to wait between allowing health snapshots to be taken that calculate success and error percentages and affect HystrixCircuitBreaker.isOpen() status. On high-volume circuits the continual calculation of error percentage can become CPU intensive thus this controls how often it is calculated. |  | Integer
| *camel.hystrix.metricsRolling{zwsp}PercentileBucketSize* | Maximum number of values stored in each bucket of the rolling percentile. This is passed into HystrixRollingPercentile inside HystrixCommandMetrics. |  | Integer
| *camel.hystrix.metricsRolling{zwsp}PercentileEnabled* | Whether percentile metrics should be captured using HystrixRollingPercentile inside HystrixCommandMetrics. |  | Boolean
| *camel.hystrix.metricsRolling{zwsp}PercentileWindowBuckets* | Number of buckets the rolling percentile window is broken into. This is passed into HystrixRollingPercentile inside HystrixCommandMetrics. |  | Integer
| *camel.hystrix.metricsRolling{zwsp}PercentileWindowInMilliseconds* | Duration of percentile rolling window in milliseconds. This is passed into HystrixRollingPercentile inside HystrixCommandMetrics. |  | Integer
| *camel.hystrix.metricsRolling{zwsp}StatisticalWindowBuckets* | Number of buckets the rolling statistical window is broken into. This is passed into HystrixRollingNumber inside HystrixCommandMetrics. |  | Integer
| *camel.hystrix.metricsRolling{zwsp}StatisticalWindowIn{zwsp}Milliseconds* | This property sets the duration of the statistical rolling window, in milliseconds. This is how long metrics are kept for the thread pool. The window is divided into buckets and rolls by those increments. |  | Integer
| *camel.hystrix.queueSize{zwsp}RejectionThreshold* | Queue size rejection threshold is an artificial max size at which rejections will occur even if maxQueueSize has not been reached. This is done because the maxQueueSize of a BlockingQueue can not be dynamically changed and we want to support dynamically changing the queue size that affects rejections. This is used by HystrixCommand when queuing a thread for execution. |  | Integer
| *camel.hystrix.requestLog{zwsp}Enabled* | Whether HystrixCommand execution and events should be logged to HystrixRequestLog. |  | Boolean
| *camel.hystrix.threadPoolKey* | Sets the thread pool key to use. Will by default use the same value as groupKey has been configured to use. |  | String
| *camel.hystrix.threadPool{zwsp}RollingNumberStatisticalWindow{zwsp}Buckets* | Number of buckets the rolling statistical window is broken into. This is passed into HystrixRollingNumber inside each HystrixThreadPoolMetrics instance. |  | Integer
| *camel.hystrix.threadPool{zwsp}RollingNumberStatisticalWindow{zwsp}InMilliseconds* | Duration of statistical rolling window in milliseconds. This is passed into HystrixRollingNumber inside each HystrixThreadPoolMetrics instance. |  | Integer
| *camel.lra.coordinatorContext{zwsp}Path* | The context-path for the LRA coordinator. Is default /lra-coordinator | /lra-coordinator | String
| *camel.lra.coordinatorUrl* | The URL for the LRA coordinator service that orchestrates the transactions |  | String
| *camel.lra.localParticipant{zwsp}ContextPath* | The context-path for the local participant. Is default /lra-participant | /lra-participant | String
| *camel.lra.localParticipantUrl* | The URL for the local participant |  | String
| *camel.resilience4j.automatic{zwsp}TransitionFromOpenToHalfOpen{zwsp}Enabled* | Enables automatic transition from OPEN to HALF_OPEN state once the waitDurationInOpenState has passed. |  | Boolean
| *camel.resilience4j.bulkhead{zwsp}Enabled* | Whether bulkhead is enabled or not on the circuit breaker. | false | Boolean
| *camel.resilience4j.bulkheadMax{zwsp}ConcurrentCalls* | Configures the max amount of concurrent calls the bulkhead will support. |  | Integer
| *camel.resilience4j.bulkheadMax{zwsp}WaitDuration* | Configures a maximum amount of time which the calling thread will wait to enter the bulkhead. If bulkhead has space available, entry is guaranteed and immediate. If bulkhead is full, calling threads will contest for space, if it becomes available. maxWaitDuration can be set to 0. Note: for threads running on an event-loop or equivalent (rx computation pool, etc), setting maxWaitDuration to 0 is highly recommended. Blocking an event-loop thread will most likely have a negative effect on application throughput. |  | Integer
| *camel.resilience4j.circuit{zwsp}BreakerRef* | Refers to an existing io.github.resilience4j.circuitbreaker.CircuitBreaker instance to lookup and use from the registry. When using this, then any other circuit breaker options are not in use. |  | String
| *camel.resilience4j.configRef* | Refers to an existing io.github.resilience4j.circuitbreaker.CircuitBreakerConfig instance to lookup and use from the registry. |  | String
| *camel.resilience4j.failureRate{zwsp}Threshold* | Configures the failure rate threshold in percentage. If the failure rate is equal or greater than the threshold the CircuitBreaker transitions to open and starts short-circuiting calls. The threshold must be greater than 0 and not greater than 100. Default value is 50 percentage. | 50 | Float
| *camel.resilience4j.minimum{zwsp}NumberOfCalls* | Configures configures the minimum number of calls which are required (per sliding window period) before the CircuitBreaker can calculate the error rate. For example, if minimumNumberOfCalls is 10, then at least 10 calls must be recorded, before the failure rate can be calculated. If only 9 calls have been recorded the CircuitBreaker will not transition to open even if all 9 calls have failed. Default minimumNumberOfCalls is 100 | 100 | Integer
| *camel.resilience4j.permitted{zwsp}NumberOfCallsInHalfOpenState* | Configures the number of permitted calls when the CircuitBreaker is half open. The size must be greater than 0. Default size is 10. | 10 | Integer
| *camel.resilience4j.sliding{zwsp}WindowSize* | Configures the size of the sliding window which is used to record the outcome of calls when the CircuitBreaker is closed. slidingWindowSize configures the size of the sliding window. Sliding window can either be count-based or time-based. If slidingWindowType is COUNT_BASED, the last slidingWindowSize calls are recorded and aggregated. If slidingWindowType is TIME_BASED, the calls of the last slidingWindowSize seconds are recorded and aggregated. The slidingWindowSize must be greater than 0. The minimumNumberOfCalls must be greater than 0. If the slidingWindowType is COUNT_BASED, the minimumNumberOfCalls cannot be greater than slidingWindowSize . If the slidingWindowType is TIME_BASED, you can pick whatever you want. Default slidingWindowSize is 100. | 100 | Integer
| *camel.resilience4j.sliding{zwsp}WindowType* | Configures the type of the sliding window which is used to record the outcome of calls when the CircuitBreaker is closed. Sliding window can either be count-based or time-based. If slidingWindowType is COUNT_BASED, the last slidingWindowSize calls are recorded and aggregated. If slidingWindowType is TIME_BASED, the calls of the last slidingWindowSize seconds are recorded and aggregated. Default slidingWindowType is COUNT_BASED. | COUNT_BASED | String
| *camel.resilience4j.slowCall{zwsp}DurationThreshold* | Configures the duration threshold (seconds) above which calls are considered as slow and increase the slow calls percentage. Default value is 60 seconds. | 60 | Integer
| *camel.resilience4j.slowCall{zwsp}RateThreshold* | Configures a threshold in percentage. The CircuitBreaker considers a call as slow when the call duration is greater than slowCallDurationThreshold(Duration. When the percentage of slow calls is equal or greater the threshold, the CircuitBreaker transitions to open and starts short-circuiting calls. The threshold must be greater than 0 and not greater than 100. Default value is 100 percentage which means that all recorded calls must be slower than slowCallDurationThreshold. | 100 | Float
| *camel.resilience4j.timeout{zwsp}CancelRunningFuture* | Configures whether cancel is called on the running future. Defaults to true. | true | Boolean
| *camel.resilience4j.timeout{zwsp}Duration* | Configures the thread execution timeout (millis). Default value is 1000 millis (1 second). | 1000 | Integer
| *camel.resilience4j.timeout{zwsp}Enabled* | Whether timeout is enabled or not on the circuit breaker. Default is false. | false | Boolean
| *camel.resilience4j.timeout{zwsp}ExecutorServiceRef* | References to a custom thread pool to use when timeout is enabled (uses ForkJoinPool#commonPool() by default) |  | String
| *camel.resilience4j.wait{zwsp}DurationInOpenState* | Configures the wait duration (in seconds) which specifies how long the CircuitBreaker should stay open, before it switches to half open. Default value is 60 seconds. | 60 | Integer
| *camel.resilience4j.writable{zwsp}StackTraceEnabled* | Enables writable stack traces. When set to false, Exception.getStackTrace returns a zero length array. This may be used to reduce log spam when the circuit breaker is open as the cause of the exceptions is already known (the circuit breaker is short-circuiting calls). |  | Boolean
| *camel.rest.apiComponent* | Sets the name of the Camel component to use as the REST API (such as swagger or openapi) |  | String
| *camel.rest.apiContextIdPattern* | Optional CamelContext id pattern to only allow Rest APIs from rest services within CamelContext's which name matches the pattern. The pattern #name# refers to the CamelContext name, to match on the current CamelContext only. For any other value, the pattern uses the rules from org.apache.camel.support.EndpointHelper#matchPattern(String,String) |  | String
| *camel.rest.apiContextListing* | Sets whether listing of all available CamelContext's with REST services in the JVM is enabled. If enabled it allows to discover these contexts, if false then only the current CamelContext is in use. |  | boolean
| *camel.rest.apiContextPath* | Sets a leading API context-path the REST API services will be using. This can be used when using components such as camel-servlet where the deployed web application is deployed using a context-path. |  | String
| *camel.rest.apiContextRouteId* | Sets the route id to use for the route that services the REST API. The route will by default use an auto assigned route id. |  | String
| *camel.rest.apiHost* | To use an specific hostname for the API documentation (eg swagger) This can be used to override the generated host with this configured hostname |  | String
| *camel.rest.apiProperties* | Sets additional options on api level |  | Map
| *camel.rest.apiVendorExtension* | Whether vendor extension is enabled in the Rest APIs. If enabled then Camel will include additional information as vendor extension (eg keys starting with x-) such as route ids, class names etc. Not all 3rd party API gateways and tools supports vendor-extensions when importing your API docs. |  | boolean
| *camel.rest.bindingMode* | Sets the binding mode to be used by the REST consumer | RestBindingMode.off | RestBindingMode
| *camel.rest.clientRequest{zwsp}Validation* | Whether to enable validation of the client request to check whether the Content-Type and Accept headers from the client is supported by the Rest-DSL configuration of its consumes/produces settings. This can be turned on, to enable this check. In case of validation error, then HTTP Status codes 415 or 406 is returned. The default value is false. |  | boolean
| *camel.rest.component* | Sets the name of the Camel component to use as the REST consumer |  | String
| *camel.rest.componentProperties* | Sets additional options on component level |  | Map
| *camel.rest.consumerProperties* | Sets additional options on consumer level |  | Map
| *camel.rest.contextPath* | Sets a leading context-path the REST services will be using. This can be used when using components such as camel-servlet where the deployed web application is deployed using a context-path. Or for components such as camel-jetty or camel-netty-http that includes a HTTP server. |  | String
| *camel.rest.corsHeaders* | Sets the CORS headers to use if CORS has been enabled. |  | Map
| *camel.rest.dataFormat{zwsp}Properties* | Sets additional options on data format level |  | Map
| *camel.rest.enableCORS* | To specify whether to enable CORS which means Camel will automatic include CORS in the HTTP headers in the response. This option is default false |  | boolean
| *camel.rest.endpointProperties* | Sets additional options on endpoint level |  | Map
| *camel.rest.host* | Sets the hostname to use by the REST consumer |  | String
| *camel.rest.hostNameResolver* | Sets the resolver to use for resolving hostname | RestHostNameResolver.allLocalIp | RestHostNameResolver
| *camel.rest.jsonDataFormat* | Sets a custom json data format to be used Important: This option is only for setting a custom name of the data format, not to refer to an existing data format instance. |  | String
| *camel.rest.port* | Sets the port to use by the REST consumer |  | int
| *camel.rest.producerApiDoc* | Sets the location of the api document (swagger api) the REST producer will use to validate the REST uri and query parameters are valid accordingly to the api document. This requires adding camel-swagger-java to the classpath, and any miss configuration will let Camel fail on startup and report the error(s). The location of the api document is loaded from classpath by default, but you can use file: or http: to refer to resources to load from file or http url. |  | String
| *camel.rest.producerComponent* | Sets the name of the Camel component to use as the REST producer |  | String
| *camel.rest.scheme* | Sets the scheme to use by the REST consumer |  | String
| *camel.rest.skipBindingOnError{zwsp}Code* | Whether to skip binding output if there is a custom HTTP error code, and instead use the response body as-is. This option is default true. | true | boolean
| *camel.rest.useXForwardHeaders* | WWhether to use X-Forward headers to set host etc. for Swagger. This option is default true. | true | boolean
| *camel.rest.xmlDataFormat* | Sets a custom xml data format to be used. Important: This option is only for setting a custom name of the data format, not to refer to an existing data format instance. |  | String
| *camel.threadpool.allowCore{zwsp}ThreadTimeOut* | Sets default whether to allow core threads to timeout |  | Boolean
| *camel.threadpool.config* | Adds a configuration for a specific thread pool profile (inherits default values) |  | Map
| *camel.threadpool.keepAliveTime* | Sets the default keep alive time for inactive threads |  | Long
| *camel.threadpool.maxPoolSize* | Sets the default maximum pool size |  | Integer
| *camel.threadpool.maxQueueSize* | Sets the default maximum number of tasks in the work queue. Use -1 or an unbounded queue |  | Integer
| *camel.threadpool.poolSize* | Sets the default core pool size (threads to keep minimum in pool) |  | Integer
| *camel.threadpool.rejected{zwsp}Policy* | Sets the default handler for tasks which cannot be executed by the thread pool. |  | ThreadPoolRejectedPolicy
| *camel.threadpool.timeUnit* | Sets the default time unit used for keep alive time |  | TimeUnit
|===
// main options: END

== Specifying custom beans

Custom beans can be configured in `camel-main` via properties (such as in the `application.properties` file).

For example to create a `DataSource` for a Postgress database, you can create a new bean instance via `#class:` with the class name (fully qualified).
Properties on the data source can then additional configured such as the server and database name, etc.

[source,properties]
----
camel.beans.myDS = #class:org.postgresql.jdbc3.Jdbc3PoolingDataSource
camel.beans.myDS.dataSourceName = myDS
camel.beans.myDS.serverName = mypostrgress
camel.beans.myDS.databaseName = test
camel.beans.myDS.user = testuser
camel.beans.myDS.password = testpassword
camel.beans.myDS.maxConnections = 10
----

The bean is registered in the Camel Registry with the name `myDS`.

If you use the SQL component then the datasource can be configured on the SQL component:

[source,properties]
----
camel.component.sql.dataSource = #myDS
----

To refer to a custom bean you may want to favour using `#bean:` style, as this states the intention more clearly that its referring to a bean,
and not just a text value that happens to start with a `#` sign:

[source,properties]
----
camel.component.sql.dataSource = #bean:myDS
----

=== Creating a custom bean with constructor parameters

When creating a bean then parameters to the constructor can be provided.
Suppose we have a class `MyFoo` with a constructor:

[source,java]
----
public class MyFoo {
    private String name;
    private boolean important;
    private int id;

    public MyFoo(String name, boolean important, int id) {
        this.name = name;
        this.important = important;
        this.id = id;
    }
}
----

Then we can create a bean instance with name `foo` and provide parameters to the constructor as shown:

[source,properties]
----
camel.beans.foo = #class:com.foo.MyBean(""Hello World"", true, 123)
----

=== Optional parameters on beans

If a parameter on a bean is not mandatory then the parameter can be marked as optional using `?` syntax, as shown:

[source,properties]
----
camel.beans.foo = #class:com.foo.MyBean(""Hello World"", true, 123)
camel.beans.foo.?company = Acme
----

Then the company parameter is only set if `MyBean` has this option (silent ignore if no option present).
Otherwise if a parameter is set and the bean does not have such a parameter, then an exception is thrown by Camel.

=== Nested parameters on beans

You can configure nested parameters separating them via `.` (dot).

For example given this `Country` class:

[source,java]
----
public class Country {
    private String iso;
    private String name;

    public void setIso(String iso) {
        this.iso = iso;
    }

    public void setName(String name) {
        this.name = name;
    }
}
----

Which is an option on the `MyBean` class.
Then we can then configure its iso and name parameter as shown below:

[source,properties]
----
camel.beans.foo = #class:com.foo.MyBean(""Hello World"", true, 123)
camel.beans.foo.country.iso = USA
camel.beans.foo.country.name = United States of America
----

Camel will automatic create an instance of `Country` if `MyBean` has a getter/setter for this option, and that the `Country` bean
has a default no-arg constructor.

=== Configuring singleton beans by their type

In the example above the SQL component was configured with the name of the `DataSource`. There can be situations where you know there is only
a single instance of a data source in the Camel registry. In such a situation you can instead refer to the class
or interface type via the `#type:` prefix as shown below:

[source,properties]
----
camel.component.sql.dataSource = #type:javax.sql.DataSource
----

If there is no bean in the registry with the type `javax.sql.DataSource` then the option isn't configured.

=== Autowiring beans

The example above can be taken one step further by letting `camel-main` try to autowire the beans.

[source,properties]
----
camel.component.sql.dataSource = #autowired
----

In this situation then `#autowrired` will make Camel detect the type of the `dataSource` option on the `SQL` component.
As the type is a `javax.sql.DataSource` instance, then Camel will lookup in the registry if there is a single instance of the same type.
If there is no such bean then the option isn't configured.

== Defining a Map bean

You can specify `java.util.Map` beans in `camel-main` via properties (such as in the `application.properties` file).

Maps have a special syntax with brackets as shown below:

[source,properties]
----
camel.beans.mymap[table] = 12
camel.beans.mymap[food] = Big Burger
camel.beans.mymap[cheese] = yes
camel.beans.mymap[quantity] = 1
----

The Map is registered in the Camel Registry with the name `mymap`.

== Defining a List bean

This is similar to Map bean where the key is the index, eg 0, 1, 2, etc:

[source,properties]
----
camel.beans.myprojects[0] = Camel
camel.beans.myprojects[1] = Kafka
camel.beans.myprojects[2] = Quarkus
----

The List is registered in the Camel Registry with the name `myprojects`.

== Examples

You can find a set of examples using `camel-main` in https://github.com/apache/camel-examples[Camel Examples]
which demonstrate running Camel in standalone with `camel-main`.
",12317,False,2195.1820728903417,median
"/*
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
   | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | http://www.php.net/license/3_01.txt                                  |
   | If you did not receive a copy of the PHP license and are unable to   |
   | obtain it through the world-wide-web, please send a note to          |
   | license@php.net so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+
*/
#include ""hphp/hhbbc/interp.h""

#include <vector>
#include <algorithm>
#include <string>
#include <utility>

#include <folly/Optional.h>
#include <folly/Format.h>

#include ""hphp/util/trace.h""

#include ""hphp/hhbbc/interp-internal.h""
#include ""hphp/hhbbc/type-ops.h""

namespace HPHP { namespace HHBBC {

namespace {

//////////////////////////////////////////////////////////////////////

const StaticString s_stdClass(""stdClass"");

//////////////////////////////////////////////////////////////////////

/*
 * Note: the couldBe comparisons here with sempty() are asking ""can this string
 * be a non-reference counted empty string"".  What actually matters is whether
 * it can be an empty string at all.  Currently, all reference counted strings
 * are TStr, which has no values and may also be non-reference
 * counted---emptiness isn't separately tracked like it is for arrays, so if
 * anything happened that could make it reference counted this check will
 * return true.
 *
 * This means this code is fine for now, but if we implement #3837503
 * (non-static strings with values in the type system) it will need to change.
 */

bool couldBeEmptyish(const Type& ty) {
  return ty.couldBe(TNull) ||
         ty.couldBe(sempty()) ||
         ty.couldBe(TFalse);
}

bool mustBeEmptyish(const Type& ty) {
  return ty.subtypeOf(TNull) ||
         ty.subtypeOf(sempty()) ||
         ty.subtypeOf(TFalse);
}

bool elemCouldPromoteToArr(const Type& ty) { return couldBeEmptyish(ty); }
bool elemMustPromoteToArr(const Type& ty)  { return mustBeEmptyish(ty); }

bool propCouldPromoteToObj(const Type& ty) {
  return RuntimeOption::EvalPromoteEmptyObject && couldBeEmptyish(ty);
}

bool propMustPromoteToObj(const Type& ty)  {
  return RuntimeOption::EvalPromoteEmptyObject && mustBeEmptyish(ty);
}

bool keyCouldBeWeird(const Type& key) {
  return key.couldBe(TObj) || key.couldBe(TArr) || key.couldBe(TVec) ||
    key.couldBe(TDict) || key.couldBe(TKeyset);
}

bool mustBeArrLike(const Type& ty) {
  return ty.subtypeOf(TArr)  || ty.subtypeOf(TVec) ||
         ty.subtypeOf(TDict) || ty.subtypeOf(TKeyset);
}

//////////////////////////////////////////////////////////////////////

Type baseLocNameType(const Base& b) {
  return b.locName ? sval(b.locName) : TInitGen;
}

//////////////////////////////////////////////////////////////////////

/*
 * A note about bases.
 *
 * Generally type inference needs to know two kinds of things about the base to
 * handle effects on tracked locations:
 *
 *   - Could the base be a location we're tracking deeper structure on, so the
 *     next operation actually affects something inside of it.  For example,
 *     could the base be an object with the same type as $this, or an array in a
 *     local variable.
 *
 *   - Could the base be something (regardless of type) that is inside one of
 *     the things we're tracking.  I.e., the base might be whatever (an array or
 *     a bool or something), but living inside a property inside an object with
 *     the same type as $this, or living inside of an array in the local frame.
 *
 * The first cases apply because final operations are going to directly affect
 * the type of these elements.  The second case is because vector operations may
 * change the base at each step if it is a defining instruction.
 *
 * Note that both of these cases can apply to the same base in some cases: you
 * might have an object property on $this that could be an object of the type of
 * $this.
 *
 * The functions below with names ""couldBeIn*"" detect the second case. The
 * effects on the tracked location in the second case are handled in the
 * functions with names ""promoteIn*{Prop,Elem,..}"".  The effects for the first
 * case are generally handled in the miFinal op functions.
 *
 * Control flow insensitive vs. control flow sensitive types:
 *
 * Things are also slightly complicated by the fact that we are analyzing some
 * control flow insensitve types along side precisely tracked types.  For
 * effects on locals, we perform the type effects of each operation on
 * base.type, and then allow updateBaseWithType() to make the updates to the
 * local when we know what its final type will be.
 *
 * This approach doesn't do as well for possible properties in $this or self::,
 * because we may see situations where the base could be one of these properties
 * but we're not sure---perhaps because it came off a property with the same
 * name on an object with an unknown type (i.e. base.type is InitCell but
 * couldBeInProp is true).  In these situations, we can get away with just
 * merging Obj=stdClass into the thisProp (because it 'could' promote) instead
 * of merging the whole InitCell, which possibly lets us leave the type at ?Obj
 * in some cases.
 *
 * This is why there's two fairly different mechanisms for handling the effects
 * of defining ops on base types.
 */

//////////////////////////////////////////////////////////////////////

bool couldBeThisObj(ISS& env, const Base& b) {
  auto const thisTy = thisType(env);
  return b.type.couldBe(thisTy ? *thisTy : TObj);
}

bool mustBeThisObj(ISS& env, const Base& b) {
  if (b.loc == BaseLoc::This) return true;
  if (auto const ty = thisType(env)) return b.type.subtypeOf(*ty);
  return false;
}

bool mustBeInLocal(const Base& b) {
  return b.loc == BaseLoc::Local;
}

bool mustBeInStack(const Base& b) {
  return b.loc == BaseLoc::Stack;
}

bool couldBeInProp(ISS& env, const Base& b) {
  if (b.loc != BaseLoc::Prop) return false;
  auto const thisTy = thisType(env);
  if (!thisTy) return true;
  if (!b.locTy.couldBe(*thisTy)) return false;
  if (b.locName) return isTrackedThisProp(env, b.locName);
  return true;
}

bool couldBeInNonSerializedProp(ISS& env, const Base& b) {
  if (!couldBeInProp(env, b)) return false;
  if (b.locName) return isNonSerializedThisProp(env, b.locName);
  return true;
}

bool couldBeInPrivateStatic(ISS& env, const Base& b) {
  if (b.loc != BaseLoc::StaticProp) return false;
  auto const selfTy = selfCls(env);
  return !selfTy || b.locTy.couldBe(*selfTy);
}

bool couldBeInPublicStatic(const Base& b) {
  return b.loc == BaseLoc::StaticProp;
}

//////////////////////////////////////////////////////////////////////

// Base locations that only occur at the start of a minstr sequence.
bool isInitialBaseLoc(BaseLoc loc) {
  return
    loc == BaseLoc::Local ||
    loc == BaseLoc::Stack ||
    loc == BaseLoc::StaticProp ||
    loc == BaseLoc::This ||
    loc == BaseLoc::Global;
}

// Base locations that only occur after the start of a minstr sequence.
bool isDimBaseLoc(BaseLoc loc) {
  return loc == BaseLoc::Elem || loc == BaseLoc::Prop;
}

//////////////////////////////////////////////////////////////////////

/*
 * If the current base is an array-like, update it via *_set, and return true;
 * otherwise, return false.
 */
bool array_do_set(ISS& env, const Type& key, const Type& value) {
  auto& base = env.state.mInstrState.base.type;
  auto res = [&] () -> folly::Optional<std::pair<Type,ThrowMode>> {
    if (base.subtypeOf(TArr))    return  array_set(std::move(base), key, value);
    if (base.subtypeOf(TVec))    return    vec_set(std::move(base), key, value);
    if (base.subtypeOf(TDict))   return   dict_set(std::move(base), key, value);
    if (base.subtypeOf(TKeyset)) return keyset_set(std::move(base), key, value);
    return folly::none;
  }();
  if (!res) return false;

  switch (res->second) {
    case ThrowMode::None:
      nothrow(env);
      break;
    case ThrowMode::MaybeMissingElement:
    case ThrowMode::MissingElement:
    case ThrowMode::MaybeBadKey:
    case ThrowMode::BadOperation:
      break;
  }

  if (res->first == TBottom) {
    unreachable(env);
  }

  base = std::move(res->first);
  return true;
}

/*
 * If the current base is an array-like, return the best known type
 * for base[key].
 */
folly::Optional<Type> array_do_elem(ISS& env,
                                    bool nullOnMissing,
                                    const Type& key) {
  auto const& base = env.state.mInstrState.base.type;
  auto res = [&] () -> folly::Optional<std::pair<Type,ThrowMode>> {
    if (base.subtypeOf(TArr))    return  array_elem(base, key);
    if (base.subtypeOf(TVec))    return    vec_elem(base, key);
    if (base.subtypeOf(TDict))   return   dict_elem(base, key);
    if (base.subtypeOf(TKeyset)) return keyset_elem(base, key);
    return folly::none;
  }();
  if (!res) return folly::none;

  switch (res->second) {
    case ThrowMode::None:
      nothrow(env);
      break;
    case ThrowMode::MaybeMissingElement:
    case ThrowMode::MissingElement:
      if (nullOnMissing) {
        nothrow(env);
        res->first |= TInitNull;
      }
      break;
    case ThrowMode::MaybeBadKey:
      if (nullOnMissing) {
        res->first |= TInitNull;
      }
      break;
    case ThrowMode::BadOperation:
      break;
  }

  if (res->first == TBottom) {
    unreachable(env);
  }

  return std::move(res->first);
}

/*
 * If the current base is an array-like, update it via *_newelem, and
 * return the best known type for the key added; otherwise return folly::none.
 */
folly::Optional<Type> array_do_newelem(ISS& env, const Type& value) {
  auto& base = env.state.mInstrState.base.type;
  auto res = [&] () -> folly::Optional<std::pair<Type,Type>> {
    if (base.subtypeOf(TArr))    return  array_newelem(std::move(base), value);
    if (base.subtypeOf(TVec))    return    vec_newelem(std::move(base), value);
    if (base.subtypeOf(TDict))   return   dict_newelem(std::move(base), value);
    if (base.subtypeOf(TKeyset)) return keyset_newelem(std::move(base), value);
    return folly::none;
  }();
  if (!res) return folly::none;
  base = std::move(res->first);
  return res->second;
}

//////////////////////////////////////////////////////////////////////

// MInstrs can throw in between each op, so the states of locals
// need to be propagated across factored exit edges.
void miThrow(ISS& env) {
  for (auto factored : env.blk.factoredExits) {
    auto const stackLess = without_stacks(env.state);
    env.propagate(factored, &stackLess);
  }
}

//////////////////////////////////////////////////////////////////////

void setLocalForBase(ISS& env, Type ty) {
  assert(mustBeInLocal(env.state.mInstrState.base));
  if (env.state.mInstrState.base.locLocal == NoLocalId) {
    return loseNonRefLocalTypes(env);
  }
  FTRACE(4, ""      ${} := {}\\n"",
    env.state.mInstrState.base.locName
     ? env.state.mInstrState.base.locName->data()
     : ""$<unnamed>"",
    show(ty)
  );
  setLoc(env, env.state.mInstrState.base.locLocal, std::move(ty));
}

void setStackForBase(ISS& env, Type ty) {
  assert(mustBeInStack(env.state.mInstrState.base));

  auto const locSlot = env.state.mInstrState.base.locSlot;
  FTRACE(4, ""      stk[{:02}] := {}\\n"", locSlot, show(ty));
  assert(locSlot < env.state.stack.size());

  auto const& oldTy = env.state.stack[locSlot].type;
  if (oldTy.subtypeOf(TInitCell)) {
    env.state.stack[locSlot] = StackElem {std::move(ty)};
  }
}

void setPrivateStaticForBase(ISS& env, Type ty) {
  assert(couldBeInPrivateStatic(env, env.state.mInstrState.base));

  if (auto const name = env.state.mInstrState.base.locName) {
    FTRACE(4, ""      self::${} |= {}\\n"", name->data(), show(ty));
    mergeSelfProp(env, name, std::move(ty));
    return;
  }
  FTRACE(4, ""      self::* |= {}\\n"", show(ty));
  mergeEachSelfPropRaw(
    env,
    [&](const Type& old){ return old.subtypeOf(TInitCell) ? ty : TBottom; }
  );
}

void setPropForBase(ISS& env, Type ty) {
  assert(couldBeInNonSerializedProp(env, env.state.mInstrState.base));

  if (auto const name = env.state.mInstrState.base.locName) {
    FTRACE(4, ""      $this->{} |= {}\\n"", name->data(), show(ty));
    mergeThisProp(env, name, std::move(ty));
    return;
  }
  FTRACE(4, ""      $this->* |= {}\\n"", show(ty));
  mergeEachThisPropRaw(
    env,
    [&] (const Type& old) { return old.couldBe(TInitCell) ? ty : TBottom; }
  );
}

// Run backwards through an array chain doing array_set operations
// to produce the array type that incorporates the effects of any
// intermediate defining dims.
Type currentChainType(ISS& env, Type val) {
  auto it = env.state.mInstrState.arrayChain.end();
  while (it != env.state.mInstrState.arrayChain.begin()) {
    --it;
    if (it->first.subtypeOf(TArr)) {
      val = array_set(it->first, it->second, val).first;
    } else if (it->first.subtypeOf(TVec)) {
      val = vec_set(it->first, it->second, val).first;
      if (val == TBottom) val = TVec;
    } else if (it->first.subtypeOf(TDict)) {
      val = dict_set(it->first, it->second, val).first;
      if (val == TBottom) val = TDict;
    } else {
      assert(it->first.subtypeOf(TKeyset));
      val = keyset_set(it->first, it->second, val).first;
      if (val == TBottom) val = TKeyset;
    }
  }
  return val;
}

Type resolveArrayChain(ISS& env, Type val) {
  static UNUSED const char prefix[] = ""              "";
  FTRACE(5, ""{}chain\\n"", prefix, show(val));
  do {
    auto arr = std::move(env.state.mInstrState.arrayChain.back().first);
    auto key = std::move(env.state.mInstrState.arrayChain.back().second);
    env.state.mInstrState.arrayChain.pop_back();
    FTRACE(5, ""{}  | {} := {} in {}\\n"", prefix,
      show(key), show(val), show(arr));
    if (arr.subtypeOf(TVec)) {
      val = vec_set(std::move(arr), key, val).first;
      if (val == TBottom) val = TVec;
    } else if (arr.subtypeOf(TDict)) {
      val = dict_set(std::move(arr), key, val).first;
      if (val == TBottom) val = TDict;
    } else if (arr.subtypeOf(TKeyset)) {
      val = keyset_set(std::move(arr), key, val).first;
      if (val == TBottom) val = TKeyset;
    } else {
      assert(arr.subtypeOf(TArr));
      val = array_set(std::move(arr), key, val).first;
    }
  } while (!env.state.mInstrState.arrayChain.empty());
  FTRACE(5, ""{}  = {}\\n"", prefix, show(val));
  return val;
}

void updateBaseWithType(ISS& env, const Type& ty) {
  FTRACE(6, ""    updateBaseWithType: {}\\n"", show(ty));

  auto const& base = env.state.mInstrState.base;

  if (mustBeInLocal(base)) {
    setLocalForBase(env, ty);
    return miThrow(env);
  }
  if (mustBeInStack(base)) {
    return setStackForBase(env, ty);
  }
  if (couldBeInPrivateStatic(env, base)) {
    return setPrivateStaticForBase(env, ty);
  }
  if (couldBeInNonSerializedProp(env, base)) {
    return setPropForBase(env, ty);
  }
}

void startBase(ISS& env, Base base) {
  auto& oldState = env.state.mInstrState;
  assert(oldState.base.loc == BaseLoc::None);
  assert(oldState.arrayChain.empty());
  assert(isInitialBaseLoc(base.loc));
  assert(!env.state.mInstrStateDefine);

  oldState.base = std::move(base);
  FTRACE(5, ""    startBase: {}\\n"", show(*env.ctx.func, oldState.base));
}

void endBase(ISS& env, bool update = true) {
  auto& state = env.state.mInstrState;
  assert(state.base.loc != BaseLoc::None);

  FTRACE(5, ""    endBase: {}\\n"", show(*env.ctx.func, state.base));

  auto const& ty = state.arrayChain.empty()
    ? state.base.type
    : resolveArrayChain(env, state.base.type);

  if (update) updateBaseWithType(env, ty);
  state.base.loc = BaseLoc::None;
}

void moveBase(ISS& env, Base newBase, bool update = true) {
  auto& state = env.state.mInstrState;
  assert(state.base.loc != BaseLoc::None);
  assert(isDimBaseLoc(newBase.loc));

  FTRACE(5, ""    moveBase: {} -> {}\\n"",
         show(*env.ctx.func, state.base),
         show(*env.ctx.func, newBase));

  if (newBase.loc == BaseLoc::Elem) {
    state.base.type =
      add_nonemptiness(
        loosen_staticness(loosen_values(state.base.type))
      );
  }

  auto const& ty = state.arrayChain.empty()
    ? state.base.type
    : resolveArrayChain(env, state.base.type);

  if (update) updateBaseWithType(env, ty);
  state.base = std::move(newBase);
}

void extendArrChain(ISS& env, Type key, Type arr,
                    Type val, bool update = true) {
  auto& state = env.state.mInstrState;
  assert(state.base.loc != BaseLoc::None);
  assert(mustBeArrLike(arr));

  state.arrayChain.emplace_back(std::move(arr), std::move(key));
  state.base.type = std::move(val);

  FTRACE(5, ""    extendArrChain: {}\\n"", show(*env.ctx.func, state));
  if (update) {
    updateBaseWithType(env, currentChainType(env, state.base.type));
  }
}

//////////////////////////////////////////////////////////////////////

/*
 * The following promoteBase{Elem,Prop}* functions are used to implement the
 * 'normal' portion of the effects on base types, which are mostly what are done
 * by intermediate dims.
 *
 * The contract with these functions is that they should handle all the effects
 * on the base type /except/ for the case of the base being an array
 * subtype---the caller is responsible for that. The reason for this is that for
 * tracking effects on specialized array types, the final ops generally need to
 * do completely different things to the array, so this allows reuse of this
 * shared part of the type transitions. The intermediate routines must handle
 * array subtypes outside of calls to this as well.
 */

void promoteBaseElemU(ISS& env) {
  // We're conservative with unsets on array types for now.
  env.state.mInstrState.base.type = loosen_all(env.state.mInstrState.base.type);
}

void promoteBasePropD(ISS& env, bool isNullsafe) {
  auto& ty = env.state.mInstrState.base.type;

  // NullSafe (Q) props do not promote an emptyish base to stdClass instance.
  if (isNullsafe || ty.subtypeOf(TObj)) return;

  if (propMustPromoteToObj(ty)) {
    ty = objExact(env.index.builtin_class(s_stdClass.get()));
    return;
  }
  if (propCouldPromoteToObj(ty)) {
    ty = promote_emptyish(ty, TObj);
    return;
  }
}

void promoteBaseElemD(ISS& env) {
  auto& ty = env.state.mInstrState.base.type;

  // When the base is actually a subtype of array, we handle it in the callers
  // of these functions.
  if (mustBeArrLike(ty)) return;

  if (elemMustPromoteToArr(ty)) {
    ty = counted_aempty();
    return;
  }

  // Intermediate ElemD operations on strings fatal, unless the string is empty,
  // which promotes to array. So for any string here we can assume it promoted
  // to an empty array.
  if (ty.subtypeOf(TStr)) {
    ty = counted_aempty();
    return;
  }

  if (elemCouldPromoteToArr(ty)) {
    ty = promote_emptyish(ty, counted_aempty());
    return;
  }

  /*
   * If the base still could be some kind of array (but isn't an array sub-type
   * which would be handled outside this routine), we need to give up on any
   * better information here (or track the effects, but we're not doing that
   * yet).
   */
  ty = loosen_arrays(ty);
}

void promoteBaseNewElem(ISS& env) {
  promoteBaseElemD(env);
  // Technically we don't need to do TStr case.
}

//////////////////////////////////////////////////////////////////////

void handleInPublicStaticElemD(ISS& env) {
  auto const& base = env.state.mInstrState.base;
  if (!couldBeInPublicStatic(base)) return;

  auto const indexer = env.collect.publicStatics;
  if (!indexer) return;

  auto const name = baseLocNameType(base);
  auto const ty = env.index.lookup_public_static(base.locTy, name);
  if (elemCouldPromoteToArr(ty)) {
    // Might be possible to only merge a TArrE, but for now this is ok.
    indexer->merge(env.ctx, base.locTy, name, TArr);
  }
}

void handleInThisElemD(ISS& env) {
  if (!couldBeInProp(env, env.state.mInstrState.base)) return;

  if (auto const name = env.state.mInstrState.base.locName) {
    auto const ty = thisPropAsCell(env, name);
    if (ty && elemCouldPromoteToArr(*ty)) {
      mergeThisProp(env, name, TArr);
    }
    return;
  }

  mergeEachThisPropRaw(env, [&] (const Type& t) {
      return elemCouldPromoteToArr(t) ? TArr : TBottom;
    });
}

void handleInPublicStaticPropD(ISS& env, bool isNullsafe) {
  // NullSafe (Q) props do not promote an emptyish base to stdClass instance.
  if (isNullsafe) return;

  auto const& base = env.state.mInstrState.base;
  if (!couldBeInPublicStatic(base)) return;

  auto const indexer = env.collect.publicStatics;
  if (!indexer) return;

  auto const name = baseLocNameType(base);
  auto const ty = env.index.lookup_public_static(base.locTy, name);
  if (propCouldPromoteToObj(ty)) {
    indexer->merge(env.ctx, base.locTy, name,
                   objExact(env.index.builtin_class(s_stdClass.get())));
  }
}

void handleInThisPropD(ISS& env, bool isNullsafe) {
  // NullSafe (Q) props do not promote an emptyish base to stdClass instance.
  if (isNullsafe) return;

  if (!couldBeInProp(env, env.state.mInstrState.base)) return;

  if (auto const name = env.state.mInstrState.base.locName) {
    auto const ty = thisPropAsCell(env, name);
    if (ty && propCouldPromoteToObj(*ty)) {
      mergeThisProp(env, name,
                    objExact(env.index.builtin_class(s_stdClass.get())));
    }
    return;
  }

  if (RuntimeOption::EvalPromoteEmptyObject) {
    mergeEachThisPropRaw(env, [&] (const Type& t) {
        return propCouldPromoteToObj(t) ? TObj : TBottom;
      });
  }
}

// Currently NewElem and Elem InFoo effects don't need to do
// anything different from each other.
void handleInPublicStaticNewElem(ISS& env) { handleInPublicStaticElemD(env); }
void handleInThisNewElem(ISS& env) { handleInThisElemD(env); }

void handleInPublicStaticElemU(ISS& env) {
  auto const& base = env.state.mInstrState.base;
  if (!couldBeInPublicStatic(base)) return;

  auto const indexer = env.collect.publicStatics;
  if (!indexer) return;

  /*
   * We need to ensure that the type could become non-static, but since we're
   * never going to see anything specialized from lookup_public_static the
   * first time we're running with collect.publicStatics, we can't do much
   * right now since we don't have a type for the union of all counted types.
   *
   * Merging InitCell is correct, but very conservative, for now.
   */
  auto const name = baseLocNameType(base);
  indexer->merge(env.ctx, base.locTy, name, TInitCell);
}

//////////////////////////////////////////////////////////////////////

// Returns nullptr if it's an unknown key or not a string.
SString mStringKey(const Type& key) {
  auto const v = tv(key);
  return v && v->m_type == KindOfPersistentString ? v->m_data.pstr : nullptr;
}

template<typename Op>
folly::Optional<Type> key_type_or_fixup(ISS& env, Op op) {
  auto fixup = [&] (Type ty, bool isProp) -> folly::Optional<Type> {
    if (auto const val = tv(ty)) {
      if (isStringType(val->m_type)) {
        op.mkey.mcode = isProp ? MPT : MET;
        op.mkey.litstr = val->m_data.pstr;
        reduce(env, op);
        return folly::none;
      }
      if (!isProp && val->m_type == KindOfInt64) {
        op.mkey.mcode = MEI;
        op.mkey.int64 = val->m_data.num;
        reduce(env, op);
        return folly::none;
      }
    }
    return std::move(ty);
  };
  switch (op.mkey.mcode) {
    case MEC: case MPC:
      return fixup(topC(env, op.mkey.idx), op.mkey.mcode == MPC);
    case MEL: case MPL:
      return fixup(locAsCell(env, op.mkey.local), op.mkey.mcode == MPL);
    case MW:
      return TBottom;
    case MEI:
      return ival(op.mkey.int64);
    case MET: case MPT: case MQT:
      return sval(op.mkey.litstr);
  }
  not_reached();
}

//////////////////////////////////////////////////////////////////////
// base ops

Base miBaseLocal(ISS& env, LocalId locBase, MOpMode mode) {
  auto const locName = env.ctx.func->locals[locBase].name;
  auto const isDefine = mode == MOpMode::Define;
  if (mode == MOpMode::None ||
      (mode == MOpMode::Warn && !locCouldBeUninit(env, locBase))) {
    nothrow(env);
  }
  // If we're changing the local to define it, we don't need to do an miThrow
  // yet---the promotions (to array or stdClass) on previously uninitialized
  // locals happen before raising warnings that could throw, so we can wait
  // until the first moveBase.
  return Base { isDefine ? locAsCell(env, locBase) : derefLoc(env, locBase),
                BaseLoc::Local,
                TBottom,
                locName,
                locBase };
}

Base miBaseSProp(ISS& env, Type cls, const Type& tprop) {
  auto const self = selfCls(env);
  auto const prop = tv(tprop);
  auto const name = prop && prop->m_type == KindOfPersistentString
                      ? prop->m_data.pstr : nullptr;
  if (self && cls.subtypeOf(*self) && name) {
    if (auto ty = selfPropAsCell(env, name)) {
      return
        Base { std::move(*ty), BaseLoc::StaticProp, std::move(cls), name };
    }
  }
  auto indexTy = env.index.lookup_public_static(cls, tprop);
  if (!indexTy.subtypeOf(TInitCell)) indexTy = TInitCell;
  return Base { std::move(indexTy),
                BaseLoc::StaticProp,
                std::move(cls),
                name };
}

//////////////////////////////////////////////////////////////////////
// intermediate ops

void miProp(ISS& env, bool isNullsafe, MOpMode mode, Type key) {
  auto const name     = mStringKey(key);
  auto const isDefine = mode == MOpMode::Define;
  auto const isUnset  = mode == MOpMode::Unset;
  // PHP5 doesn't modify an unset local if you unset a property or
  // array elem on it, but hhvm does (it promotes it to init-null).
  auto const update = isDefine || isUnset;
  /*
   * MOpMode::Unset Props doesn't promote ""emptyish"" things to stdClass, or
   * affect arrays, however it can define a property on an object base.  This
   * means we don't need any couldBeInFoo logic, but if the base could actually
   * be $this, and a declared property could be Uninit, we need to merge
   * InitNull.
   *
   * We're trying to handle this case correctly as far as the type inference
   * here is concerned, but the runtime doesn't actually behave this way right
   * now for declared properties.  Note that it never hurts to merge more types
   * than a thisProp could actually be, so this is fine.
   *
   * See TODO(#3602740): unset with intermediate dims on previously declared
   * properties doesn't define them to null.
   */
  if (isUnset && couldBeThisObj(env, env.state.mInstrState.base)) {
    if (name) {
      auto const ty = thisPropRaw(env, name);
      if (ty && ty->couldBe(TUninit)) {
        mergeThisProp(env, name, TInitNull);
      }
    } else {
      mergeEachThisPropRaw(env, [&] (const Type& ty) {
        return ty.couldBe(TUninit) ? TInitNull : TBottom;
      });
    }
  }

  if (isDefine) {
    handleInThisPropD(env, isNullsafe);
    handleInPublicStaticPropD(env, isNullsafe);
    promoteBasePropD(env, isNullsafe);
  }

  if (mustBeThisObj(env, env.state.mInstrState.base)) {
    auto const optThisTy = thisType(env);
    auto const thisTy    = optThisTy ? *optThisTy : TObj;
    if (name) {
      auto const propTy = thisPropAsCell(env, name);
      moveBase(env,
               Base { propTy ? *propTy : TInitCell,
                      BaseLoc::Prop,
                      thisTy,
                      name },
               update);
    } else {
      moveBase(env,
               Base { TInitCell, BaseLoc::Prop, thisTy },
               update);
    }
    return;
  }

  // We know for sure we're going to be in an object property.
  if (env.state.mInstrState.base.type.subtypeOf(TObj)) {
    moveBase(env,
             Base { TInitCell,
                    BaseLoc::Prop,
                    env.state.mInstrState.base.type,
                    name },
             update);
    return;
  }

  /*
   * Otherwise, intermediate props with define can promote a null, false, or """"
   * to stdClass.  Those cases, and others, if it's MOpMode::Define, will set
   * the base to a null value in tvScratch.  The base may also legitimately be
   * an object and our next base is in an object property. Conservatively treat
   * all these cases as ""possibly"" being inside of an object property with
   * ""Prop"" with locType TTop.
   */
  moveBase(env,
           Base { TInitCell, BaseLoc::Prop, TTop, name },
           update);
}

void miElem(ISS& env, MOpMode mode, Type key) {
  auto const isDefine = mode == MOpMode::Define;
  auto const isUnset  = mode == MOpMode::Unset;
  auto const update = isDefine || isUnset;

  if (isUnset) {
    /*
     * Elem dims with MOpMode::Unset can change a base from a static array into
     * a reference counted array.  It never promotes emptyish types, however.
     */
    handleInPublicStaticElemU(env);
    promoteBaseElemU(env);

    if (auto ty = array_do_elem(env, false, key)) {
      moveBase(
        env,
        Base { std::move(*ty), BaseLoc::Elem, env.state.mInstrState.base.type },
        update
      );
      return;
    }
  }

  if (isDefine) {
    handleInThisElemD(env);
    handleInPublicStaticElemD(env);
    promoteBaseElemD(env);
  }

  if (auto ty = array_do_elem(env, mode == MOpMode::None, key)) {
    extendArrChain(
      env, std::move(key), env.state.mInstrState.base.type,
      std::move(*ty),
      update
    );
    return;
  }

  if (env.state.mInstrState.base.type.subtypeOf(TStr)) {
    moveBase(env, Base { TStr, BaseLoc::Elem }, update);
    return;
  }

  /*
   * Other cases could leave the base as anything (if nothing else, via
   * ArrayAccess on an object).
   *
   * The resulting BaseLoc is either inside an array, is the global
   * init_null_variant, or inside tvScratch.  We represent this with the
   * Elem base location with locType TTop.
   */
  moveBase(env, Base { TInitCell, BaseLoc::Elem, TTop }, update);
}

void miNewElem(ISS& env) {
  handleInThisNewElem(env);
  handleInPublicStaticNewElem(env);
  promoteBaseNewElem(env);

  if (auto kty = array_do_newelem(env, TInitNull)) {
    extendArrChain(env,
                   std::move(*kty),
                   std::move(env.state.mInstrState.base.type),
                   TInitNull);
  } else {
    moveBase(env, Base { TInitCell, BaseLoc::Elem, TTop });
  }
}

//////////////////////////////////////////////////////////////////////
// final prop ops

void miFinalIssetProp(ISS& env, int32_t nDiscard, const Type& key) {
  auto const name = mStringKey(key);
  discard(env, nDiscard);
  if (name && mustBeThisObj(env, env.state.mInstrState.base)) {
    if (auto const pt = thisPropAsCell(env, name)) {
      if (pt->subtypeOf(TNull))  return push(env, TFalse);
      if (!pt->couldBe(TNull))   return push(env, TTrue);
    }
  }
  push(env, TBool);
}

void miFinalCGetProp(ISS& env, int32_t nDiscard, const Type& key) {
  auto const name = mStringKey(key);
  discard(env, nDiscard);
  if (name && mustBeThisObj(env, env.state.mInstrState.base)) {
    if (auto const t = thisPropAsCell(env, name)) {
      return push(env, *t);
    }
  }
  push(env, TInitCell);
}

void miFinalVGetProp(ISS& env, int32_t nDiscard,
                     const Type& key, bool isNullsafe) {
  auto const name = mStringKey(key);
  handleInThisPropD(env, isNullsafe);
  handleInPublicStaticPropD(env, isNullsafe);
  promoteBasePropD(env, isNullsafe);
  if (couldBeThisObj(env, env.state.mInstrState.base)) {
    if (name) {
      boxThisProp(env, name);
    } else {
      killThisProps(env);
    }
  }
  endBase(env);
  discard(env, nDiscard);
  push(env, TRef);
}

void miFinalSetProp(ISS& env, int32_t nDiscard, const Type& key) {
  auto const name = mStringKey(key);
  auto const t1 = popC(env);

  auto const finish = [&](Type ty) {
    endBase(env);
    discard(env, nDiscard);
    push(env, std::move(ty));
  };

  handleInThisPropD(env, false);
  handleInPublicStaticPropD(env, false);
  promoteBasePropD(env, false);

  if (couldBeThisObj(env, env.state.mInstrState.base)) {
    if (!name) {
      mergeEachThisPropRaw(
        env,
        [&] (Type propTy) {
          return propTy.couldBe(TInitCell) ? t1 : TBottom;
        }
      );
    } else {
      mergeThisProp(env, name, t1);
    }
  }

  if (env.state.mInstrState.base.type.subtypeOf(TObj)) {
    moveBase(
      env,
      Base { t1, BaseLoc::Prop, env.state.mInstrState.base.type, name }
    );
    return finish(t1);
  }

  moveBase(env, Base { TInitCell, BaseLoc::Prop, TTop, name });
  return finish(TInitCell);
}

void miFinalSetOpProp(ISS& env, int32_t nDiscard,
                      SetOpOp subop, const Type& key) {
  auto const name = mStringKey(key);
  auto const rhsTy = popC(env);

  handleInThisPropD(env, false);
  handleInPublicStaticPropD(env, false);
  promoteBasePropD(env, false);

  auto resultTy = TInitCell;

  if (couldBeThisObj(env, env.state.mInstrState.base)) {
    if (name && mustBeThisObj(env, env.state.mInstrState.base)) {
      if (auto const lhsTy = thisPropAsCell(env, name)) {
        resultTy = typeSetOp(subop, *lhsTy, rhsTy);
      }
    }

    if (name) {
      mergeThisProp(env, name, resultTy);
    } else {
      loseNonRefThisPropTypes(env);
    }
  }

  endBase(env);
  discard(env, nDiscard);
  push(env, resultTy);
}

void miFinalIncDecProp(ISS& env, int32_t nDiscard,
                       IncDecOp subop, const Type& key) {
  auto const name = mStringKey(key);

  handleInThisPropD(env, false);
  handleInPublicStaticPropD(env, false);
  promoteBasePropD(env, false);

  auto prePropTy  = TInitCell;
  auto postPropTy = TInitCell;

  if (couldBeThisObj(env, env.state.mInstrState.base)) {
    if (name && mustBeThisObj(env, env.state.mInstrState.base)) {
      if (auto const propTy = thisPropAsCell(env, name)) {
        prePropTy  = typeIncDec(subop, *propTy);
        postPropTy = *propTy;
      }
    }

    if (name) {
      mergeThisProp(env, name, prePropTy);
    } else {
      loseNonRefThisPropTypes(env);
    }
  }

  endBase(env);
  discard(env, nDiscard);
  push(env, isPre(subop) ? prePropTy : postPropTy);
}

void miFinalBindProp(ISS& env, int32_t nDiscard, const Type& key) {
  auto const name = mStringKey(key);
  popV(env);
  handleInThisPropD(env, false);
  handleInPublicStaticPropD(env, false);
  promoteBasePropD(env, false);
  if (couldBeThisObj(env, env.state.mInstrState.base)) {
    if (name) {
      boxThisProp(env, name);
    } else {
      killThisProps(env);
    }
  }
  endBase(env);
  discard(env, nDiscard);
  push(env, TRef);
}

void miFinalUnsetProp(ISS& env, int32_t nDiscard, const Type& key) {
  auto const name = mStringKey(key);

  /*
   * Unset does define intermediate dims but with slightly different
   * rules than sets.  It only applies to object properties.
   *
   * Note that this can't affect self props, because static
   * properties can never be unset.  It also can't change anything
   * about an inner array type.
   */
  handleInThisPropD(env, false);

  if (couldBeThisObj(env, env.state.mInstrState.base)) {
    if (name) {
      unsetThisProp(env, name);
    } else {
      unsetUnknownThisProp(env);
    }
  }

  endBase(env);
  discard(env, nDiscard);
}

//////////////////////////////////////////////////////////////////////
// Final elem ops

// This is a helper for final defining Elem operations that need to
// handle array chains and frame effects, but don't yet do anything
// better than supplying a single type.
void pessimisticFinalElemD(ISS& env, const Type& key, const Type& ty) {
  array_do_set(env, key, ty);
}

template<typename F>
void miFinalCGetElem(ISS& env, int32_t nDiscard,
                     const Type& key, bool nullOnMissing,
                     F transform) {
  auto ty = [&] {
    if (auto type = array_do_elem(env, nullOnMissing, key)) {
      return std::move(*type);
    }
    return TInitCell;
  }();
  discard(env, nDiscard);
  push(env, transform(std::move(ty)));
}

void miFinalVGetElem(ISS& env, int32_t nDiscard, const Type& key) {
  handleInThisElemD(env);
  handleInPublicStaticElemD(env);
  promoteBaseElemD(env);
  pessimisticFinalElemD(env, key, TInitGen);

  auto const finish = [&](Type ty) {
    endBase(env);
    discard(env, nDiscard);
    push(env, std::move(ty));
  };

  auto const& baseTy = env.state.mInstrState.base.type;
  if (baseTy.subtypeOf(TVec) ||
      baseTy.subtypeOf(TDict) ||
      baseTy.subtypeOf(TKeyset)) {
    unreachable(env);
    return finish(TBottom);
  }
  finish(TRef);
}

void miFinalSetElem(ISS& env, int32_t nDiscard, const Type& key) {
  auto const t1  = popC(env);

  handleInThisElemD(env);
  handleInPublicStaticElemD(env);

  auto const finish = [&](Type ty) {
    endBase(env);
    discard(env, nDiscard);
    push(env, std::move(ty));
  };

  // Note: we must handle the string-related cases before doing the
  // general handleBaseElemD, since operates on strings as if this
  // was an intermediate ElemD.
  if (env.state.mInstrState.base.type.subtypeOf(sempty())) {
    env.state.mInstrState.base.type = counted_aempty();
  } else {
    auto& ty = env.state.mInstrState.base.type;
    if (ty.couldBe(TStr)) {
      // Note here that a string type stays a string (with a changed character,
      // and loss of staticness), unless it was the empty string, where it
      // becomes an array.  Do it conservatively for now:
      ty = union_of(
        loosen_staticness(loosen_values(std::move(ty))),
        counted_aempty()
      );
    }
    if (!ty.subtypeOf(TStr)) promoteBaseElemD(env);
  }

  /*
   * In some unusual cases with illegal keys, SetM pushes null
   * instead of the right hand side.
   *
   * There are also some special cases for SetM for different base types:
   * 1. If the base is a string, SetM pushes a new string with the
   * value of the first character of the right hand side converted
   * to a string (or something like that).
   * 2. If the base is a primitive type, SetM pushes null.
   * 3. If the base is an object, and it does not implement ArrayAccess,
   * it is still ok to push the right hand side, because it is a
   * fatal.
   *
   * We push the right hand side on the stack only if the base is an
   * array, object or emptyish.
   */
  if (array_do_set(env, key, t1)) {
    if (env.state.unreachable) return finish(TBottom);
    auto const maybeWeird =
      env.state.mInstrState.base.type.subtypeOf(TArr) && keyCouldBeWeird(key);
    return finish(maybeWeird ? union_of(t1, TInitNull) : t1);
  }

  // ArrayAccess on $this will always push the rhs, even if things
  // were weird.
  if (mustBeThisObj(env, env.state.mInstrState.base)) return finish(t1);

  auto const isWeird =
    keyCouldBeWeird(key) ||
    (!mustBeEmptyish(env.state.mInstrState.base.type) &&
     !env.state.mInstrState.base.type.subtypeOf(TObj));
  finish(isWeird ? TInitCell : t1);
}

void miFinalSetOpElem(ISS& env, int32_t nDiscard,
                      SetOpOp subop, const Type& key) {
  auto const rhsTy = popC(env);
  handleInThisElemD(env);
  handleInPublicStaticElemD(env);
  promoteBaseElemD(env);
  auto const lhsTy = [&] {
    if (auto ty = array_do_elem(env, false, key)) {
      if (env.state.unreachable) return TBottom;
      assertx(!ty->subtypeOf(TBottom));
      return std::move(*ty);
    }
    return TInitCell;
  }();
  auto const resultTy = typeSetOp(subop, lhsTy, rhsTy);
  pessimisticFinalElemD(env, key, resultTy);
  endBase(env);
  discard(env, nDiscard);
  push(env, resultTy);
}

void miFinalIncDecElem(ISS& env, int32_t nDiscard,
                       IncDecOp subop, const Type& key) {
  handleInThisElemD(env);
  handleInPublicStaticElemD(env);
  promoteBaseElemD(env);
  auto const postTy = [&] {
    if (auto ty = array_do_elem(env, false, key)) {
      if (env.state.unreachable) return TBottom;
      assertx(!ty->subtypeOf(TBottom));
      return std::move(*ty);
    }
    return TInitCell;
  }();
  auto const preTy = typeIncDec(subop, postTy);
  pessimisticFinalElemD(env, key, preTy);
  endBase(env);
  discard(env, nDiscard);
  push(env, isPre(subop) ? preTy : postTy);
}

void miFinalBindElem(ISS& env, int32_t nDiscard, const Type& key) {
  popV(env);
  handleInThisElemD(env);
  handleInPublicStaticElemD(env);
  promoteBaseElemD(env);
  pessimisticFinalElemD(env, key, TInitGen);

  auto const finish = [&](Type ty) {
    endBase(env);
    discard(env, nDiscard);
    push(env, std::move(ty));
  };

  auto const& baseTy = env.state.mInstrState.base.type;
  if (baseTy.subtypeOf(TVec) ||
      baseTy.subtypeOf(TDict) ||
      baseTy.subtypeOf(TKeyset)) {
    unreachable(env);
    return finish(TBottom);
  }
  finish(TRef);
}

void miFinalUnsetElem(ISS& env, int32_t nDiscard, const Type&) {
  handleInPublicStaticElemU(env);
  promoteBaseElemU(env);
  // We don't handle inner-array types with unset yet.
  always_assert(env.state.mInstrState.arrayChain.empty());
  auto const& ty = env.state.mInstrState.base.type;
  always_assert(!ty.strictSubtypeOf(TArr) && !ty.strictSubtypeOf(TVec) &&
                !ty.strictSubtypeOf(TDict) && !ty.strictSubtypeOf(TKeyset));
  endBase(env);
  discard(env, nDiscard);
}

//////////////////////////////////////////////////////////////////////
// Final new elem ops

// This is a helper for final defining Elem operations that need to handle
// array chains and frame effects, but don't yet do anything better than
// supplying a single type.
void pessimisticFinalNewElem(ISS& env, const Type& type) {
  array_do_newelem(env, type);
}

void miFinalVGetNewElem(ISS& env, int32_t nDiscard) {
  handleInThisNewElem(env);
  handleInPublicStaticNewElem(env);
  promoteBaseNewElem(env);
  pessimisticFinalNewElem(env, TInitGen);

  auto const finish = [&](Type ty) {
    endBase(env);
    discard(env, nDiscard);
    push(env, std::move(ty));
  };

  auto const& baseTy = env.state.mInstrState.base.type;
  if (baseTy.subtypeOf(TVec) ||
      baseTy.subtypeOf(TDict) ||
      baseTy.subtypeOf(TKeyset)) {
    unreachable(env);
    return finish(TBottom);
  }
  finish(TRef);
}

void miFinalSetNewElem(ISS& env, int32_t nDiscard) {
  auto const t1 = popC(env);

  handleInThisNewElem(env);
  handleInPublicStaticNewElem(env);
  promoteBaseNewElem(env);

  auto const finish = [&](Type ty) {
    endBase(env);
    discard(env, nDiscard);
    push(env, std::move(ty));
  };

  if (array_do_newelem(env, t1)) {
    return finish(t1);
  }

  // ArrayAccess on $this will always push the rhs.
  if (mustBeThisObj(env, env.state.mInstrState.base)) return finish(t1);

  // TODO(#3343813): we should push the type of the rhs when we can;
  // SetM for a new elem still has some weird cases where it pushes
  // null instead to handle.  (E.g. if the base is a number.)
  finish(TInitCell);
}

void miFinalSetOpNewElem(ISS& env, int32_t nDiscard) {
  popC(env);
  handleInThisNewElem(env);
  handleInPublicStaticNewElem(env);
  promoteBaseNewElem(env);
  pessimisticFinalNewElem(env, TInitCell);
  endBase(env);
  discard(env, nDiscard);
  push(env, TInitCell);
}

void miFinalIncDecNewElem(ISS& env, int32_t nDiscard) {
  handleInThisNewElem(env);
  handleInPublicStaticNewElem(env);
  promoteBaseNewElem(env);
  pessimisticFinalNewElem(env, TInitCell);
  endBase(env);
  discard(env, nDiscard);
  push(env, TInitCell);
}

void miFinalBindNewElem(ISS& env, int32_t nDiscard) {
  popV(env);
  handleInThisNewElem(env);
  handleInPublicStaticNewElem(env);
  promoteBaseNewElem(env);
  pessimisticFinalNewElem(env, TInitGen);

  auto const finish = [&](Type ty) {
    endBase(env);
    discard(env, nDiscard);
    push(env, std::move(ty));
  };

  auto const& baseTy = env.state.mInstrState.base.type;
  if (baseTy.subtypeOf(TVec)||
      baseTy.subtypeOf(TDict) ||
      baseTy.subtypeOf(TKeyset)) {
    unreachable(env);
    return finish(TBottom);
  }
  finish(TRef);
}

void miFinalSetWithRef(ISS& env) {
  auto const& baseTy = env.state.mInstrState.base.type;
  auto const isvec = baseTy.subtypeOf(TVec);
  auto const isdict = baseTy.subtypeOf(TDict);
  auto const iskeyset = baseTy.subtypeOf(TKeyset);
  endBase(env);
  if (!isvec && !isdict && !iskeyset) {
    killLocals(env);
    killThisProps(env);
    killSelfProps(env);
  }
}

//////////////////////////////////////////////////////////////////////

template<typename A, typename B>
void handleDualMInstrState(ISS& env, A nondefine, B define) {
  // The current active state should be the non-define case. We'll do the
  // non-define processing first, then swap in the define case into the active
  // state and do the define processing. Then we'll swap the non-define case
  // back into the active state.
  auto start = env.state;

  assert(!env.flags.canConstProp);
  assert(env.flags.wasPEI);
  nondefine();

  auto nonDefineState = std::move(env.state);
  auto const nonDefineFlags = env.flags;

  env.flags.canConstProp = false;
  env.flags.effectFree = false;
  env.flags.wasPEI = true;
  env.state = std::move(start);

  // If we're tracking a separate define state, replace the active state with it
  // so it can be processed. If not, the non-define state (which is active) and
  // the define state are identical, so we don't have to modify anything.
  if (env.state.mInstrStateDefine) {
    env.state.mInstrState = *env.state.mInstrStateDefine;
  }
  define();

  merge_into(env.state, nonDefineState);

  if (nonDefineState.mInstrState.base.loc != BaseLoc::None) {
    // The non-define case continued the sequence (it has a base), so the define
    // case (which is the current active state) can't have ended the sequence.
    assert(env.state.mInstrState.base.loc != BaseLoc::None);
    // Move the active state back into the define state.
    if (env.state.mInstrStateDefine) {
      *env.state.mInstrStateDefine.mutate() = std::move(env.state.mInstrState);
    } else {
      env.state.mInstrStateDefine.emplace(std::move(env.state.mInstrState));
    }
  } else {
    // The non-define case no longer has a base, so it ended the member
    // instruction sequence. The define case (which is the current active state)
    // should likewise have ended the sequence.
    assert(env.state.mInstrState.base.loc == BaseLoc::None);
    assert(env.state.mInstrState.arrayChain.empty());
    assert(nonDefineState.mInstrState.arrayChain.empty());
    env.state.mInstrStateDefine.reset();
  }
  // Set the active state back to be the non-define case.
  env.state.mInstrState = std::move(nonDefineState.mInstrState);

  env.flags.wasPEI |= nonDefineFlags.wasPEI;
  env.flags.canConstProp &= nonDefineFlags.canConstProp;
  env.flags.effectFree &= nonDefineFlags.effectFree;

  // Elements of a minstr sequence should never be constprop - it
  // would leave invalid bytecode.
  assert(!env.flags.canConstProp);
}

/*
 * Helpers to set the MOpMode immediate of a bytecode struct, whether it's
 * subop2 for Base* opcodes or subop1 for a Dim. All users of these functions
 * start with the flags set to Warn.
 */
template<typename BC>
void setMOpMode(BC& op, MOpMode mode) {
  assert(op.subop2 == MOpMode::Warn);
  op.subop2 = mode;
}

void setMOpMode(bc::Dim& op, MOpMode mode) {
  assert(op.subop1 == MOpMode::Warn);
  op.subop1 = mode;
}

folly::Optional<MOpMode> fpassMode(ISS& env, int32_t arg) {
  switch (prepKind(env, arg)) {
    case PrepKind::Unknown: return folly::none;
    case PrepKind::Val:     return MOpMode::Warn;
    case PrepKind::Ref:     return MOpMode::Define;
  }
  always_assert(false);
}

}

namespace interp_step {

//////////////////////////////////////////////////////////////////////
// Base operations

void in(ISS& env, const bc::BaseNC& op) {
  topC(env, op.arg1);
  readUnknownLocals(env);
  mayUseVV(env);
  startBase(
    env,
    Base {
      TInitCell,
      BaseLoc::Local,
      TBottom,
      SString{},
      NoLocalId
    }
  );
}

void in(ISS& env, const bc::BaseNL& op) {
  locAsCell(env, op.loc1);
  readUnknownLocals(env);
  mayUseVV(env);
  startBase(
    env,
    Base {
      TInitCell,
      BaseLoc::Local,
      TBottom,
      SString{},
      NoLocalId
    }
  );
}

void in(ISS& env, const bc::BaseGC& op) {
  topC(env, op.arg1);
  startBase(env, Base{TInitCell, BaseLoc::Global});
}

void in(ISS& env, const bc::BaseGL& op) {
  locAsCell(env, op.loc1);
  startBase(env, Base{TInitCell, BaseLoc::Global});
}

void in(ISS& env, const bc::BaseSC& op) {
  auto prop = topC(env, op.arg1);
  auto cls = takeClsRefSlot(env, op.slot);
  startBase(env, miBaseSProp(env, std::move(cls), prop));
}

void in(ISS& env, const bc::BaseSL& op) {
  auto prop = locAsCell(env, op.loc1);
  auto cls = takeClsRefSlot(env, op.slot);
  startBase(env, miBaseSProp(env, std::move(cls), prop));
}

void in(ISS& env, const bc::BaseL& op) {
  startBase(env, miBaseLocal(env, op.loc1, op.subop2));
}

void in(ISS& env, const bc::BaseC& op) {
  assert(op.arg1 < env.state.stack.size());
  startBase(
    env,
    Base {
      topC(env, op.arg1),
      BaseLoc::Stack,
      TBottom,
      SString{},
      NoLocalId,
      (uint32_t)env.state.stack.size() - op.arg1 - 1
    }
  );
  nothrow(env);
}

void in(ISS& env, const bc::BaseR& op) {
  assert(op.arg1 < env.state.stack.size());
  auto const ty = topR(env, op.arg1);
  startBase(
    env,
    Base {
      ty.subtypeOf(TInitCell) ? std::move(ty) : TInitCell,
      BaseLoc::Stack,
      TBottom,
      SString{},
      NoLocalId,
      (uint32_t)env.state.stack.size() - op.arg1 - 1
    }
  );
  nothrow(env);
}

void in(ISS& env, const bc::BaseH&) {
  auto const ty = thisType(env);
  startBase(env, Base{ty ? *ty : TObj, BaseLoc::This});
  nothrow(env);
}

template<typename BC>
static void fpassImpl(ISS& env, int32_t arg, BC op) {
  if (auto const mode = fpassMode(env, arg)) {
    setMOpMode(op, *mode);
    return reduce(env, op);
  }

  handleDualMInstrState(
    env,
    [&] { in(env, op); },
    [&] {
      setMOpMode(op, MOpMode::Define);
      in(env, op);
    }
  );
}

void in(ISS& env, const bc::FPassBaseNC& op) {
  fpassImpl(env, op.arg1, bc::BaseNC{op.arg2, MOpMode::Warn});
}

void in(ISS& env, const bc::FPassBaseNL& op) {
  fpassImpl(env, op.arg1, bc::BaseNL{op.loc2, MOpMode::Warn});
}

void in(ISS& env, const bc::FPassBaseGC& op) {
  fpassImpl(env, op.arg1, bc::BaseGC{op.arg2, MOpMode::Warn});
}

void in(ISS& env, const bc::FPassBaseGL& op) {
  fpassImpl(env, op.arg1, bc::BaseGL{op.loc2, MOpMode::Warn});
}

void in(ISS& env, const bc::FPassBaseL& op) {
  fpassImpl(env, op.arg1, bc::BaseL{op.loc2, MOpMode::Warn});
}

//////////////////////////////////////////////////////////////////////
// Intermediate operations

void in(ISS& env, const bc::Dim& op) {
  auto const key = key_type_or_fixup(env, op);
  if (!key) return;
  if (mcodeIsProp(op.mkey.mcode)) {
    miProp(env, op.mkey.mcode == MQT, op.subop1, *key);
  } else if (mcodeIsElem(op.mkey.mcode)) {
    miElem(env, op.subop1, *key);
  } else {
    miNewElem(env);
  }
}

void in(ISS& env, const bc::FPassDim& op) {
  if (!key_type_or_fixup(env, op)) return;
  fpassImpl(env, op.arg1, bc::Dim{MOpMode::Warn, op.mkey});
}

//////////////////////////////////////////////////////////////////////
// Final operations

void in(ISS& env, const bc::QueryM& op) {
  auto const key = key_type_or_fixup(env, op);
  if (!key) return;
  auto const nDiscard = op.arg1;

  if (mcodeIsProp(op.mkey.mcode)) {
    // We don't currently do anything different for nullsafe query ops.
    switch (op.subop2) {
      case QueryMOp::CGet:
      case QueryMOp::CGetQuiet:
        miFinalCGetProp(env, nDiscard, *key);
        break;
      case QueryMOp::Isset:
        miFinalIssetProp(env, nDiscard, *key);
        break;
      case QueryMOp::Empty:
        discard(env, nDiscard);
        push(env, TBool);
        break;
    }
  } else if (mcodeIsElem(op.mkey.mcode)) {
    switch (op.subop2) {
      case QueryMOp::CGet:
        miFinalCGetElem(env, nDiscard, *key, false,
                        [](Type t) { return t; });
        break;
      case QueryMOp::CGetQuiet:
        miFinalCGetElem(env, nDiscard, *key, true,
                        [](Type t) { return t; });
        break;
      case QueryMOp::Isset:
        miFinalCGetElem(env, nDiscard, *key, true,
                        [](Type t) {
                          return t.subtypeOf(TInitNull) ? TFalse :
                            !t.couldBe(TInitNull) ? TTrue : TBool;
                        });
        break;
      case QueryMOp::Empty:
        miFinalCGetElem(env, nDiscard, *key, true,
                        [](Type t) {
                          auto const e = emptiness(t);
                          return
                            e == Emptiness::Empty ? TTrue :
                            e == Emptiness::NonEmpty ? TFalse : TBool;
                        });
        break;
    }
  } else {
    // QueryMNewElem will always throw without doing any work.
    discard(env, op.arg1);
    push(env, TInitCell);
  }

  endBase(env, false);
}

void in(ISS& env, const bc::VGetM& op) {
  auto const key = key_type_or_fixup(env, op);
  if (!key) return;
  if (mcodeIsProp(op.mkey.mcode)) {
    miFinalVGetProp(env, op.arg1, *key, op.mkey.mcode == MQT);
  } else if (mcodeIsElem(op.mkey.mcode)) {
    miFinalVGetElem(env, op.arg1, *key);
  } else {
    miFinalVGetNewElem(env, op.arg1);
  }
}

void in(ISS& env, const bc::SetM& op) {
  auto const key = key_type_or_fixup(env, op);
  if (!key) return;
  if (mcodeIsProp(op.mkey.mcode)) {
    miFinalSetProp(env, op.arg1, *key);
  } else if (mcodeIsElem(op.mkey.mcode)) {
    miFinalSetElem(env, op.arg1, *key);
  } else {
    miFinalSetNewElem(env, op.arg1);
  }
}

void in(ISS& env, const bc::IncDecM& op) {
  auto const key = key_type_or_fixup(env, op);
  if (!key) return;
  if (mcodeIsProp(op.mkey.mcode)) {
    miFinalIncDecProp(env, op.arg1, op.subop2, *key);
  } else if (mcodeIsElem(op.mkey.mcode)) {
    miFinalIncDecElem(env, op.arg1, op.subop2, *key);
  } else {
    miFinalIncDecNewElem(env, op.arg1);
  }
}

void in(ISS& env, const bc::SetOpM& op) {
  auto const key = key_type_or_fixup(env, op);
  if (!key) return;
  if (mcodeIsProp(op.mkey.mcode)) {
    miFinalSetOpProp(env, op.arg1, op.subop2, *key);
  } else if (mcodeIsElem(op.mkey.mcode)) {
    miFinalSetOpElem(env, op.arg1, op.subop2, *key);
  } else {
    miFinalSetOpNewElem(env, op.arg1);
  }
}

void in(ISS& env, const bc::BindM& op) {
  auto const key = key_type_or_fixup(env, op);
  if (!key) return;
  if (mcodeIsProp(op.mkey.mcode)) {
    miFinalBindProp(env, op.arg1, *key);
  } else if (mcodeIsElem(op.mkey.mcode)) {
    miFinalBindElem(env, op.arg1, *key);
  } else {
    miFinalBindNewElem(env, op.arg1);
  }
}

void in(ISS& env, const bc::UnsetM& op) {
  auto const key = key_type_or_fixup(env, op);
  if (!key) return;
  if (mcodeIsProp(op.mkey.mcode)) {
    miFinalUnsetProp(env, op.arg1, *key);
  } else {
    assert(mcodeIsElem(op.mkey.mcode));
    miFinalUnsetElem(env, op.arg1, *key);
  }
}

void in(ISS& env, const bc::SetWithRefLML& op) {
  locAsCell(env, op.loc1);
  locAsCell(env, op.loc2);
  miFinalSetWithRef(env);
}

void in(ISS& env, const bc::SetWithRefRML& op) {
  locAsCell(env, op.loc1);
  popR(env);
  miFinalSetWithRef(env);
}

void in(ISS& env, const bc::FPassM& op) {
  if (!key_type_or_fixup(env, op)) return;
  auto const cget = bc::QueryM{op.arg2, QueryMOp::CGet, op.mkey};
  auto const vget = bc::VGetM{op.arg2, op.mkey};

  if (auto const mode = fpassMode(env, op.arg1)) {
    return mode == MOpMode::Warn
      ? reduce_fpass_arg(env, cget, op.arg1, false, op.subop4)
      : reduce_fpass_arg(env, vget, op.arg1, true, op.subop4);
  }

  handleDualMInstrState(
    env,
    [&] { in(env, cget); },
    [&] { in(env, vget); }
  );
}

namespace {

// Find a contiguous local range which is equivalent to the given range and has
// a smaller starting id. Only returns the equivalent first local because the
// size doesn't change.
LocalId equivLocalRange(ISS& env, const LocalRange& range) {
  auto bestRange = range.first;
  auto equivFirst = findLocEquiv(env, range.first);
  if (equivFirst == NoLocalId) return bestRange;
  do {
    if (equivFirst < bestRange) {
      auto equivRange = [&] {
        // local equivalency includes differing by Uninit, so we need
        // to check the types.
        if (peekLocRaw(env, equivFirst) != peekLocRaw(env, range.first)) {
          return false;
        }

        for (uint32_t i = 1; i <= range.restCount; ++i) {
          if (!locsAreEquiv(env, equivFirst + i, range.first + i) ||
              peekLocRaw(env, equivFirst + i) !=
              peekLocRaw(env, range.first + i)) {
            return false;
          }
        }

        return true;
      }();

      if (equivRange) {
        bestRange = equivFirst;
      }
    }
    equivFirst = findLocEquiv(env, equivFirst);
    assert(equivFirst != NoLocalId);
  } while (equivFirst != range.first);

  return bestRange;
}

}

void in(ISS& env, const bc::MemoGet& op) {
  always_assert(env.ctx.func->isMemoizeWrapper);
  always_assert(op.locrange.first + op.locrange.restCount
                < env.ctx.func->locals.size());
  always_assert(env.state.mInstrState.base.loc == BaseLoc::Local ||
                env.state.mInstrState.base.loc == BaseLoc::StaticProp ||
                env.state.mInstrState.base.loc == BaseLoc::Prop);
  always_assert(env.state.mInstrState.arrayChain.empty());

  // If we can use an equivalent, earlier range, then use that instead.
  auto const equiv = equivLocalRange(env, op.locrange);
  if (equiv != op.locrange.first) {
    return reduce(
      env,
      bc::MemoGet { op.arg1, LocalRange { equiv, op.locrange.restCount } }
    );
  }

  nothrow(env);
  for (uint32_t i = 0; i < op.locrange.restCount + 1; ++i) {
    mayReadLocal(env, op.locrange.first + i);
  }
  endBase(env, false);
  discard(env, op.arg1);
  // The pushed value is always the return type of the wrapped function with
  // TUninit unioned in, but that's always going to result in TCell right now.
  push(env, TCell);
}

void in(ISS& env, const bc::MemoSet& op) {
  always_assert(env.ctx.func->isMemoizeWrapper);
  always_assert(op.locrange.first + op.locrange.restCount
                < env.ctx.func->locals.size());
  always_assert(env.state.mInstrState.base.loc == BaseLoc::Local ||
                env.state.mInstrState.base.loc == BaseLoc::StaticProp ||
                env.state.mInstrState.base.loc == BaseLoc::Prop);
  always_assert(env.state.mInstrState.arrayChain.empty());

  // If we can use an equivalent, earlier range, then use that instead.
  auto const equiv = equivLocalRange(env, op.locrange);
  if (equiv != op.locrange.first) {
    return reduce(
      env,
      bc::MemoSet { op.arg1, LocalRange { equiv, op.locrange.restCount } }
    );
  }

  nothrow(env);
  for (uint32_t i = 0; i < op.locrange.restCount + 1; ++i) {
    mayReadLocal(env, op.locrange.first + i);
  }

  auto const t1 = popC(env);

  // The cache set always writes a counted non-empty dict to the base.
  env.state.mInstrState.base.type = TCDictN;
  endBase(env);
  discard(env, op.arg1);
  push(env, t1);
}

}

//////////////////////////////////////////////////////////////////////

}}
",16373,True,2984.188256730519,median
"// 
//     Licensed to the Apache Software Foundation (ASF) under one
//     or more contributor license agreements.  See the NOTICE file
//     distributed with this work for additional information
//     regarding copyright ownership.  The ASF licenses this file
//     to you 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.
//

= NetBeans IDEでのエンタープライズ・アプリケーションのプロファイリング
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: NetBeans IDEでのエンタープライズ・アプリケーションのプロファイリング - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, NetBeans IDEでのエンタープライズ・アプリケーションのプロファイリング

NetBeans IDEには、エンタープライズ・アプリケーションの実行時の動作に関する重要な情報を提供できる強力なプロファイリング・ツールが含まれています。プロファイリング・ツールを使用して、簡単にスレッドの状態をモニターしたり、アプリケーションのCPUパフォーマンスやメモリー使用状況に関するデータを取得したりできます。

このドキュメントでは、プロファイリング・ツールを使用して、アプリケーション・サーバーにWARとしてデプロイされている単純なエンタープライズ・アプリケーションに関するデータを取得します。このドキュメントでは、IDEを使用して次に関するプロファイリング結果を取得する方法を示します。

* アプリケーションの実行時動作
* アプリケーションのメソッドによって使用されたCPU時間
* オブジェクト作成

ローカルに登録されたTomcat、GlassFishサーバーまたはJBossインストールにアプリケーションをデプロイしている場合は、ほとんど構成せずに数回のマウス・クリックのみでアプリケーションをプロファイルできます。プロジェクトをプロファイリングするプロセスは、IDEで「実行」コマンドを使用する場合と非常に似ています。メイン・メニューから「プロファイリング」>「メイン・プロジェクトのプロファイル」を選択することで、エンタープライズ・アプリケーション・プロジェクトまたは個々のWebおよびEJBモジュールのプロファイリングを簡単に開始できます。


image::images/netbeans-stamp-80-74-73.png[title=""このページの内容は、NetBeans IDE 7.3、7.4および8.0に適用されます""]


*このチュートリアルに従うには、次のソフトウェアとリソースが必要です。*

|===
|ソフトウェアまたはリソース |必須バージョン 

|link:https://netbeans.org/downloads/index.html[+NetBeans IDE+] |7.3、7.4、8.0、Java EEバンドル版 

|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+Java Development Kit (JDK)+] |JDK 7または8 

|GlassFishサーバー |3.1, 4.0 
|===

*注意:*

* プロファイラを初めて使用する場合は、タスクのモニタリングとプロファイリングの概要について説明しているlink:../java/profiler-intro.html[+NetBeans IDEでのJavaアプリケーションのプロファイリングの概要+]を読むことをお薦めします。
* NetBeans IDE 7.2またはそれ以前を使用している場合は、link:../../72/javaee/profiler-javaee.html[+NetBeans IDE 7.2でのエンタープライズ・アプリケーションのプロファイリング+]を参照してください。
* このドキュメントでは、GlassFishサーバーにデプロイされたエンタープライズ・アプリケーションをプロファイルします。開発中にエンタープライズ・アプリケーションまたはWebアプリケーションをプロファイリングする場合に推奨される最も単純な構成は、アプリケーションをローカルのTomcat、GlassFishまたはJBossサーバー上で実行しているときです。


== IDEでのエンタープライズ・アプリケーションのプロファイリングについて

エンタープライズ・アプリケーションをプロファイリングするときは、ほとんどの場合、アプリケーションのパフォーマンスを解析してプロジェクトのメソッドの実行時間を確認します。これにより、アプリケーションのトラブルシューティングを行い、パフォーマンスの向上を試みることができます。場合によっては、ガベージ・コレクションを最適化するためにメモリー使用状況に関するデータも入手します。

エンタープライズ・アプリケーション、EJBモジュールおよびWebアプリケーションをプロファイリングするためのプロセスは、基本的に「実行」コマンドを使用してプロジェクトを実行する場合と同じです。プロファイリング・タスクを選択し、プロファイリング・オプションを指定したら、「プロファイリング・タスクの選択」ダイアログ・ボックスで「実行」をクリックしてプロファイリング・セッションを開始します。プロファイリング・セッションを開始すると、IDEによって次が実行されます。

* アプリケーションをコンパイルする
* ターゲット・サーバーをプロファイリング・モードで起動する
* アプリケーションをデプロイする
* アプリケーションにアタッチする
* WebブラウザでWebページを開く(プロジェクト・プロパティで指定された場合)
* 「プロファイリングのライブ結果」タブを開く

プロファイリング・オプションによっては、IDEの「プロファイリングのライブ結果」タブにプロファイリング結果がただちに表示され始めます。プロファイリング用ルート・メソッドを指定したときなど、場合によっては、結果を表示する前にWebブラウザでいくつかのアクションを実行する必要がある場合があります。


=== エンタープライズ・アプリケーション・プロジェクトのプロファイリング

IDEで作成するエンタープライズ・アプリケーションは通常、Webアーカイブ(WAR)としてアプリケーション・サーバーにデプロイされるWebアプリケーション・プロジェクトか、またはWebアプリケーションと追加ライブラリを含み、エンタープライズ・アプリケーション・アーカイブ(EAR)としてデプロイされるエンタープライズ・アプリケーション・プロジェクトのどちらかです。

アプリケーションをEARアーカイブとしてデプロイする場合は、サブプロジェクトとライブラリを含むNetBeansエンタープライズ・アプリケーション・プロジェクトを作成できます。エンタープライズ・アプリケーション・プロジェクトには、ソース・ファイルは含まれず、アプリケーションのビルドとデプロイに関する情報とサーバー構成のメタデータのみが含まれます。エンタープライズ・アプリケーション・プロジェクトでは、一般にアプリケーションのビジネス・ロジックがEJBモジュールに含まれ、プレゼンテーション・レイヤーのソース・コードがWebモジュールに含まれます。

エンタープライズ・アプリケーション・プロジェクトのすべてのソースが存在する場合、アプリケーションをプロファイリングする最も適切で簡単な方法は、プロジェクトの1つのサブプロジェクトではなく、エンタープライズ・アプリケーション・プロジェクトをプロファイルすることです。これにより、必要なすべてのコードがコンパイルおよびデプロイされ、アプリケーションが正常に動作します。次のいずれかを実行することで、エンタープライズ・アプリケーション・プロジェクトをプロファイルできます。

* エンタープライズ・アプリケーション・プロジェクトがメイン・プロジェクトとして設定されている場合は、IDEツールバーから「メイン・プロジェクトのプロファイル」をクリックするか、メイン・メニューで「プロファイル」>「メイン・プロジェクトのプロファイル」を選択します。
* 「プロジェクト」ウィンドウでエンタープライズ・アプリケーション・プロジェクトのノードを右クリックし、ポップアップ・メニューから「プロファイル」を選択します。

エンタープライズ・アプリケーションをプロファイリングするときは、プロファイリング用ルート・メソッドを指定し、インストゥルメント・フィルタを使用してプロファイルされるクラスを制限することにより、プロファイリング結果の関連性を高めることができます。これは、プロファイリングのオーバーヘッドがアプリケーションのパフォーマンスに与える影響を最小限に抑え、プロファイリング結果の関連性を高めるのに役立ちます。

Webアプリケーションと異なり、エンタープライズ・アプリケーションを実行するときは、ブラウザが常に自動的に開くとはかぎりません。(これはプロジェクトの構成によって異なります。)これは、場合によってはWebアプリケーションのフロント・エンドを手動で起動してから、EJBモジュール内のビジネス・ロジックなどのコードをWebブラウザから呼び出す必要があることを意味します。


=== EJBおよびWebモジュール・サブプロジェクトのプロファイリング

任意のEJBモジュールまたはWebモジュール・プロジェクトからプロファイリング・セッションを開始できます。この場合、次のいずれかの方法を試すことをお薦めします。

* *EJBモジュールのプロファイリング。*この方法を選択した場合、EJBモジュール・プロジェクトは一般にWebブラウザを開くように構成されていないため、通常はWebブラウザまたは別のクライアントからアプリケーション・コードを手動で呼び出す必要があります。EJBモジュールがサーバーにデプロイされたら、アプリケーション機能のデバッグや評価の場合と同じ方法で(通常はWebアプリケーションのフロント・エンドを起動してから、Webブラウザでアクションを実行することにより)、そのコードをコールするようにしてください。
* *Webモジュールのプロファイリング。*この方法を選択した場合は、Webモジュール・プロジェクトをプロファイリングする前に、EJBモジュールをコンパイルしてサーバーにデプロイする必要があります。通常、EJBのコードはブラウザ内でのなんらかのユーザー・アクションの結果として実行されます。このアクションがWebアプリケーション・コードによって実行または処理されると、EJBコードがそのコール・ツリーに表示されます。


== サンプル・プロジェクトの作成

このドキュメントでは、ServletStatelessサンプル・アプリケーションをプロファイルします。ServletStatelessアプリケーションは、IDEにサンプル・プロジェクトとして含まれている単純なエンタープライズWebアプリケーションです。

ServletStatelessアプリケーションを作成するには、次の手順を実行します。

1. メイン・メニューから「ファイル」>「新規プロジェクト」([Ctrl]-[Shift]-[N]、Macの場合は[⌘]-[Shift]-[N])を選択します。
2. 新規プロジェクト・ウィザードで、「サンプル」>「Java EE」カテゴリを選択します。
3. Servlet Statelessプロジェクトを選択します。「次」をクリックします。
4. プロジェクトの場所を指定します。「終了」をクリックします。

「終了」をクリックすると、IDEによってServletStatelessサンプル・プロジェクトが作成されます。「プロジェクト」ウィンドウにServletStatelessプロジェクトが表示されます。

*注意:*

* デフォルトでは、IDEを使用してプロジェクトをプロファイルすると、複数のプロジェクトが開いている場合は、「プロジェクト」ウィンドウで選択したプロジェクトがプロファイルされます。メイン・メニューから「実行」>「メイン・プロジェクトとして設定」を選択し、プロジェクトをメイン・プロジェクトとして設定した場合は、メイン・プロジェクトがデフォルトでプロファイルされます。「プロジェクト」ウィンドウでプロジェクト・ノードを右クリックし、ポップアップ・メニューから「プロファイル」を選択できます。
*  ``.jsp`` ページやサーブレットなどのファイルをプロファイルする場合は、そのファイルを右クリックして、ポップアップ・メニューから「ファイルをプロファイル」を選択します。動作は「(メイン)プロジェクトをプロファイル」とほぼ同じですが、プロファイリング・セッションを開始すると、プロジェクトのデフォルトのWebページではなく、選択されたWebページがブラウザで開きます。


== アプリケーションのモニタリング

アプリケーションをモニタリングすると、スレッドのアクティビティやメモリーの割当てなど、ターゲットJVMのプロパティに関する概要を取得できます。アプリケーションのモニタリングにかかるオーバーヘッドは非常に低いため、このモードではアプリケーションを長時間実行できます。「モニター」タスクを選択した場合、ターゲット・アプリケーションはインストゥルメントなしで起動されます。

ServletStatelessアプリケーションをモニターするには、次の手順を実行します。

1. 「実行」>「メイン・プロジェクトとして設定」>「ServletStateless」を選択し、プロジェクトをメイン・プロジェクトとして設定します。

プロジェクトをメイン・プロジェクトとして設定すると、「プロジェクト」ウィンドウでは、そのプロジェクト名が太字で表示されます。

2. メイン・メニューから「プロファイル」>「メイン・プロジェクトのプロファイル」を選択します。

*注意:*プロファイリング用のJavaプラットフォームを選択するプロンプトが表示された場合は、JDK 1.7またはJDK 1.8を選択します。

3. 「プロファイリング・タスクの選択」ダイアログ・ボックスで「モニター」を選択します。
4. 「実行」をクリックします。

*注意:*プロファイラを以前に使用したことがない場合は、「実行」をクリックできるようになる前に、プロファイラを調整するためのプロンプトが表示される場合があります。プロファイラの調整の詳細は、link:../java/profiler-intro.html[+NetBeans IDEでのJavaアプリケーションのプロファイリングの概要+]のlink:../java/profiler-intro.html#calibrate[+初めてのプロファイラの使用+]の項を参照してください。

「実行」をクリックすると、IDEによってアプリケーションがビルドされ、プロファイル・モードでサーバーが起動され、サーバーにアプリケーションがデプロイされます。次に、IDEがアプリケーションにアタッチされ、データの取得が開始されます。

ターゲットJVM内のスレッド上のデータが「スレッド」タブに表示されます。「スレッド」タブには、すべてのスレッド、サーバー・スレッドおよびアプリケーション内のスレッド上のデータが表示されます。

「プロファイラ」ウィンドウの「遠隔測定の概要」ボタンをクリックして「VM遠隔測定の概要」ウィンドウを開くことにより、追加のモニタリング情報を表示できます。「VM遠隔測定の概要」ウィンドウでは、モニタリング・データの概要をリアル・タイムですばやく取得できます。「VM遠隔測定の概要」ウィンドウ内のいずれかのグラフをダブルクリックすると、そのグラフのより大きいバージョンを開くことができます。

エンタープライズ・アプリケーションをモニタリングするときは、メモリー(ヒープ)グラフとメモリー(GC)グラフを使用して、アプリケーションのメモリー使用状況をすばやく確認できます。グラフの上にカーソルを置くと、詳細情報を示すツールチップを開くことができます。ヒープ・サイズや生存中世代の数が徐々に増加している場合は、メモリー・リークを示している可能性があります。メモリー・リークが疑われる場合は、アプリケーションのメモリー使用状況をプロファイルすることをお薦めします。

image::images/monitor-memory-telemetry.png[title=""GCの情報を示すメモリー(GC)グラフ""] 


== アプリケーションのパフォーマンスの解析

「CPUパフォーマンスを解析」タスクを使用して、アプリケーションのメソッド・レベルのCPUパフォーマンス(実行時間)とメソッドが呼び出された回数に関するデータを確認できます。アプリケーション全体のパフォーマンスを解析するか、またはプロファイリング・ルートを選択してプロファイリングをアプリケーション・コードの一部に制限するかを選択できます。

image::images/sample-task.png[title=""「プロファイリング・タスクの選択」ダイアログ・ボックスの「CPU」ペインで選択された「サンプル・アプリケーション」モード""]

「プロファイリング・タスク」ウィンドウで「CPUパフォーマンスを解析」タスクを選択したときは、次のいずれかのオプションを選択することで、プロファイルするアプリケーションの部分を選択できます。

* *簡易(サンプリング)。*このモードでは、IDEはアプリケーションをサンプリングし、定期的にスタック・トレースを取得します。このオプションは、メソッドをインストゥルメントする方法と比較して正確性が低下しますが、オーバーヘッドは低くなります。このオプションは、インストゥルメントが必要になる可能性のあるメソッドを見つけるのに役立ちます。
* *詳細(インストゥルメント済)。*このモードでは、プロファイルされたアプリケーションのメソッドがインストゥルメントされます。IDEでは、スレッドがプロジェクトのメソッドに入った時刻と出た時刻が記録されるため、各メソッド内で費やされた時間の長さを確認できます。メソッドに入るときは、スレッドによって「メソッドに入る」イベントが生成されます。メソッドから出るときは、スレッドによって対応する「メソッドから出る」イベントが生成されます。この両方のイベントのタイムスタンプが記録されます。これらのデータはリアル・タイムで処理されます。

アプリケーション内のすべてのメソッドをインストゥルメントするか、または1つ以上の*ルート・メソッド*を指定することによってインストゥルメントをアプリケーションのコードのサブセットに制限するかを選択できます。ルート・メソッドを指定すると、プロファイリングのオーバーヘッドを大幅に削減できます。ルート・メソッドは、ユーザーがインストゥルメントのルートとして指定する、ソース・コード内のメソッド、クラス、またはパッケージです。プロファイリング・データは、アプリケーションのスレッドのいずれかがインストゥルメントのルートに入ったときと出たときに収集されます。アプリケーションのスレッドのいずれかがルート・メソッドに入るまで、プロファイリング・データは収集されません。ルート・メソッドは、ソース・コード内でポップアップ・メニューを使用するか、または「*カスタマイズ*」をクリックして「プロファイリング・ルートの編集」ダイアログ・ボックスを開くことによって指定できます。

*Webアプリケーションのプロファイリングに関するヒント*

* エンタープライズ・アプリケーションは、通常、Javaコア・クラスに加えて、ターゲット・サーバーのクラスに含まれる多数のメソッドを呼び出します。このため、インストゥルメントされるソースを制限するためのフィルタを選択することが重要です。エンタープライズ・アプリケーションをプロファイリングするときは、「*プロジェクト・クラスだけをプロファイリング*」フィルタを使用することをお薦めします。
* プロファイリング結果は、プロファイリング・セッションが開始されるとすぐに収集されます。詳細方式の使用時にプロファイリング用ルート・メソッドが指定されていない場合は、サーバーの起動(特に、Webアプリケーションのリスナーおよびフィルタの初期化)の直後にいくつかの興味深いデータを取得できます。プロファイリング用ルート・メソッドを指定すると、選択したルート・メソッドによっては、このデータを取得できない可能性があります。
* 通常はリスナーやフィルタに関するデータは必要ないため、「収集結果をリセット」をクリックしてそのデータをクリアできます。Webブラウザでのアクションの結果としてなんらかのコード(通常はJavaBeans、カスタム・タグ、またはその両方を使用するJSPページの表示やサーブレットの ``doGet`` / ``doPost`` メソッドの処理)が呼び出されると、最初に使用可能なデータが収集されます。アプリケーションが初めて起動したときに収集されるデータは、多くの場合、Webアプリケーションの起動動作のみを表していることに注意してください。
* JSPページは、初めて表示されると、サーバーの内部でサーブレットにコンパイルされ、コール・ツリーやメソッドのタイミングに影響を与えます。また、サーブレットや他のアプリケーション・コードの動作は、最初の実行時とアプリケーションが継続的に実行される実際の本番環境とで少し異なる可能性があります。実際のアプリケーション・パフォーマンスをより的確に表すプロファイリング・データを取得するには、時間を測定する前に、プロファイルされるコードに対してある程度のワークロードをかけるようにしてください(コール・ツリーがこの影響を受けないようにしてください)。これは、負荷ジェネレータを使用して簡単に行うことができます。(詳細は、link:../java/profile-loadgenerator.html[+NetBeans IDEでの負荷ジェネレータの使用+]を参照してください。)様々なブラウザのキャッシュ機能も、パフォーマンスに影響を与える可能性があります。

*注意:*Windowsマシン上のGlassFishアプリケーション・サーバーでWebアプリケーションをプロファイリングする場合、スペースが使用されているパス(デフォルトの ``C:\\Program Files\\netbeans-7.4`` へのインストールなど)にNetBeans IDEがインストールされていると、プロファイリング用サーバーの起動が失敗することがあります。これを回避するには、NetBeans IDEのインストール・ディレクトリをパスにスペースが含まれない場所( ``C:\\netbeans-7.4`` など)にインストールまたはコピーします。


=== アプリケーションのサンプリング

アプリケーション全体の動作の概要が必要であり、メソッドをインストゥルメントしない場合は、簡易オプションを選択してください。簡易プロファイル・モードでは、IDEが定期的にスタック・トレースを取得します。簡易プロファイル・モードのオーバーヘッドは、詳細プロファイル・モードより少なくなります。

この課題では、簡易プロファイル・モードを選択して、アプリケーションのパフォーマンスを解析します。

1. 「プロファイラ」ウィンドウの「停止」ボタンをクリックして、モニタリング・セッションを停止します。
2. メイン・メニューから「プロファイル」>「メイン・プロジェクトのプロファイル」を選択します。
3. 「プロファイリング・タスクの選択」ダイアログ・ボックスで「CPU」を選択します。
4. *「簡易(サンプリング)」*モードを選択します。
5. 「フィルタ」ドロップダウン・リストから「*プロジェクト・クラスだけをプロファイル*」を選択します。「実行」をクリックします。

*注意:*このフィルタは、インストゥルメント対象クラスをエンタープライズ・アプリケーション・プロジェクト内のクラスに限定します。フィルタされたクラスの一覧を表示するには、「*フィルタ値を表示*」をクリックします。

image::images/sample-task.png[title=""「プロファイリング・タスクの選択」ダイアログ・ボックスの「CPU」ペインで選択された「サンプル・アプリケーション」モード""]

ダイアログ内の目盛りを見ると、オーバーヘッドが比較的小さいことがわかります。

6. 「プロファイラ」ウィンドウの「プロファイリングのライブ結果」ボタンをクリックして、「プロファイリングのライブ結果」タブを開きます。
image::images/sample-task-results.png[title=""「サンプル・アプリケーション」モードの結果""]

「プロファイリングのライブ結果」タブで、 ``Servlet2Stateless`` クラス内のサーブレットの ``service`` メソッドの実行時間と、このメソッドが1回呼び出されたことを確認できます。


=== すべてのメソッドのインストゥルメント

「アプリケーションをプロファイル」モードでは、アプリケーションのメソッドがインストゥルメントされます。アプリケーションのパフォーマンスをより正確に測定できますが、プロファイリングのオーバーヘッドはサンプル・モードを選択した場合より大きくなります。プロファイリング用ルート・メソッドを指定すると、インストゥルメントされるメソッドが制限され、プロファイリングのオーバーヘッドを削減できます。一部のアプリケーションでは、アプリケーション全体をプロファイリングすると、大量のプロファイリング・データが生成されてアプリケーションが使用できなくなるか、またはアプリケーションがクラッシュする原因になる可能性があるため、ルート・メソッドを指定することが、詳細な、または現実的なパフォーマンス・データを取得するための唯一の方法である場合があります。

この課題では、エンタープライズ・アプリケーション内のすべてのメソッドをインストゥルメントすることにより、アプリケーションのパフォーマンスを解析します。

1. 「プロファイラ」ウィンドウの「停止」ボタンをクリックして、モニタリング・セッションを停止します。
2. メイン・メニューから「プロファイル」>「メイン・プロジェクトのプロファイル」を選択します。
3. 「プロファイリング・タスクの選択」ダイアログ・ボックスで「CPU」を選択します。
4. *「詳細(インストゥルメント済)」*モードを選択します。
5. 「フィルタ」ドロップダウン・リストから「*プロジェクト・クラスだけをプロファイル*」を選択します。「実行」をクリックします。
image::images/advanced-cpu-task.png[title=""「プロファイリング・タスクの選択」ダイアログ・ボックスの「CPU」ペインで選択された「アプリケーションをプロファイル」モード""]

ダイアログ内の目盛りを見ると、オーバーヘッドが「簡易(サンプリング)」プロファイル・モードより大きいことがわかります。

6. 「プロファイラ」ウィンドウの「プロファイリングのライブ結果」ボタンをクリックして、「プロファイリングのライブ結果」タブを開きます。

「プロファイリングのライブ結果」タブに ``Servlet2Stateless`` クラス内のサーブレットの ``init`` および ``service`` メソッドの実行時間が表示され、各メソッドが1回ずつ呼び出されたことを確認できます。 ``StatelessSessionBean`` クラス内の ``init`` メソッドも呼び出されました。

image::images/cpu-pane1-results.png[title=""「アプリケーションをプロファイル」モードの結果""]

*注意:*デフォルトでは、自動リフレッシュ・モードがアクティブになっているため、表示されるデータは数秒ごとに更新されます。自動リフレッシュ・モードは、ツールバーの「自動リフレッシュ」ボタンをクリックすることでアクティブ化および非アクティブ化できます。

収集されるデータの読みやすさを向上させるため、「プロファイリングのライブ結果」ウィンドウのホット・スポット・ビューで結果フィルタを使用して、表示される結果をフィルタできます。結果フィルタは、結果の表示をフィルタするのみであり、インストゥルメントされるクラスには影響しません。結果フィルタを使用すると、定義されたパターン「で始まる」、「を含む」または「で終わる」結果がフィルタされます。より複雑な正規表現をフィルタリングに使用することもできます。データは、最初の結果表の列に表示されたとおりのパッケージ/クラス/メソッド名に基づいてフィルタされます。複数のパターンをスペースまたはカンマとスペースで区切って指定できます。

7. Webブラウザで、フィールドに自分の名前を入力して「問合せを送信」をクリックします。
image::images/cpu-pane1-results1.png[title=""「アプリケーションをプロファイル」モードの結果""]

「問合せを送信」をクリックすると、「プロファイリングのライブ結果」タブが更新され、Webブラウザでのアクションが反映されたことがわかります。ボタンのクリックにより、 ``StatelessSessionBean`` クラス内の ``sayHello`` メソッドが呼び出され、 ``init`` メソッドが再度呼び出されました。 ``Servlet2Stateless`` 内のサーブレットの ``service`` メソッドも再度呼び出されました。タブには、各メソッドに費やされた時間も表示されます。

「ドリルダウン」ボタンをクリックすると、サーブレットやリスナーなど、アプリケーションの様々な領域で費やされた相対的な時間のグラフィカル表現を表示できます。グラフィックをクリックして、表示されているプロファイリング結果にドリルダウンできます。

image::images/drill-down.png[title=""アプリケーション内のサーブレットで費やされた相対的な時間のドリルダウン・グラフ""]

アプリケーションのインストゥルメントでは、アプリケーションをプロファイリングするときに常にある程度のオーバーヘッドが発生します。このような単純なアプリケーションではオーバーヘッドがあまり目立ちませんが、複雑なアプリケーションではオーバーヘッドがかなり大きくなる可能性があります。プロファイリング用ルート・メソッドを選択してプロファイルされるクラスを制限することで、オーバーヘッドを削減できます。


=== プロファイリング用ルート・メソッドの使用

この課題では、アプリケーションの一部のみをプロファイルします。パフォーマンスのボトルネックがどこにあるかわかっていると思われる場合や、コードの特定の部分(たとえば、1つまたは少数のサーブレットのみ)をプロファイルする場合は、このプロファイリング方法を使用するようにしてください。この方法では通常、プロファイリングによって発生するオーバーヘッドが、すべてのアプリケーション・メソッドをインストゥルメントする場合に比べてかなり小さくなります。アプリケーションの一部のみをインストゥルメントすることで、本当に必要なデータのみが収集され、表示されます。

アプリケーションの一部をプロファイルするには、1つまたは複数のプロファイリング用ルート・メソッドを設定する必要があります。IDEは、プロファイリング用ルート・メソッドに入っているスレッドによってコールされたメソッドのみをインストゥルメントします。たとえば、 ``StatelessSessionBean`` クラスの ``sayHello`` メソッドをルート・メソッドとして設定し、「プロジェクト・クラスだけをプロファイル」フィルタを使用すると、このメソッドが呼び出され、アプリケーション・スレッドがこのメソッドに入ったときにIDEがメソッドのインストゥルメントを開始します。このアプリケーションでは、 ``init`` コンストラクタは ``sayHello`` の前に呼び出されるため、インストゥルメントされません。

image::images/profileroot-sayhello-project.png[title=""アプリケーション内のサーブレットで費やされた相対的な時間のドリルダウン・グラフ""]

「すべてのクラスをプロファイル」フィルタを選択すると、IDEは ``sayHello`` によってコールされたJavaコア・クラスを含むすべてのメソッドをインストゥルメントします。

image::images/profileroot-sayhello-all.png[title=""アプリケーション内のサーブレットで費やされた相対的な時間のドリルダウン・グラフ""]

*注意: *より複雑なアプリケーションでは、複数のルート・メソッドを指定することもできます。個々のメソッド、クラス全体およびパッケージをプロファイリング・ルートとして選択できます。

プロファイリング・ルートを指定してアプリケーションのパフォーマンスを解析するには、次の手順を実行します。

1. 「プロファイラ」ウィンドウの「停止」ボタンをクリックして、以前のプロファイリング・セッションを停止します(まだ実行されている場合)。
2. メイン・メニューから「プロファイル」>「メイン・プロジェクトのプロファイル」を選択します。
3. 「プロファイリング・タスクの選択」ダイアログ・ボックスで「CPU」を選択します。
4. *「詳細(インストゥルメント済)」*モードを選択します。
5. 「*カスタマイズ*」をクリックして「プロファイリング・ルートの編集」ダイアログ・ボックスを開きます。

アプリケーションの一部をプロファイルするには、最初にルート・メソッドを指定する必要があります。プロファイリング・ルートを選択することで、プロファイリングをプロファイリング・ルートに入っているスレッドによってコールされたメソッドに制限します。

6. 「プロファイリング・ルートの編集」ダイアログ・ボックスの「ビューを選択」ドロップダウン・リストで、「Webアプリケーション・ビュー」を選択します。
7. ServletStatelessノードを展開して、「サーブレット」パッケージ内の ``service`` メソッドを選択します。「OK」をクリックします。
image::images/edit-profiling-roots.png[title=""「プロファイリング・ルートの編集」ダイアログの「Webアプリケーション・ビュー」""]

または、「パッケージ表示」を選択してアプリケーション内のすべてのソース・パッケージを表示し、 ``servlet.stateless`` パッケージに含まれる ``Servlet2Stateless`` クラスの ``service`` メソッドを選択することもできます。

image::images/edit-profiling-roots-pkg.png[title=""「プロファイリング・ルートの編集」ダイアログの「パッケージ表示」""]

*注意:* ``Servlet2Stateless`` コンストラクタが選択されていないことに注意してください。「プロファイリング・ルートの編集」ダイアログを使用して、インストゥルメントをクラス内の特定のメソッドに制限できます。インストゥルメントを特定のメソッドに制限しない場合は、「パッケージ表示」を使用してクラスまたはパッケージ全体を選択できます。たとえば、「プロファイリング・ルートの編集」ダイアログ・ボックスの「パッケージ表示」で ``Servlet2Stateless`` クラスを選択すると、IDEは ``init`` コンストラクタと ``service`` メソッドをインストゥルメントします。

「詳細」ボタンをクリックすると、「プロファイリング・ルートの編集(詳細)」ダイアログ・ボックスに ``service`` メソッドが唯一のルート・メソッドとして表示されることがわかります。「追加」をクリックし、メソッドの署名とクラスを入力することでメソッドを明示的に定義できます。

image::images/edit-profilingroots-pkg-adv.png[title=""「プロファイリング・ルートの編集(詳細)」ダイアログ""]
8. 「プロファイリング・ルートの編集」ダイアログ・ボックスで「OK」をクリックします。

「プロファイリング・タスクの選択」ダイアログ・ボックスで、詳細プロファイリング・モードがカスタム・プロファイリング・ルートを使用して実行されることを確認できます。「*編集*」をクリックすると、選択したルート・メソッドを表示および変更できます。これで、ルート・メソッドを指定しなかった場合に比べてプロファイリングのオーバーヘッドが小さくなりました。

9. 「フィルタ」ドロップダウン・リストから「*プロジェクト・クラスだけをプロファイル*」を選択します。「実行」をクリックします。
image::images/advanced-cpu-task-custom.png[title=""カスタム・プロファイリング・ルート付きで選択された「アプリケーションをプロファイル」モード""]

「実行」をクリックすると、IDEによってアプリケーションがビルドおよびデプロイされ、Webブラウザが開いてサーブレットのページが表示されます。

IDEの「プロファイリングのライブ結果」タブにプロファイリング結果が表示されます。

image::images/cpu-pane2-results.png[title=""プロファイリング・ルートを使用してメソッドをインストゥルメントした結果""]

プロファイリング・ルートとして指定したメソッドの結果のみがIDEに表示されることがわかります。アプリケーション・スレッドは、プロファイリング・ルートに入った後、アプリケーション内の他のメソッドに入っていません。

アプリケーションはプロファイリング・ルートに入った後で他のメソッドに入っていますが、インストゥルメント・フィルタによってインストゥルメントがプロジェクトの一部のクラスに制限されているため、これらの他のメソッドは表示されません。

10. Webブラウザで、フィールドに自分の名前を入力して「問合せを送信」をクリックします。
image::images/cpu-pane2-results1.png[title=""sayHelloメソッドの呼出し後にプロファイリング・ルートを使用してメソッドをインストゥルメントした結果""]

「問合せを送信」をクリックすると、「プロファイリングのライブ結果」タブが更新され、Webブラウザでのアクションが反映されたことがわかります。ボタンのクリックにより、 ``StatelessSessionBean`` クラス内の ``sayHello`` メソッドが1回呼び出されました。 ``service`` メソッドも再度呼び出されました。

結果には、アプリケーションのパフォーマンスが表示されますが、長期間実行されているアプリケーションのパフォーマンスが正確に表されていない可能性があります。より現実的な条件下でWebアプリケーションのパフォーマンスをエミュレートする1つの方法は、負荷ジェネレータ・スクリプトを実行することです。

11. ブラウザで前のステップを数回繰り返してから、「プロファイリングのライブ結果」タブの「結果のリセット」をクリックして結果をクリアします。
12. プロファイリング結果がリセットされたら、もう一度自分の名前を入力して「問合せを送信」をクリックします。
image::images/cpu-pane2-results2.png[title=""sayHelloメソッドの呼出し後にプロファイリング・ルートを使用してメソッドをインストゥルメントした結果""]

プロファイリング結果を見ると、ほとんどの場合、パフォーマンスが向上していることがわかります。


=== インストゥルメント・フィルタの使用

CPUパフォーマンスを解析するときは、ドロップダウン・リストからインストゥルメント・フィルタを選択し、プロファイリングを必要なソース・コードに制限することで、プロファイリングのオーバーヘッドを削減できます。フィルタを使用して、インストゥルメントされるパッケージまたはクラスを指定できます。次のデフォルト・フィルタから選択するか、カスタム・フィルタを作成できます。

* *すべてのクラスをプロファイル。*Webアプリケーションまたはエンタープライズ・アプリケーションをプロファイリングするときにこのフィルタを選択すると、コアJavaクラスやサーバー・クラスを含むすべてのクラスがインストゥルメントされます。これほど多くのクラスをインストゥルメントすると、*非常に*大きなオーバーヘッドが発生する可能性があるため、このフィルタを選択する場合は注意が必要です。
* *プロジェクト・クラスだけをプロファイリング*。エンタープライズ・アプリケーションをプロファイリングする場合は、このフィルタを使用して、インストゥルメントされるコードをプロジェクト内のクラスに制限することをお薦めします。サーバー・クラスはインストゥルメントされません。
* *プロジェクトとサブプロジェクトのクラスをプロファイル。*Webアプリケーション、EJBモジュール、クラス・ライブラリなどのサブプロジェクトを含むエンタープライズ・アプリケーション・プロジェクトをプロファイリングする場合は、このフィルタを選択して、インストゥルメント対象コードをサブプロジェクト内のクラスに制限できます。

カスタム・フィルタを作成して、特定のプロジェクトや特定タイプのプロファイリングで使用できます。たとえば、Oracle WebLogic Server上のWebアプリケーションをプロファイリングするときに使用するインストゥルメント・フィルタが必要な場合は、「フィルタ・セットを編集」をクリックして、Javaコア・クラス、Oracle WebLogicクラスおよびNetBeansクラスを除外するフィルタ・セットを作成できます(HTTPモニターが有効になっている場合に便利です)。フィルタ・セットに「WebLogic Webapp Exclusive」などの名前を設定しておき、WebLogicサーバーにデプロイされたアプリケーションをプロファイリングするときに、「フィルタ」ドロップダウン・リストからそのフィルタを選択できます。

image::images/custom-filter.png[title=""プロジェクトを初めてプロファイリングする場合に表示されるダイアログ・ボックス""]

「フィルタ」ドロップダウン・リストから「簡易フィルタ」を選択し、「簡易フィルタの設定」ダイアログ・ボックスを開くことで、簡易なインストゥルメント・フィルタを定義できます。インストゥルメントされるパッケージまたはクラスの一覧をすばやく編集できます。これにより、「フィルタ」ドロップダウン・リストから選択できる簡易フィルタが作成されます。

image::images/set-quick-filter.png[title=""プロジェクトを初めてプロファイリングする場合に表示されるダイアログ・ボックス""]

インストゥルメント・フィルタの定義と使用の詳細は、IDEのプロファイリングに関するドキュメントを参照してください。


== アプリケーションのメモリー使用状況の解析

IDEのプロファイリング・ツールを使用して、エンタープライズ・アプリケーションのメモリー使用状況を解析し、オブジェクト割当てやガベージ・コレクションに関する詳細なデータを取得できます。「メモリー使用状況を解析」タスクによって、ターゲット・アプリケーション内で割り当てられているオブジェクトに関するデータ(割り当てられたオブジェクトの数、型、場所など)が提供されます。

メモリー使用状況をプロファイリングするときは、プロファイリング用ルート・メソッドやインストゥルメント・フィルタを設定できないため、サーバーの実行中に作成されたすべてのオブジェクトがトラックされます。このため、複雑なアプリケーション・サーバーでは、プロファイリングのオーバーヘッドやメモリーの消費量が大きくなる可能性があります。したがって、このタイプのプロファイリングを実行する前に、マシンの潜在的な制限事項について知っておくようにしてください。プロファイリングのオーバーヘッドを軽減するため、10個に1個の割合でのみオブジェクトをプロファイルするように設定を変更できます。オブジェクト割当てのスタック・トレースの記録を無効化(制限)することもできます。

メモリー・リークを検出するためにエンタープライズ・アプリケーションをプロファイリングするときは、「生存中世代」のメトリックを使用すると非常に便利なことがあります。このツールは、ガベージ・コレクションのサイクルを経て生存する様々なオブジェクト世代の数をトラックすることにより、アプリケーションのメモリー使用量が著しく大きくなる前にメモリー・リークを検出できます。

メモリー・パフォーマンスを解析するには、次のオプションのいずれかを選択することによって、取得するデータの量を選択します。

* *簡易。*このオプションが選択されている場合、プロファイラはアプリケーションをサンプリングして、ライブ・オブジェクトに限定されたデータを提供します。ライブ・オブジェクトとは、ガベージ・コレクタによって回収されていないアクセス可能(およびアクセス不能)なすべてのオブジェクトです。このオプションは、ライブ・オブジェクトのみ追跡し、計測時に割当てを追跡しません。このオプションを選択した場合は、スタック・トレースを記録したり、プロファイリング・ポイントを使用したりすることはできません。このオプションを選択すると、「詳細」オプションよりもオーバーヘッドが大幅に削減されます。
* *詳細。*このオプションを選択すると、割り当てられたオブジェクトの数、タイプおよび場所に関する情報を取得できます。割り当てられたオブジェクトとは、アプリケーションを起動してから(またはプロファイラでの収集結果が最後にリセットされてから)これまでに作成されたオブジェクトです。ターゲットJVMによって現在ロードされているすべてのクラス(および新規にロードされる各クラス)が計測され、オブジェクト割当てに関する情報が生成されます。メモリ使用状況の分析時にプロファイリング・ポイントを使用する場合、またはコール・スタックを記録する場合は、このオプションを選択する必要があります。このオプションを選択すると、簡易オプションよりもプロファイリング・オーバーヘッドが増加します。

「詳細」オプションを選択した場合は、次のオプションも設定できます。

* *完全なオブジェクト・ライフスタイルを記録。*存続している世代数など、各オブジェクトのすべての情報を記録するには、このオプションを選択します。
* *割当てのスタック・トレースを記録。*完全なコール・スタックを記録するには、このオプションを選択します。このオプションでは、メモリー・スナップショットを表示する際にメソッド呼出しの逆呼出しツリーを表示できます。
* *定義済みプロファイリング・ポイントを使用。*プロファイリング・ポイントを有効にするには、このオプションを選択します。無効なプロファイリング・ポイントは無視されます。選択解除されている場合は、プロジェクト内のすべてのプロファイリング・ポイントが無視されます。

「プロファイリング・タスクの選択」ウィンドウの「オーバーヘッド」メーターは、ユーザーが選択したプロファイリング・オプションに応じて、プロファイリングのオーバーヘッドの大まかな増減を示します。

ここで、IDEを使用してエンタープライズ・アプリケーションのメモリー・パフォーマンスを解析します。存続している世代に関する情報を取得する場合は、*「詳細」*オプションを選択する必要があります。または、ライブ・オブジェクトに関するデータが必要な場合は、*簡易*オプションを選択できます。

1. 「プロファイラ」ウィンドウの「停止」ボタンをクリックして、以前のプロファイリング・セッションを停止します(まだ実行されている場合)。
「停止」をクリックすると、IDEがアプリケーションからデタッチされます。
2. メイン・メニューから「プロファイル」>「メイン・プロジェクトのプロファイル」を選択します。
3. 「プロファイリング・タスクの選択」ダイアログ・ボックスで「*メモリー*」を選択します。
4. *「詳細」*を選択します。
5. *「完全なオブジェクト・ライフサイクルを記録」*を選択して、存続している世代に関するデータを取得します。

*注意:*このオプションを選択すると、「オーバーヘッド」メーターが大幅に増加します。エンタープライズ・アプリケーションをプロファイリングするときは、収集されるデータ量のため、ほとんどの場合、IDE用のメモリーを増やす必要がありあります。

6. 「*定義済みプロファイリング・ポイントを使用*」を選択解除します(選択されている場合)。「実行」をクリックします。
image::images/profile-memory-advanced.png[title=""「メモリー」タスクとオプションが表示された「プロファイリング・タスクの選択」ダイアログ""]

「実行」をクリックすると、IDEによってアプリケーションがコンパイルされ、プロファイル・モードでサーバーが起動され、サーバーにアプリケーションがデプロイされます。プロファイリング結果を表示するには、「プロファイラ」ウィンドウ内の「ライブ結果」をクリックして「ライブ結果」ウィンドウを開きます。「ライブ結果」ウィンドウに、ターゲットJVMに割り当てられたオブジェクトのサイズと数に関する情報が表示されます。結果には、エンタープライズ・アプリケーションによって割り当てられたオブジェクトに加えて、アプリケーション・サーバーによって割り当てられたオブジェクトもすべて含まれています。

image::images/profile-memory-results.png[title=""メモリー使用状況のプロファイリングの結果が表示された「プロファイリング結果」タブ""]

デフォルトでは、結果は「ライブ・バイト数」の数でソートされて表示されますが、列ヘッダーをクリックすると結果の表示方法を変更できます。また、リストの下にあるフィルタ・ボックスにクラス名を入力して結果をフィルタすることもできます。

link:/about/contact_form.html?to=3&subject=Feedback:%20Profiling%20Enterprise%20Applications[+このチュートリアルに関するご意見をお寄せください+]



== 関連項目

このドキュメントでは、GlassFishアプリケーション・サーバーにデプロイされたエンタープライズ・アプリケーションをプロファイリングするときにプロファイリング・データを取得する基本的な方法について説明しました。

このドキュメントで説明されていないプロファイリング設定および機能の詳細は、製品に含まれ、「ヘルプ」メニュー項目から使用できるドキュメントを参照してください。

関連ドキュメントについては、次のリソースを参照してください。

* link:http://wiki.netbeans.org/wiki/view/NetBeansUserFAQ#section-NetBeansUserFAQ-Profiler[+NetBeansプロファイラのFAQ+]
NetBeans IDEでのアプリケーションのプロファイリングに関連した、よくある質問を含むドキュメント
* link:http://wiki.netbeans.org/wiki/view/FaqProfilerProfileFreeForm[+FAQ: 自由形式プロジェクトのプロファイリング+]
* link:../java/profiler-screencast.html[+スクリーンキャスト: プロファイリング・ポイント、ドリルダウン・グラフ、ヒープ・ウォーカ+]
NetBeans IDEのいくつかのプロファイリング機能を示すデモ。
* link:../../../community/magazine/html/04/profiler.html[+詳細なプロファイリング: 実行理論+]
* link:http://profiler.netbeans.org/index.html[+profiler.netbeans.org+]
NetBeansプロファイラ・プロジェクトのサイト
* link:http://blogs.oracle.com/nbprofiler/[+NetBeansプロファイラのブログ+]
* link:http://profiler.netbeans.org/mailinglists.html[+NetBeansプロファイラのメーリング・リスト+]
* link:http://profiler.netbeans.org/docs/help/5.5/index.html[+NetBeansプロファイラ5.5の使用+]

<<top,先頭>>

",12291,True,2656.6851604534077,median
"////
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements.  See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You 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.
////

== TinkerPop 3.5.0

=== Upgrading for Users

==== Upgrade Neo4j

Refer to Neo4j link:https://neo4j.com/guides/upgrade-archive/[3.4 Upgrade FAQ] for guide on how to upgrade from the previous 3.2.3 version.
For example, configuration setting `dbms.allow_format_migration` is now `dbms.allow_upgrade`.

= TinkerPop 3.4.0

image::https://raw.githubusercontent.com/apache/tinkerpop/master/docs/static/images/avant-gremlin.png[width=225]

*Avant-Gremlin Construction #3 for Theremin and Flowers*

== TinkerPop 3.4.3

*Release Date: August 5, 2019*

Please see the link:https://github.com/apache/tinkerpop/blob/3.4.3/CHANGELOG.asciidoc#release-3-4-3[changelog] for a complete list of all the modifications that are part of this release.

=== Upgrading for Users

==== Deprecated store()

The `store()`-step and `aggregate()`-step do the same thing in different ways, where the former is lazy and the latter
is eager in the side-effect collection of objects from the traversal. The different behaviors can be thought of as
differing applications of `Scope` where `global` is eager and `local` is lazy. As a result, there is no need for both
steps when one will do.

As of 3.4.3, `store(String)` is now deprecated in favor of `aggregate(Scope, String)` where the `Scope` should be set
to `local` to ensure the same functionality as `store()`. Note that `aggregate('x')` is the same as
`aggregate(global,'x')`.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1553[TINKERPOP-1553]

==== Deprecate Gryo in Gremlin Server

Gryo is now deprecated as a serialization format for Gremlin Server, however, it is still configured as a default
option in the sample configuration files packaged with the server. The preferred serialization option should now be
GraphBinary. Note that Gremlin Console is now configured to use GraphBinary by default.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2250[TINKERPOP-2250]

=== Upgrading for Providers

==== Graph Driver Providers

===== Gremlin Server Test Configuration

Gremlin Server has a test configuration built into its Maven build process which all integration tests and Gremlin
Language Variants use to validate their operations. While this approach has worked really well for test automation
within Maven, there are often times where it would be helpful to simply have Gremlin Server running with that
configuration. This need is especially true when developing Gremlin Language Variants which is something that is done
outside of the JVM.

This release introduces a Docker script that will start Gremlin Server with this test configuration. It can be started
with:

[source,text]
docker/gremlin-server.sh

Once started, it is then possible to run GLV tests directly from a debugger against this instance which should
hopefully reduce development friction.

see: link:http://tinkerpop.apache.org/docs/3.4.3/dev/developer/#docker-integration[Developer Documentation]

== TinkerPop 3.4.2

*Release Date: May 28, 2019*

Please see the link:https://github.com/apache/tinkerpop/blob/3.4.2/CHANGELOG.asciidoc#release-3-4-2[changelog] for a complete list of all the modifications that are part of this release.

=== Upgrading for Users

==== Per Request Options

In 3.4.0, the notion of `RequestOptions` were added so that users could have an easier way to configure settings on
individual requests made through the Java driver. While that change provided a way to set those configurations for
script based requests, it didn't include options to make those settings in a `Traversal` submitted via `Bytecode`. In
this release those settings become available via `with()` step on the `TraversalSource` as follows:

[source,java]
----
GraphTraversalSource g = traversal().withRemote(conf);
List<Vertex> vertices = g.with(RemoteConnection.PER_REQUEST_TIMEOUT, 500).V().out(""knows"").toList()
----

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2211[TINKERPOP-2211]

==== Gremlin Console Timeout

The Gremlin Console timeout that is set by `:remote config timeout x` was client-side only in prior versions, which
meant that if the console timeout was less than the server timeout the client would timeout but the server might still
be processing the request. Similarly, a longer timeout on the console would not change the server and the timeout
would occur sooner than expected. These discrepancies often led to confusion.

As of 3.4.0, the Java Driver API allowed for timeout settings to be more easily passed per request, so the console
was modified for this current version to pass the console timeout for each remote submission thus yielding more
consistent and intuitive behavior.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2203[TINKERPOP-2203]

=== Upgrading for Providers

==== Graph System Providers

===== Warnings

It is now possible to pass warnings over the Gremlin Server protocol using a `warnings` status attribute. The warnings
are expected to be a string value or a `List` of string values which can be consumed by the user or tools that check
for that status attribute. Note that Gremlin Console is one such tool that will respond to this status attribute - it
will print the messages to the console as they are detected when doing remote script submissions.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2216[TINKERPOP-2216]

==== Graph Driver Providers

===== GraphBinary API Change

In GraphBinary serialization, Java `write()` and `writeValue()` from `TypeSerializer<T>` interface now take a Netty's
`ByteBuf` instance instead of an `ByteBufAllocator`, that way the same buffer instance gets reused during the write
of a message. Additionally, we took the opportunity to remove the unused parameter from `ResponseMessageSerializer`.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2161[TINKERPOP-2161]

== TinkerPop 3.4.1

*Release Date: March 18, 2019*

Please see the link:https://github.com/apache/tinkerpop/blob/3.4.1/CHANGELOG.asciidoc#release-3-4-1[changelog] for a complete list of all the modifications that are part of this release.

=== Upgrading for Users

==== Mix SPARQL and Gremlin

In the initial release of `sparql-gremlin` it was only possible to execute a SPARQL query and have it translate to
Gremlin. Therefore, it was only possible to write a query like this:

[source,text]
----
gremlin> g.sparql(""SELECT ?name ?age WHERE { ?person v:name ?name . ?person v:age ?age }"")
==>[name:marko,age:29]
==>[name:vadas,age:27]
==>[name:josh,age:32]
==>[name:peter,age:35]
gremlin> g.sparql(""SELECT * WHERE { }"")
==>v[1]
==>v[2]
==>v[3]
==>v[4]
==>v[5]
==>v[6]
----

In this release, however, it is now possible to further process that result with Gremlin steps:

[source,text]
----
gremlin> g.sparql(""SELECT ?name ?age WHERE { ?person v:name ?name . ?person v:age ?age }"").select(""name"")
==>marko
==>vadas
==>josh
==>peter
gremlin> g.sparql(""SELECT * WHERE { }"").out(""knows"").values(""name"")
==>vadas
==>josh
----

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2171[TINKERPOP-2171],
link:http://tinkerpop.apache.org/docs/3.4.1/reference/#sparql-with-gremlin[Reference Documentation]

=== Upgrading for Providers

==== Graph Database Providers

===== GraphBinary Serializer Changes

In GraphBinary serialization, Java `write()` and `writeValue()` from `TypeSerializer<T>` interface now take a Netty's
`ByteBuf` instance instead of an `ByteBufAllocator`, that way the same buffer instance gets reused during the write
of a message. Additionally, we took the opportunity to remove the unused parameter from `ResponseMessageSerializer`.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2161[TINKERPOP-2161]

== TinkerPop 3.4.0

*Release Date: January 2, 2019*

Please see the link:https://github.com/apache/tinkerpop/blob/3.4.0/CHANGELOG.asciidoc#release-3-4-0[changelog] for a complete list of all the modifications that are part of this release.

=== Upgrading for Users

==== sparql-gremlin

The `sparql-gremlin` module is a link:https://en.wikipedia.org/wiki/SPARQL[SPARQL] to Gremlin compiler, which allows
SPARQL to be executed over any TinkerPop-enabled graph system.

[source,groovy]
----
graph = TinkerFactory.createModern()
g = graph.traversal(SparqlTraversalSource)
g.sparql(""""""SELECT ?name ?age
            WHERE { ?person v:name ?name . ?person v:age ?age }
            ORDER BY ASC(?age)"""""")
----

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1878[TINKERPOP-1878],
link:http://tinkerpop.apache.org/docs/3.4.0/reference/#sparql-gremlin[Reference Documentation]

==== Gremlin.NET Driver Improvements

The Gremlin.NET driver now uses request pipelining. This allows connections to be reused for different requests in
parallel which should lead to better utilization of connections. The `ConnectionPool` now also has a fixed size
whereas it could previously create an unlimited number of connections. Each `Connection` can handle up to
`MaxInProcessPerConnection` requests in parallel. If this limit is reached for all connections, then a
`NoConnectionAvailableException` is thrown which makes this a breaking change.

These settings can be set as properties on the `ConnectionPoolSettings` instance that can be passed to the `GremlinClient`.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1774[TINKERPOP-1774],
link:https://issues.apache.org/jira/browse/TINKERPOP-1775[TINKERPOP-1775],
link:http://tinkerpop.apache.org/docs/3.4.0/reference/#_connection_pool[Reference Documentation]

==== Indexing of Collections

TinkerPop 3.4.0 adds a new `index()`-step, which allows users to transform simple collections into index collections or maps.

```
gremlin> g.V().hasLabel(""software"").values(""name"").fold().
......1>   order(local).
......2>   index().unfold()
==>[lop,0]
==>[ripple,1]
gremlin> g.V().hasLabel(""person"").values(""name"").fold().
......1>   order(local).by(decr).
......2>   index().
......3>     with(WithOptions.indexer, WithOptions.map)
==>[0:vadas,1:peter,2:marko,3:josh]
```

==== Modulation of valueMap()

The `valueMap()` step now supports `by` and `with` modulation, which also led to the deprecation of `valueMap(true)` overloads.

===== by() Modulation

With the help of the `by()` modulator `valueMap()` result values can now be adjusted, which is particularly useful to turn multi-/list-values into single values.

```
gremlin> g.V().hasLabel(""person"").valueMap()
==>[name:[marko],age:[29]]
==>[name:[vadas],age:[27]]
==>[name:[josh],age:[32]]
==>[name:[peter],age:[35]]
gremlin> g.V().hasLabel(""person"").valueMap().by(unfold())
==>[name:marko,age:29]
==>[name:vadas,age:27]
==>[name:josh,age:32]
==>[name:peter,age:35]
```
===== with() Modulation

The `with()` modulator can be used to include certain tokens (`id`, `label`, `key` and/or `value`).

The old way (still valid, but deprecated):

```
gremlin> g.V().hasLabel(""software"").valueMap(true)
==>[id:10,label:software,name:[gremlin]]
==>[id:11,label:software,name:[tinkergraph]]
gremlin> g.V().has(""person"",""name"",""marko"").properties(""location"").valueMap(true)
==>[id:6,key:location,value:san diego,startTime:1997,endTime:2001]
==>[id:7,key:location,value:santa cruz,startTime:2001,endTime:2004]
==>[id:8,key:location,value:brussels,startTime:2004,endTime:2005]
==>[id:9,key:location,value:santa fe,startTime:2005]
```

The new way:

```
gremlin> g.V().hasLabel(""software"").valueMap().with(WithOptions.tokens)
==>[id:10,label:software,name:[gremlin]]
==>[id:11,label:software,name:[tinkergraph]]
gremlin> g.V().has(""person"",""name"",""marko"").properties(""location"").valueMap().with(WithOptions.tokens)
==>[id:6,key:location,value:san diego,startTime:1997,endTime:2001]
==>[id:7,key:location,value:santa cruz,startTime:2001,endTime:2004]
==>[id:8,key:location,value:brussels,startTime:2004,endTime:2005]
==>[id:9,key:location,value:santa fe,startTime:2005]
```

Furthermore, now there's a finer control over which of the tokens should be included:

```
gremlin> g.V().hasLabel(""software"").valueMap().with(WithOptions.tokens, WithOptions.labels)
==>[label:software,name:[gremlin]]
==>[label:software,name:[tinkergraph]]
gremlin> g.V().has(""person"",""name"",""marko"").properties(""location"").valueMap().with(WithOptions.tokens, WithOptions.values)
==>[value:san diego,startTime:1997,endTime:2001]
==>[value:santa cruz,startTime:2001,endTime:2004]
==>[value:brussels,startTime:2004,endTime:2005]
==>[value:santa fe,startTime:2005]
```

As shown above, the support of the `with()` modulator for `valueMap()` makes the `valueMap(boolean)` overload
superfluous, hence this overload is now deprecated. This is a breaking API change, since `valueMap()` will now always
yield instances of type `Map<Object, Object>`. Prior this change only the `valueMap(boolean)` overload yielded
`Map<Object, Object>` objects, `valueMap()` without the boolean parameter used to yield instances of type
`Map<String, Object>`.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2059[TINKERPOP-2059]

==== Predicate Number Comparison

In previous versions `within()` and `without()` performed strict number comparisons; that means these predicates did
not only compare number values, but also the type. This was inconsistent with how other predicates (like `eq`, `gt`,
etc.) work. All predicates will now ignore the number type and instead compare numbers only based on their value.

Old behavior:

```
gremlin> g.V().has(""age"", eq(32L))
==>v[4]
gremlin> g.V().has(""age"", within(32L, 35L))
gremlin>
```

New behavior:

```
gremlin> g.V().has(""age"", eq(32L))
==>v[4]
gremlin> g.V().has(""age"", within(32L, 35L))
==>v[4]
==>v[6]
```

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2058[TINKERPOP-2058]

==== ReferenceElementStrategy

Gremlin Server has had some inconsistent behavior in the serialization of the results it returns. Remote traversals
based on Gremlin bytecode always detach returned graph elements to ""reference"" (i.e. removes properties and only
include the `id` and `label`), but scripts would detach graph elements and include the properties. For 3.4.0,
TinkerPop introduces the `ReferenceElementStrategy` which can be configured on a `GraphTraversalSource` to always
detach to ""reference"".

[source,text]
----
gremlin> graph = TinkerFactory.createModern()
==>tinkergraph[vertices:6 edges:6]
gremlin> g = graph.traversal().withStrategies(ReferenceElementStrategy.instance())
==>graphtraversalsource[tinkergraph[vertices:6 edges:6], standard]
gremlin> v = g.V().has('person','name','marko').next()
==>v[1]
gremlin> v.class
==>class org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceVertex
gremlin> v.properties()
gremlin>
----

The packaged initialization scripts that come with Gremlin Server now pre-configure the sample graphs with this
strategy to ensure that both scripts and bytecode based requests over any protocol (HTTP, websocket, etc) and
serialization format all return a ""reference"". To revert to the old form, simply remove the strategy in the
initialization script.

It is recommended that users choose to configure their `GraphTraversalSource` instances with `ReferenceElementStrategy`
as working with ""references"" only is the recommended method for developing applications with TinkerPop. In the future,
it is possible that `ReferenceElementStrategy` will be configured by default for all graphs on or off Gremlin Server,
so it would be best to start utilizing it now and grooming existing Gremlin and related application code to account
for it.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2075[TINKERPOP-2075]

==== Text Predicates

Gremlin now supports simple text predicates on top of the existing `P` predicates. Both, the new `TextP` text
predicates and the old `P` predicates, can be chained using `and()` and `or()`.

[source,groovy]
----
gremlin> g.V().has(""person"",""name"", containing(""o"")).valueMap()
==>[name:[marko],age:[29]]
==>[name:[josh],age:[32]]
gremlin> g.V().has(""person"",""name"", containing(""o"").and(gte(""j"").and(endingWith(""ko"")))).valueMap()
==>[name:[marko],age:[29]]
----

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2041[TINKERPOP-2041]

==== Changed Infix Behavior

The infix notation of `and()` and `or()` now supports an arbitrary number of traversals and `ConnectiveStrategy`
produces a traversal with proper AND and OR semantics.

```
Input: a.or.b.and.c.or.d.and.e.or.f.and.g.and.h.or.i

*BEFORE*
Output: or(a, or(and(b, c), or(and(d, e), or(and(and(f, g), h), i))))

*NOW*
Output: or(a, and(b, c), and(d, e), and(f, g, h), i)
```

Furthermore, previous versions failed to apply 3 or more `and()` steps using the infix notation, this is now fixed.

[source,groovy]
----
gremlin> g.V().has(""name"",""marko"").and().has(""age"", lt(30)).or().has(""name"",""josh"").and().has(""age"", gt(30)).and().out(""created"")
==>v[1]
==>v[4]
----

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2029[TINKERPOP-2029]

==== GraphBinary

GraphBinary is a new language agnostic, network serialization format designed to replace Gryo and GraphSON. At this
time it is only available on the JVM, but support will be added for other languages in upcoming releases. The
serializer has been configured in Gremlin Server's packaged configuration files. The serializer can be configured
using the Java driver as follows:

[source,java]
----
Cluster cluster = Cluster.build(""localhost"").port(8182).
                          serializer(Serializers.GRAPHBINARY_V1D0).create();
Client client = cluster.connect();
List<Result> r = client.submit(""g.V().has('person','name','marko')"").all().join();
----

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1942[TINKERPOP-1942],
link:http://tinkerpop.apache.org/docs/3.4.0/dev/io/#graphbinary[IO Documentation]

==== Status Attributes

The Gremlin Server protocol allows for status attributes to be returned in responses. These attributes were typically
for internal use, but were designed with extensibility in mind so that providers could place return their own
attributes to calling clients. Unfortunately, unless the client was being used with protocol level requests (which
wasn't convenient) those attributes were essentially hidden from view. As of this version however, status attributes
are fully retrievable for both successful requests and exceptions.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1913[TINKERPOP-1913]

==== with() Step

This version of TinkerPop introduces the `with()`-step to Gremlin. It isn't really a step but is instead a step
modulator. This modulator allows the step it is modifying to accept configurations that can be used to alter the
behavior of the step itself. A good example of its usage is shown with the revised syntax of the `pageRank()`-step
which now uses `with()` to replace the old `by()` options:

[source,groovy]
----
g.V().hasLabel('person').
  pageRank().
    with(PageRank.edges, __.outE('knows')).
    with(PageRank.propertyName, 'friendRank').
  order().
    by('friendRank',desc).
  valueMap('name','friendRank')
----

A similar change was made for `peerPressure()`-step:

[source,groovy]
----
g.V().hasLabel('person').
  peerPressure().
    with(PeerPressure.propertyName, 'cluster').
  group().
    by('cluster').
    by('name')
----

Note that the `by()` modulators still work, but should be considered deprecated and open for removal in a future
release where breaking changes are allowed.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1975[TINKERPOP-1975],
link:http://tinkerpop.apache.org/docs/3.4.0/reference/#with-step[Reference Documentation]

==== shortestPath() Step

Calculating the link:https://en.wikipedia.org/wiki/Shortest_path_problem[shortest path] between vertices is a common
graph use case. While the traversal to determine a shortest path can be expressed in Gremlin, this particular problem
is common enough that the feature has been encapsulated into its own step, demonstrated as follows:

[source,text]
----
gremlin> g.withComputer().V().has('name','marko').
......1>   shortestPath().with(ShortestPath.target, has('name','peter'))
==>[v[1],v[3],v[6]]
----

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1990[TINKERPOP-1990],
link:http://tinkerpop.apache.org/docs/3.4.0/reference/#shortestpath-step[Reference Documentation]

==== connectedComponent() Step

In prior version of TinkerPop, it was recommended that the identification of
link:https://en.wikipedia.org/wiki/Connected_component_(graph_theory)[Connected Component] instances in a graph be
computed by way of a reasonably complex bit of Gremlin that looked something like this:

[source,groovy]
----
g.V().emit(cyclicPath().or().not(both())).repeat(both()).until(cyclicPath()).
  path().aggregate(""p"").
  unfold().dedup().
  map(__.as(""v"").select(""p"").unfold().
         filter(unfold().where(eq(""v""))).
         unfold().dedup().order().by(id).fold()).
  dedup()
----

The above approach had a number of drawbacks that included a large execution cost as well as incompatibilities in OLAP.
To simplify usage of this commonly use graph algorithm, TinkerPop 3.4.0 introduces the `connectedComponent()` step
which reduces the above operation to:

[source,groovy]
----
g.withComputer().V().connectedComponent()
----

It is important to note that this step does require the use of a `GraphComputer` to work, as it utilizes a
`VertexProgram` behind the scenes.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1967[TINKERPOP-1967],
link:http://tinkerpop.apache.org/docs/x.y.z/reference/#connectedcomponent-step[Reference Documentation]

==== io() Step

There have been some important changes to IO operations for reading and writing graph data. The use of `Graph.io()`
has been deprecated to further remove dependence on the Graph (Structure) API for users and to extend these basic
operations to GLV users by making these features available as part of the Gremlin language.

It is now possible to simply use Gremlin:

[source,groovy]
----
graph = ...
g = graph.traversal()
g.io(someInputFile).read().iterate()
g.io(someOutputFile).write().iterate()
----

While `io()`-step is still single-threaded for OLTP style loading, it can be utilized in conjunction with OLAP which
internally uses `CloneVertexProgram` and therefore any graph `InputFormat` or `OutputFormat` can be configured in
conjunction with this step for parallel loads of large datasets.

It is also worth noting that the `io()`-step may be overridden by graph providers to utilize their native bulk-loading
features, so consult the documentation of the implementation being used to determine if there are any improved
efficiencies there.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1996[TINKERPOP-1996],
link:http://tinkerpop.apache.org/docs/3.4.0/reference/#io-step[Reference Documentation]

==== Per Request Options

The Java driver now allows for various options to be set on a per-request basis via new overloads to `submit()` that
accept `RequestOption` instances. A good use-case for this feature is to set a per-request override to the
`scriptEvaluationTimeout` so that it only applies to the current request.

[source,java]
----
Cluster cluster = Cluster.open();
Client client = cluster.connect();
RequestOptions options = RequestOptions.build().timeout(500).create();
List<Result> result = client.submit(""g.V()"", options).all().get();
----

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1342[TINKERPOP-1342]

==== min() max() and Comparable

Previously `min()` and `max()` were only working for numeric values. This has been changed and these steps can now
operate over any `Comparable` value. The common workaround was the combination of `order().by()` and `limit()` as
shown here:

[source,groovy]
----
gremlin> g.V().values('name').order().by().limit(1)      // workaround for min()
==>josh
gremlin> g.V().values('name').order().by(decr).limit(1)  // workaround for max()
==>vadas
----

Any attempt to use `min()` or `max()` on non-numeric values lead to an exception:

[source,groovy]
----
gremlin> g.V().values('name').min()
java.lang.String cannot be cast to java.lang.Number
Type ':help' or ':h' for help.
Display stack trace? [yN]
----

With the changes in this release these kind of queries became a lot easier:

[source,groovy]
----
gremlin> g.V().values('name').min()
==>josh
gremlin> g.V().values('name').max()
==>vadas
----

==== Nested Loop Support

Traversals now support nesting of `repeat()` loops.

These can now be used to repeat another traversal while in a looped context, either inside the body of a `repeat()` or
in its step modifiers (`until()` or `emit()`).

[source,groovy]
----
gremlin> g.V().repeat(__.in('traverses').repeat(__.in('develops')).emit()).emit().values('name')
==>stephen
==>matthias
==>marko
----

See: link:https://issues.apache.org/jira/browse/TINKERPOP-967[TINKERPOP-967]

==== EventStrategy API

There were some minor modifications to how `EventStrategy` is constructed and what can be expected from events raised
from the addition of new properties.

With respect to the change in terms of `EventStrategy` construction, the `detach()` builder method formerly took a
`Class` as an argument and that `Class` was meant to be one of the various ""detachment factories"" or `null`. That
approach was a bit confusing, so that signature has changed to `detach(EventStrategy.Detachment)` where the argument
is a more handy enum of detachment options.

As for the changes related to events themselves, it is first worth noting that the previously deprecated
`vertexPropertyChanged(Vertex, Property, Object, Object...)` on `MutationListener` has been removed for what should
have originally been the correct signature of `vertexPropertyChanged(Vertex, VertexProperty, Object, Object...)`. In
prior versions when this method and its related `edgePropertyChanged()` and `vertexPropertyPropertyChanged()` were
triggered by way of the addition of a new property a ""fake"" property was included with a `null` value for the
""oldValue"" argument to these methods (as it did not exist prior to this event). That was a bit awkward to reason about
when dealing with that event. To make this easier, the event now raises with a `KeyedVertexProperty` or
`KeyedProperty` instance, which only contains a property key and no value in them.

link:https://issues.apache.org/jira/browse/TINKERPOP-1831[TINKERPOP-1831]

==== Reducing Barrier Steps

The behavior of `min()`, `max()`, `mean()` and `sum()` has been modified to return no result if there's no input.
Previously these steps yielded the internal seed value:

[source,groovy]
----
gremlin> g.V().values('foo').min()
==>NaN
gremlin> g.V().values('foo').max()
==>NaN
gremlin> g.V().values('foo').mean()
==>NaN
gremlin> g.V().values('foo').sum()
==>0
----

These traversals will no longer emit a result. Note, that this also affects more complex scenarios, e.g. if these
steps are used in `by()` modulators:

[source,groovy]
----
gremlin> g.V().group().
......1>   by(label).
......2>   by(outE().values(""weight"").sum())
==>[software:0,person:3.5]
----

Since software vertices have no outgoing edges and thus no weight values to sum, `software` will no longer show up in
the result. In order to get the same result as before, one would have to add a `coalesce()`-step:

[source,groovy]
----
gremlin> g.V().group().
......1>   by(label).
......2>   by(outE().values(""weight"").sum())
==>[person:3.5]
gremlin> g.V().group().
......1>   by(label).
......2>   by(coalesce(outE().values(""weight""), constant(0)).sum())
==>[software:0,person:3.5]
----

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1777[TINKERPOP-1777]

==== Order of select() Scopes

The order of select scopes has been changed to: maps, side-effects, paths. Previously the order was: side-effects,
maps, paths - which made it almost impossible to select a specific map entry if a side-effect with the same name
existed.

The following snippets illustrate the changed behavior:

[source,groovy]
----
gremlin> g.V(1).
......1>   group(""a"").
......2>     by(__.constant(""a"")).
......3>     by(__.values(""name"")).
......4>   select(""a"")
==>[a:marko]
gremlin> g.V(1).
......1>   group(""a"").
......2>     by(__.constant(""a"")).
......3>     by(__.values(""name"")).
......4>   select(""a"").select(""a"")
==>[a:marko]
----

Above is the old behavior; the second `select(""a"")` has no effect, it selects the side-effect `a` again, although one
would expect to get the map entry `a`. What follows is the new behavior:

[source,groovy]
----
gremlin> g.V(1).
......1>   group(""a"").
......2>     by(__.constant(""a"")).
......3>     by(__.values(""name"")).
......4>   select(""a"")
==>[a:marko]
gremlin> g.V(1).
......1>   group(""a"").
......2>     by(__.constant(""a"")).
......3>     by(__.values(""name"")).
......4>   select(""a"").select(""a"")
==>marko
----

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1522[TINKERPOP-1522]

==== GraphSON BulkSet

In earlier versions of TinkerPop, `BulkSet` was coerced to a `List` for GraphSON which was convenient in that it
didn't add a new data type to support, but inconvenient in that it meant that certain process tests were not consistent
in terms of how they ran and the benefits of the `BulkSet` were ""lost"" in that the ""bulk"" was being resolved server
side. With the addition of `BulkSet` as a GraphSON type the ""bulk"" is now resolved on the client side by the language
variant. How that resolution occurs depends upon the language variant. For Java, there is a `BulkSet` object which
maintains that structure sent from the server. For the other variants, the `BulkSet` is deserialized to a `List` form
which results in a much larger memory footprint than what is contained the `BulkSet`.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2111[TINKERPOP-2111]

==== Python Bindings

Bindings were formerly created using a Python 2-tuple as a bit of syntactic sugar, but all other language variants
used an explicit `Bindings` object which `gremlin-python` already had in place. To make all work variants behave
consistently, the 2-tuple syntax has been removed in favor of the explicit `Bindings.of()` option.

[source,python]
----
g.V(Bindings.of('id',1)).out('created').map(lambda: (""it.get().value('name').length()"", ""gremlin-groovy"")).sum()
----

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2116[TINKERPOP-2116]

==== Deprecation and Removal

This section describes newly deprecated classes, methods, components and patterns of usage as well as which previously
deprecated features have been officially removed or repurposed.

===== Moving of RemoteGraph

`RemoteGraph` was long ago deprecated in favor of `withRemote()`. It became even less useful with the introduction of
the `AnonymousTraversalSource` concept in 3.3.5. It's only real use was for testing remote bytecode based traversals
in the test suite as the test suite requires an actual `Graph` object to function properly. As such, `RemoteGraph` has
been moved to `gremlin-test`. It should no longer be used in any capacity besides that.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2079[TINKERPOP-2079]

===== Removal of Giraph Support

Support for Giraph has been removed as of this version. There were a number of reasons for this decision which were
discussed in the community prior to taking this step. Users should switch to Spark for their OLAP based graph-computing
needs.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1930[TINKERPOP-1930]

===== Removal of Rebindings Options

The ""rebindings"" option is no longer supported for clients. It was deprecated long ago at 3.1.0. The server will not
respond to them on any channel - websockets, nio or HTTP. Use the ""aliases"" option instead.

link:https://issues.apache.org/jira/browse/TINKERPOP-1705[TINKERPOP-1705]

===== gremlin-server.sh -i Removal

The `-i` option for installing dependencies in Gremlin Server was long ago deprecated and has now been removed. Please
use `install` as its replacement going forward.

link:https://issues.apache.org/jira/browse/TINKERPOP-2031[TINKERPOP-2031]

===== Deprecation Removal

The following deprecated classes, methods or fields have been removed in this version:

* `gremlin-core`
** `org.apache.tinkerpop.gremlin.jsr223.ImportCustomizer#GREMLIN_CORE`
** `org.apache.tinkerpop.gremlin.process.remote.RemoteGraph` - moved to `gremlin-test`
** `org.apache.tinkerpop.gremlin.process.remote.RemoteConnection.submit(Traversal)`
** `org.apache.tinkerpop.gremlin.process.remote.RemoteConnection.submit(Bytecode)`
** `org.apache.tinkerpop.gremlin.process.remote.traversal.strategy.decoration.RemoteStrategy#identity()`
** `org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine`
** `org.apache.tinkerpop.gremlin.process.traversal.engine.*`
** `org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.PartitionStrategy.Builder#addReadPartition(String)`
** `org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SubgraphStrategy.Builder#edgeCriterion(Traversal)`
** `org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SubgraphStrategy.Builder#vertexCriterion(Traversal)`
** `org.apache.tinkerpop.gremlin.process.traversal.step.map.LambdaCollectingBarrierStep.Consumers`
** `org.apache.tinkerpop.gremlin.process.traversal.step.util.HasContainer#makeHasContainers(String, P)`
** `org.apache.tinkerpop.gremlin.process.traversal.step.util.event.MutationListener#vertexPropertyChanged(Vertex, Property, Object, Object...)`
** `org.apache.tinkerpop.gremlin.structure.Element.Exceptions#elementAlreadyRemoved(Class, Object)`
** `org.apache.tinkerpop.gremlin.structure.Graph.Exceptions#elementNotFound(Class, Object)`
** `org.apache.tinkerpop.gremlin.structure.Graph.Exceptions#elementNotFound(Class, Object, Exception)`
* `gremlin-driver`
** `org.apache.tinkerpop.gremlin.driver.Client#rebind(String)`
** `org.apache.tinkerpop.gremlin.driver.Client.ReboundClusterdClient`
** `org.apache.tinkerpop.gremlin.driver.Tokens#ARGS_REBINDINGS`
* `gremlin-groovy`
** `org.apache.tinkerpop.gremlin.groovy.jsr223.GremlinGroovyScriptEngine.close()` - no longer implements `AutoCloseable`
* `gremlin-server`
** `org.apache.tinkerpop.gremlin.server.GraphManager#getGraphs()`
** `org.apache.tinkerpop.gremlin.server.GraphManager#getTraversalSources()`
** `org.apache.tinkerpop.gremlin.server.Settings#serializedResponseTimeout`
** `org.apache.tinkerpop.gremlin.server.Settings.AuthenticationSettings#className`
** `org.apache.tinkerpop.gremlin.server.handler.OpSelectorHandler(Settings, GraphManager, GremlinExecutor, ScheduledExecutorService)`
** `org.apache.tinkerpop.gremlin.server.op.AbstractOpProcessor#makeFrame(ChannelHandlerContext, RequestMessage, MessageSerializer serializer, boolean, List, ResponseStatusCode code)`
* `hadoop-graph`
** `org.apache.tinkerpop.gremlin.hadoop.structure.HadoopConfiguration#getGraphInputFormat()`
** `org.apache.tinkerpop.gremlin.hadoop.structure.HadoopConfiguration#getGraphOutputFormat()`

Please see the javadoc deprecation notes or upgrade documentation specific to when the deprecation took place to
understand how to resolve this breaking change.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1143[TINKERPOP-1143],
link:https://issues.apache.org/jira/browse/TINKERPOP-1296[TINKERPOP-1296],
link:https://issues.apache.org/jira/browse/TINKERPOP-1705[TINKERPOP-1705],
link:https://issues.apache.org/jira/browse/TINKERPOP-1707[TINKERPOP-1707],
link:https://issues.apache.org/jira/browse/TINKERPOP-1954[TINKERPOP-1954],
link:https://issues.apache.org/jira/browse/TINKERPOP-1986[TINKERPOP-1986],
link:https://issues.apache.org/jira/browse/TINKERPOP-2079[TINKERPOP-2079],
link:https://issues.apache.org/jira/browse/TINKERPOP-2103[TINKERPOP-2103]

===== Deprecated GraphSONMessageSerializerGremlinV2d0

The `GraphSONMessageSerializerGremlinV2d0` serializer is now analogous to `GraphSONMessageSerializerV2d0` and therefore
redundant. It has technically always been equivalent in terms of functionality as both serialized to the same format
(i.e. GraphSON 2.0 with embedded types). It is no longer clear why these two classes were established this way, but
it does carry the negative effect where multiple serializer versions could not be bound to Gremlin Server's HTTP
endpoint as the MIME types conflicted on `application/json`. By simply making both message serializers support
`application/json` and `application/vnd.gremlin-v2.0+json`, it then became possible to overcome that limitation. In
short, prefer use of `GraphSONMessageSerializerV2d0` when possible.

Note that this is a breaking change in the sense that `GraphSONMessageSerializerV2d0` will no longer set the header of
requests messages to `application/json`. As a result, older versions of Gremlin Server not configured with
`GraphSONMessageSerializerGremlinV2d0` will not find a deserializer to match the request.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1984[TINKERPOP-1984]

===== Removed groovy-sql Dependency

Gremlin Console and Gremlin Server no longer include groovy-sql.  If you depend on groovy-sql,
you can install it in Gremlin Console or Gremlin Server using the plugin system.

Console:
```
:install org.codehaus.groovy groovy-sql 2.5.2
```

Server:
```
bin/gremlin-server.sh install org.codehaus.groovy groovy-sql 2.5.2
```

If your project depended on groovy-sql transitively, simply include it in your project's build file (e.g. maven: pom.xml).

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2037[TINKERPOP-2037]

=== Upgrading for Providers

==== Graph Database Providers

===== io() Step

The new `io()`-step that was introduced provides some new changes to consider. Note that `Graph.io()` has been
deprecated and users are no longer instructed to utilize that method. It is not yet decided when that method will be
removed completely, but given the public nature of it and the high chance of common usage, it should be hanging around
for some time.

As with any step in Gremlin, it is possible to replace it with a more provider specific implementation that could be
more efficient. Developing a `TraversalStrategy` to do this is encouraged, especially for those graph providers who
might have special bulk loaders that could be abstracted by this step. Examples of this are already shown with
`HadoopGraph` which replaces the simple single-threaded loader with `CloneVertexProgram`. Graph providers are
encouraged to use the `with()` step to capture any necessary configurations required for their underlying loader to
work. Graph providers should not feel restricted to `graphson`, `gryo` and `graphml` formats either. If a graph
supports CSV or some custom graph specific format, it shouldn't be difficult to gather the configurations necessary to
make that available to users.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1996[TINKERPOP-1996]

===== Caching Graph Features

For graph implementations that have expensive creation times, it can be time consuming to run the TinkerPop test suite
as each test run requires a `Graph` instance even if the test is ultimately ignored becaue it doesn't pass the feature
checks. To possibly help alleviate this problem, the `GraphProvider` interface now includes this method:

[source,java]
----
public default Optional<Graph.Features> getStaticFeatures() {
    return Optional.empty();
}
----

This method can be implemented to return a cacheable set of features for a `Graph` generated from that `GraphProvider`.
Assuming this method is faster than the cost of creating a new `Graph` instance, the test suite should execute
significantly faster depending on how many tests end up being ignored.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1518[TINKERPOP-1518]

===== Configuring Interface

There were some changes to interfaces that were related to `Step`. A new `Configuring` interface was added that was
helpful in the implementation of the `with()`-step modulator. This new interface extends the `Parameterizing` interface
(which moved to the `org.apache.tinkerpop.gremlin.process.traversal.step` package with the other step interfaces) and
in turn is extended by the `Mutating` interface. Making this change meant that the `Mutating.addPropertyMutations()`
method could be removed in favor of the new `Configuring.configure()` method.

All of the changes above basically mean, that if the `Mutating` interface was being used in prior versions, the
`addPropertyMutations()` method simply needs to be changed to `configure()`.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1975[TINKERPOP-1975]

===== OptionsStrategy

`OptionsStrategy` is a `TraversalStrategy` that makes it possible for users to set arbitrary configurations on a
`Traversal`. These configurations can be used by graph providers to allow for traversal-level configurations to be
accessible to their custom steps. A user would write something like:

[source,java]
----
g.withStrategies(OptionsStrategy.build().with(""specialLimit"", 10000).create()).V();
----

The `OptionsStrategy` is really only the carrier for the configurations and while users can choose to utilize that
more verbose method for constructing it shown above, it is more elegantly constructed as follows using `with()`-step:

[source,java]
----
g.with(""specialLimit"", 10000)).V();
----

The graph provider could then access that value of ""specialLimit"" in their custom step (or elsewhere) as follows:

[source,java]
----
OptionsStrategy strategy = this.getTraversal().asAdmin().getStrategies().getStrategy(OptionsStrategy.class).get();
int specialLimit = (int) strategy.getOptions().get(""specialLimit"");
----

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2053[TINKERPOP-2053]

===== Removed hadoop-gremlin Test Artifact

The `hadoop-gremlin` module no longer generates a test jar that can be used as a test dependency in other modules.
Generally speaking, that approach tends to be a bad practice and can cause build problems with Maven that aren't always
obvious to troubleshoot. With the removal of `giraph-gremlin` for 3.4.0, it seemed even less useful to have this
test artifact present. All tests are still present. The follow provides a basic summary of how this refactoring
occurred:

* A new `AbstractFileGraphProvider` was created in `gremlin-test` which provided a lot of the features that
`HadoopGraphProvider` was exposing. Both `HadoopGraphProvider` and `SparkHadoopGraphProvider` extend from that class
now.
* `ToyIoRegistry` and related classes were moved to `gremlin-test`.
* The various tests that validated capabilities of `Storage` have been moved to `spark-gremlin` and are part of those
tests now. Obviously, that makes those tests specific to Spark testing now. If that location creates a problem for some
reason, that decision can be revisited at some point.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1410[TINKERPOP-1410]

===== TraversalEngine Moved

The `TraversalEngine` interface was deprecated in 3.2.0 along with all related methods that used it and classes that
implemented it. It was replaced by the `Computer` interface and provided a much nicer way to plug different
implementations of `Computer` into a traversal. `TraversalEngine` was never wholly removed however as it had some deep
dependencies in the inner workings of the test suite. That infrastructure has largely remained as is until now.

As of 3.4.0, `TraversalEngine` is no longer in `gremlin-core` and can instead be found in `gremlin-test` as it is
effectively a ""test-only"" component and serves no other real function. As explained in the javadocs going back to
3.2.0, providers should implement the `Computer` class and use that instead. At this point, graph providers should have
long ago moved to the `Computer` infrastructure as methods for constructing a `TraversalSource` with a
`TraversalEngine` were long ago removed.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1143[TINKERPOP-1143]

===== Upsert Graph Feature

Some `Graph` implementations may be able to offer upsert functionality for vertices and edges, which can help improve
usability and performance. To help make it clear to users that a graph operates in this fashion, the `supportsUpsert()`
feature has been added to both `Graph.VertexFeatures` and `Graph.EdgeFeatures`. By default, both of these methods will
return `false`.

Should a provider wish to support this feature, the behavior of `addV()` and/or `addE()` should change such that when
a vertex or edge with the same identifier is provided, the respective step will insert the new element if that value
is not present or update an existing element if it is found. The method by which the provider ""identifies"" an element
is completely up to the capabilities of that provider. In the most simple fashion, a graph could simply check the
value of the supplied `T.id`, however graphs that support some form of schema will likely have other methods for
determining whether or not an existing element is present.

The extent to which TinkerPop tests ""upsert"" is fairly narrow. Graph providers that choose to support this feature
should consider their own test suites carefully to ensure appropriate coverage.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-1685[TINKERPOP-1685]

===== TypeTranslator Changes

The `TypeTranslator` experienced a change in its API and `GroovyTranslator` a change in expectations.

`TypeTranslator` now implements `BiFunction` and takes the graph traversal source name as an argument along with the
object to translate. This interface is implemented by default for Groovy with `GroovyTranslator.DefaultTypeTranslator`
which encapsulates all the functionality of what `GroovyTranslator` formerly did by default. To provide customize
translation, simply extend the `DefaultTypeTranslator` and override the methods.

`GroovyTranslator` now expects that the `TypeTranslator` provide to it as part of its `of()` static method overload
is ""complete"" - i.e. that it provides all the functionality to translate the types passed to it. Thus, a ""complete""
`TypeTranslator` is one that does everything that `DefaultTypeTranslator` does as a minimum requirement. Therefore,
the extension model described above is the easiest way to get going with a custom `TypeTranslator` approach.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2072[TINKERPOP-2072]

==== Graph Driver Providers

===== Deprecation Removal in RemoteConnection

The two deprecated synchronous `submit()` methods on the `RemoteConnection` interface have been removed, which means
that `RemoteConnection` implementations will need to implement `submitAsync(Bytecode)` if they have not already done
so.

See: link:https://issues.apache.org/jira/browse/TINKERPOP-2103[TINKERPOP-2103]
",12090,False,2270.8209894337288,median
"// Copyright (C) 2006 The Trustees of Indiana University.

// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

//  Authors: Douglas Gregor
//           Jeremiah Willcock
//           Andrew Lumsdaine

// Distributed compressed sparse row graph type

#ifndef BOOST_GRAPH_DISTRIBUTED_CSR_HPP
#define BOOST_GRAPH_DISTRIBUTED_CSR_HPP

#ifndef BOOST_GRAPH_USE_MPI
#error ""Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included""
#endif

#include <boost/assert.hpp>
#include <boost/graph/compressed_sparse_row_graph.hpp>
#include <boost/graph/distributed/selector.hpp>
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/graph/distributed/concepts.hpp>
#include <boost/graph/parallel/properties.hpp>
#include <boost/graph/parallel/distribution.hpp>
#include <boost/property_map/parallel/local_property_map.hpp>
#include <boost/property_map/parallel/distributed_property_map.hpp>

namespace boost {

// Distributed and sequential inplace ctors have the same signature so
// we need a separate tag for distributed inplace ctors
enum distributed_construct_inplace_from_sources_and_targets_t 
  {distributed_construct_inplace_from_sources_and_targets};

// The number of bits we reserve for the processor ID. 
// DPG TBD: This is a hack. It will eventually be a run-time quantity.
static const int processor_bits = 8;

// Tag class for a distributed CSR graph
struct distributed_csr_tag
  : public virtual distributed_graph_tag,
    public virtual distributed_vertex_list_graph_tag,
    public virtual distributed_edge_list_graph_tag,
    public virtual incidence_graph_tag,
    public virtual adjacency_graph_tag {};

template<typename VertexProperty, typename EdgeProperty,
         typename GraphProperty, typename ProcessGroup, typename InVertex,
         typename InDistribution, typename InEdgeIndex>
class compressed_sparse_row_graph<
         directedS, VertexProperty, EdgeProperty, GraphProperty,
         distributedS<ProcessGroup, InVertex, InDistribution>,
         InEdgeIndex>
{
  typedef compressed_sparse_row_graph self_type;

 private:
  /**
   *  Determine the type used to represent vertices in the graph. If
   *  the user has overridden the default, use the user's
   *  parameter. Otherwise, fall back to std::size_t.
   */
  typedef typename mpl::if_<is_same<InVertex, defaultS>,
                            std::size_t,
                            InVertex>::type Vertex;

  /**
   *  Determine the type used to represent edges in the graph. If
   *  the user has overridden the default (which is to be the same as
   *  the distributed vertex selector type), use the user's
   *  parameter. Otherwise, fall back to the value of @c Vertex.
   */
  typedef typename mpl::if_<is_same<InEdgeIndex,
                                    distributedS<ProcessGroup, InVertex,
                                                 InDistribution> >,
                            Vertex,
                            InEdgeIndex>::type EdgeIndex;

 public:
  /**
   * The type of the CSR graph that will be stored locally.
   */
  typedef compressed_sparse_row_graph<directedS, VertexProperty, EdgeProperty,
                                      GraphProperty, Vertex, EdgeIndex>
    base_type;

  // -----------------------------------------------------------------
  // Graph concept requirements
  typedef Vertex vertex_descriptor;
  typedef typename graph_traits<base_type>::edge_descriptor edge_descriptor;
  typedef directed_tag directed_category;
  typedef allow_parallel_edge_tag edge_parallel_category;
  typedef distributed_csr_tag traversal_category;
  static vertex_descriptor null_vertex();

  // -----------------------------------------------------------------
  // Distributed Vertex List Graph concept requirements
  typedef Vertex vertices_size_type;
  class vertex_iterator;

  // -----------------------------------------------------------------
  // Distributed Edge List Graph concept requirements
  typedef EdgeIndex edges_size_type;
  class edge_iterator;

  // -----------------------------------------------------------------
  // Incidence Graph concept requirements
  typedef typename graph_traits<base_type>::out_edge_iterator
    out_edge_iterator;
  typedef typename graph_traits<base_type>::degree_size_type
    degree_size_type;

  // -----------------------------------------------------------------
  // Adjacency Graph concept requirements
  typedef typename graph_traits<base_type>::adjacency_iterator
    adjacency_iterator;

  // Note: This graph type does not model Bidirectional Graph.
  // However, this typedef is required to satisfy graph_traits.
  typedef void in_edge_iterator;

  // -----------------------------------------------------------------
  // Distributed Container concept requirements
  typedef ProcessGroup process_group_type;
  typedef boost::parallel::variant_distribution<process_group_type, Vertex>
    distribution_type;

  // -----------------------------------------------------------------
  // Workarounds
  // NOTE: This graph type does not have old-style graph properties. It only
  // accepts bundles.
  typedef no_property vertex_property_type;
  typedef no_property edge_property_type;
  typedef no_property graph_property_type;
  typedef typename mpl::if_<is_void<VertexProperty>,
                            void****,
                            VertexProperty>::type vertex_bundled;
  typedef typename mpl::if_<is_void<EdgeProperty>,
                            void****,
                            EdgeProperty>::type edge_bundled;
  typedef typename mpl::if_<is_void<GraphProperty>,
                            void****,
                            GraphProperty>::type graph_bundled;

  // -----------------------------------------------------------------
  // Useful types
  typedef typename ProcessGroup::process_id_type process_id_type;

  // -----------------------------------------------------------------
  // Graph constructors
  compressed_sparse_row_graph(const ProcessGroup& pg = ProcessGroup())
    : m_process_group(pg), m_distribution(parallel::block(pg, 0)) {}

  compressed_sparse_row_graph(const GraphProperty& prop,
                              const ProcessGroup& pg = ProcessGroup())
    : m_process_group(pg), m_distribution(parallel::block(pg, 0)) {}

  compressed_sparse_row_graph(vertices_size_type numverts,
                              const ProcessGroup& pg = ProcessGroup())
    : m_process_group(pg), m_distribution(parallel::block(pg, 0)),
      m_base(numverts) 
  {}

  compressed_sparse_row_graph(vertices_size_type numverts,
                              const GraphProperty& prop,
                              const ProcessGroup& pg = ProcessGroup())
    : m_process_group(pg), m_distribution(parallel::block(pg, 0)),
      m_base(numverts) 
  {}

  template <typename Distribution>
  compressed_sparse_row_graph(vertices_size_type numverts,
                              const ProcessGroup& pg,
                              const Distribution& dist)
    : m_process_group(pg), m_distribution(dist), m_base(numverts) {}

  template <typename Distribution>
  compressed_sparse_row_graph(vertices_size_type numverts,
                              const GraphProperty& prop,
                              const ProcessGroup& pg,
                              const Distribution& dist)
    : m_process_group(pg), m_distribution(dist), m_base(numverts) {}

  template <typename InputIterator>
  compressed_sparse_row_graph(edges_are_unsorted_t,
                              InputIterator edge_begin, InputIterator edge_end,
                              vertices_size_type numverts,
                              const ProcessGroup& pg = ProcessGroup(),
                              const GraphProperty& prop = GraphProperty());

  template <typename InputIterator, typename Distribution>
  compressed_sparse_row_graph(edges_are_unsorted_t,
                              InputIterator edge_begin, InputIterator edge_end,
                              vertices_size_type numverts,
                              const ProcessGroup& pg,
                              const Distribution& dist,
                              const GraphProperty& prop = GraphProperty());

  template <typename InputIterator, typename EdgePropertyIterator>
  compressed_sparse_row_graph(edges_are_unsorted_t,
                              InputIterator edge_begin, InputIterator edge_end,
                              EdgePropertyIterator ep_iter,
                              vertices_size_type numverts,
                              const ProcessGroup& pg = ProcessGroup(),
                              const GraphProperty& prop = GraphProperty());

  template <typename InputIterator, typename EdgePropertyIterator,
            typename Distribution>
  compressed_sparse_row_graph(edges_are_unsorted_t,
                              InputIterator edge_begin, InputIterator edge_end,
                              EdgePropertyIterator ep_iter,
                              vertices_size_type numverts,
                              const ProcessGroup& pg,
                              const Distribution& dist,
                              const GraphProperty& prop = GraphProperty());

  template <typename InputIterator>
  compressed_sparse_row_graph(edges_are_sorted_t,
                              InputIterator edge_begin, InputIterator edge_end,
                              vertices_size_type numverts,
                              edges_size_type numedges = 0,
                              const ProcessGroup& pg = ProcessGroup(),
                              const GraphProperty& prop = GraphProperty());

  template <typename InputIterator, typename Distribution>
  compressed_sparse_row_graph(edges_are_sorted_t,
                              InputIterator edge_begin, InputIterator edge_end,
                              vertices_size_type numverts,
                              const ProcessGroup& pg,
                              const Distribution& dist,
                              const GraphProperty& prop = GraphProperty());

  template <typename InputIterator, typename EdgePropertyIterator>
  compressed_sparse_row_graph(edges_are_sorted_t,
                              InputIterator edge_begin, InputIterator edge_end,
                              EdgePropertyIterator ep_iter,
                              vertices_size_type numverts,
                              edges_size_type numedges = 0,
                              const ProcessGroup& pg = ProcessGroup(),
                              const GraphProperty& prop = GraphProperty());

  template <typename InputIterator, typename EdgePropertyIterator,
            typename Distribution>
  compressed_sparse_row_graph(edges_are_sorted_t,
                              InputIterator edge_begin, InputIterator edge_end,
                              EdgePropertyIterator ep_iter,
                              vertices_size_type numverts,
                              const ProcessGroup& pg,
                              const Distribution& dist,
                              const GraphProperty& prop = GraphProperty());

  template <typename MultiPassInputIterator>
  compressed_sparse_row_graph(edges_are_unsorted_multi_pass_t,
                              MultiPassInputIterator edge_begin, 
                              MultiPassInputIterator edge_end,
                              vertices_size_type numverts,
                              const ProcessGroup& pg = ProcessGroup(),
                              const GraphProperty& prop = GraphProperty());

  template <typename MultiPassInputIterator, typename Distribution>
  compressed_sparse_row_graph(edges_are_unsorted_multi_pass_t,
                              MultiPassInputIterator edge_begin, 
                              MultiPassInputIterator edge_end,
                              vertices_size_type numverts,
                              const ProcessGroup& pg,
                              const Distribution& dist,
                              const GraphProperty& prop = GraphProperty());

  template <typename MultiPassInputIterator, typename EdgePropertyIterator>
  compressed_sparse_row_graph(edges_are_unsorted_multi_pass_t,
                              MultiPassInputIterator edge_begin, 
                              MultiPassInputIterator edge_end,
                              EdgePropertyIterator ep_iter,
                              vertices_size_type numverts,
                              const ProcessGroup& pg = ProcessGroup(),
                              const GraphProperty& prop = GraphProperty());

  template <typename MultiPassInputIterator, typename EdgePropertyIterator,
            typename Distribution>
  compressed_sparse_row_graph(edges_are_unsorted_multi_pass_t,
                              MultiPassInputIterator edge_begin, 
                              MultiPassInputIterator edge_end,
                              EdgePropertyIterator ep_iter,
                              vertices_size_type numverts,
                              const ProcessGroup& pg,
                              const Distribution& dist,
                              const GraphProperty& prop = GraphProperty());

  template <typename Source>
  compressed_sparse_row_graph(distributed_construct_inplace_from_sources_and_targets_t,
                              std::vector<Source>& sources,
                              std::vector<vertex_descriptor>& targets,
                              vertices_size_type numverts,
                              const ProcessGroup& pg = ProcessGroup(),
                              const GraphProperty& prop = GraphProperty());

  template <typename Distribution, typename Source> 
  compressed_sparse_row_graph(distributed_construct_inplace_from_sources_and_targets_t,
                              std::vector<Source>& sources,
                              std::vector<vertex_descriptor>& targets,
                              vertices_size_type numverts,
                              const ProcessGroup& pg,
                              const Distribution& dist,
                              const GraphProperty& prop = GraphProperty());

  template <typename Source>
  compressed_sparse_row_graph(distributed_construct_inplace_from_sources_and_targets_t,
                              std::vector<Source>& sources,
                              std::vector<vertex_descriptor>& targets,
                              std::vector<edge_bundled>& edge_props,
                              vertices_size_type numverts,
                              const ProcessGroup& pg = ProcessGroup(),
                              const GraphProperty& prop = GraphProperty());

  template <typename Distribution, typename Source>
  compressed_sparse_row_graph(distributed_construct_inplace_from_sources_and_targets_t,
                              std::vector<Source>& sources,
                              std::vector<vertex_descriptor>& targets,
                              std::vector<edge_bundled>& edge_props,
                              vertices_size_type numverts,
                              const ProcessGroup& pg,
                              const Distribution& dist,
                              const GraphProperty& prop = GraphProperty());

  template<typename InputIterator>
  compressed_sparse_row_graph(InputIterator edge_begin, InputIterator edge_end,
                              vertices_size_type numverts,
                              const ProcessGroup& pg = ProcessGroup(),
                              const GraphProperty& prop = GraphProperty());

  template<typename InputIterator, typename EdgePropertyIterator>
  compressed_sparse_row_graph(InputIterator edge_begin, InputIterator edge_end,
                              EdgePropertyIterator ep_iter,
                              vertices_size_type numverts,
                              const ProcessGroup& pg = ProcessGroup(),
                              const GraphProperty& prop = GraphProperty());

  template<typename InputIterator, typename Distribution>
  compressed_sparse_row_graph(InputIterator edge_begin, InputIterator edge_end,
                              vertices_size_type numverts,
                              const ProcessGroup& pg,
                              const Distribution& dist,
                              const GraphProperty& prop = GraphProperty());

  template<typename InputIterator, typename EdgePropertyIterator, 
           typename Distribution>
  compressed_sparse_row_graph(InputIterator edge_begin, InputIterator edge_end,
                              EdgePropertyIterator ep_iter,
                              vertices_size_type numverts,
                              const ProcessGroup& pg,
                              const Distribution& dist,
                              const GraphProperty& prop = GraphProperty());

  base_type&       base()       { return m_base; }
  const base_type& base() const { return m_base; }

  process_group_type process_group() const { return m_process_group.base(); }

  distribution_type&       distribution()       { return m_distribution; }
  const distribution_type& distribution() const { return m_distribution; }

  // Directly access a vertex or edge bundle
  vertex_bundled& operator[](vertex_descriptor v)
  {
    return get(vertex_bundle, *this, v);
  }

  const vertex_bundled& operator[](vertex_descriptor v) const
  {
    return get(vertex_bundle, *this, v);
  }

  edge_bundled& operator[](edge_descriptor e)
  {
    return get(edge_bundle, *this, e);
  }

  const edge_bundled& operator[](edge_descriptor e) const
  {
    return get(edge_bundle, *this, e);
  }

  // Create a vertex descriptor from a process ID and a local index.
  vertex_descriptor 
  make_vertex_descriptor(process_id_type p, vertex_descriptor v) const
  {
    vertex_descriptor vertex_local_index_bits = 
      sizeof(vertex_descriptor) * CHAR_BIT - processor_bits;
    return v | ((vertex_descriptor)p << vertex_local_index_bits);
  }

  // Convert a local vertex descriptor into a global vertex descriptor
  vertex_descriptor local_to_global_vertex(vertex_descriptor v) const
  {
    return make_vertex_descriptor(process_id(m_process_group), v);
  }

  // Structural modification
  vertex_descriptor add_vertex()
  {
    typename graph_traits<base_type>::vertex_descriptor v 
      = boost::add_vertex(m_base);

    return make_vertex_descriptor(process_id(m_process_group), v);
  }

  vertex_descriptor add_vertex(const vertex_bundled& p)
  {
    typename graph_traits<base_type>::vertex_descriptor v 
      = boost::add_vertex(m_base, p);

    return make_vertex_descriptor(process_id(m_process_group), v);
  }

  vertex_descriptor add_vertices(vertices_size_type count)
  {
    typename graph_traits<base_type>::vertex_descriptor v 
      = boost::add_vertices(count, m_base);

    return make_vertex_descriptor(process_id(m_process_group), v);
  }

  template <typename InputIterator>
  void 
  add_edges(InputIterator first, InputIterator last)
  { boost::add_edges_global(first, last, get(vertex_local, *this), m_base); }

  template <typename InputIterator, typename EdgePropertyIterator>
  void 
  add_edges(InputIterator first, InputIterator last,
            EdgePropertyIterator ep_iter,
            EdgePropertyIterator ep_iter_end)
  { boost::add_edges_global(first, last, ep_iter, ep_iter_end, 
                            get(vertex_local, *this), m_base); }

  template <typename InputIterator>
  void 
  add_edges_sorted(InputIterator first, InputIterator last)
  { boost::add_edges_sorted_global(first, last, 
                                   get(vertex_local, *this), m_base); }

  template <typename InputIterator, typename EdgePropertyIterator>
  void 
  add_edges_sorted(InputIterator first_sorted, InputIterator last_sorted,
                   EdgePropertyIterator ep_iter_sorted)
  { boost::add_edges_sorted_global(first_sorted, last_sorted, ep_iter_sorted, 
                                   get(vertex_local, *this), m_base); }

 protected:
  ProcessGroup m_process_group;
  distribution_type m_distribution;
  base_type m_base;
};

/** @brief Helper macro containing the template parameters for the
 *   distributed CSR graph.
 *
 *  This macro contains all of the template parameters needed for the
 *  distributed compressed_sparse_row graph type. It is used to reduce
 *  the amount of typing required to declare free functions for this
 *  graph type.
 */
#define BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS                          \\
  typename VertexProperty, typename EdgeProperty,    \\
  typename GraphProperty, typename ProcessGroup, typename InVertex,     \\
  typename InDistribution, typename InEdgeIndex

/** @brief Helper macro containing the typical instantiation of the
 *   distributed CSR graph.
 *
 *  This macro contains an instantiation of the distributed CSR graph
 *  type using the typical template parameters names (e.g., those
 *  provided by the macro @c
 *  BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS). It is used to reduce
 *  the amount of typing required to declare free functions for this
 *  graph type.
 */
#define BOOST_DISTRIB_CSR_GRAPH_TYPE                            \\
  compressed_sparse_row_graph<                                  \\
    directedS, VertexProperty, EdgeProperty, GraphProperty,      \\
    distributedS<ProcessGroup, InVertex, InDistribution>,       \\
    InEdgeIndex>

// -----------------------------------------------------------------
// Graph concept operations
template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor
BOOST_DISTRIB_CSR_GRAPH_TYPE::null_vertex()
{
  return graph_traits<base_type>::null_vertex();
}

// -----------------------------------------------------------------
// Incidence Graph concept operations
template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor
source(typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edge_descriptor e,
       const BOOST_DISTRIB_CSR_GRAPH_TYPE&)
{ return e.src; }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor
target(typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edge_descriptor e,
       const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{ return target(e, g.base()); }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline std::pair<typename BOOST_DISTRIB_CSR_GRAPH_TYPE::out_edge_iterator,
                 typename BOOST_DISTRIB_CSR_GRAPH_TYPE::out_edge_iterator>
out_edges(typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor u,
          const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edges_size_type
    edges_size_type;
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edge_descriptor ed;
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::out_edge_iterator it;
  edges_size_type u_local = get(vertex_local, g, u);
  edges_size_type u_row_start = g.base().m_forward.m_rowstart[u_local];
  edges_size_type next_row_start = g.base().m_forward.m_rowstart[u_local + 1];
  return std::make_pair(it(ed(u, u_row_start)),
                        it(ed(u, (std::max)(u_row_start, next_row_start))));
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename BOOST_DISTRIB_CSR_GRAPH_TYPE::degree_size_type
out_degree(typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor u,
           const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  return out_degree(get(vertex_local, g, u), g.base());
}

// -----------------------------------------------------------------
// DistributedGraph concept requirements
template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
void synchronize(const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef BOOST_DISTRIB_CSR_GRAPH_TYPE graph_type;
  synchronize(g.process_group());
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS> 
ProcessGroup
process_group(const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{ return g.process_group(); }


// -----------------------------------------------------------------
// Adjacency Graph concept requirements
template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline std::pair<typename BOOST_DISTRIB_CSR_GRAPH_TYPE::adjacency_iterator,
                 typename BOOST_DISTRIB_CSR_GRAPH_TYPE::adjacency_iterator>
adjacent_vertices(typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor u,
                  const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  return adjacent_vertices(get(vertex_local, g, u), g.base());
}

// -----------------------------------------------------------------
// Distributed Vertex List Graph concept operations
template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
class BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_iterator
  : public iterator_adaptor<vertex_iterator,
                            counting_iterator<Vertex>,
                            Vertex,
                            random_access_traversal_tag,
                            Vertex>
{
  typedef iterator_adaptor<vertex_iterator,
                           counting_iterator<Vertex>,
                           Vertex,
                           random_access_traversal_tag,
                           Vertex> inherited;
 public:
  vertex_iterator() {}

  explicit vertex_iterator(Vertex v, const self_type* graph)
    : inherited(counting_iterator<Vertex>(v)), graph(graph) { }

  Vertex dereference() const
  {
    return graph->local_to_global_vertex(*(this->base_reference()));
  }

  friend class iterator_core_access;

 private:
  const self_type* graph;
};

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename BOOST_DISTRIB_CSR_GRAPH_TYPE::degree_size_type
num_vertices(const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  return num_vertices(g.base());
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline std::pair<typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_iterator,
                 typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_iterator>
vertices(const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_iterator
    vertex_iterator;
  return std::make_pair(vertex_iterator(0, &g),
                        vertex_iterator(num_vertices(g), &g));
}

// -----------------------------------------------------------------
// Distributed Edge List Graph concept operations
template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
class BOOST_DISTRIB_CSR_GRAPH_TYPE::edge_iterator
{
 public:
  typedef std::forward_iterator_tag iterator_category;
  typedef edge_descriptor value_type;

  typedef const edge_descriptor* pointer;

  typedef edge_descriptor reference;
  typedef typename int_t<CHAR_BIT * sizeof(EdgeIndex)>::fast difference_type;

  edge_iterator() : graph(0), current_edge(), end_of_this_vertex(0) {}

  edge_iterator(const compressed_sparse_row_graph& graph,
                edge_descriptor current_edge,
                EdgeIndex end_of_this_vertex)
    : graph(&graph), local_src(current_edge.src), current_edge(current_edge),
      end_of_this_vertex(end_of_this_vertex)
  {
    // The edge that comes in has a local source vertex. Make it global.
    current_edge.src = graph.local_to_global_vertex(current_edge.src);
  }

  // From InputIterator
  reference operator*() const { return current_edge; }
  pointer operator->() const { return &current_edge; }

  bool operator==(const edge_iterator& o) const {
    return current_edge == o.current_edge;
  }
  bool operator!=(const edge_iterator& o) const {
    return current_edge != o.current_edge;
  }

  edge_iterator& operator++()
  {
    ++current_edge.idx;
    while (current_edge.idx == end_of_this_vertex && local_src < num_vertices(*graph)-1) {
      ++local_src;
      current_edge.src = graph->local_to_global_vertex(local_src);
      end_of_this_vertex = graph->base().m_forward.m_rowstart[local_src + 1];
    }
    return *this;
  }

  edge_iterator operator++(int) {
    edge_iterator temp = *this;
    ++*this;
    return temp;
  }

 private:
  const compressed_sparse_row_graph* graph;
  EdgeIndex local_src;
  edge_descriptor current_edge;
  EdgeIndex end_of_this_vertex;
};

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edges_size_type
num_edges(const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  return g.base().m_forward.m_column.size();
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
std::pair<typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edge_iterator,
          typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edge_iterator>
edges(const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor Vertex;
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edge_iterator ei;
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edge_descriptor edgedesc;
  if (g.base().m_forward.m_rowstart.size() == 1 ||
      g.base().m_forward.m_column.empty()) {
    return std::make_pair(ei(), ei());
  } else {
    // Find the first vertex that has outgoing edges
    Vertex src = 0;
    while (g.base().m_forward.m_rowstart[src + 1] == 0) ++src;
    return std::make_pair(ei(g, edgedesc(src, 0), g.base().m_forward.m_rowstart[src + 1]),
                          ei(g, edgedesc(num_vertices(g), g.base().m_forward.m_column.size()), 0));
  }
}

// -----------------------------------------------------------------
// Graph constructors

// Returns true if a vertex belongs to a process according to a distribution
template <typename OwnerMap, typename ProcessId>
struct local_vertex {

  local_vertex(OwnerMap owner, ProcessId id) 
    : owner(owner), id(id) {}

  template <typename Vertex>
  bool operator()(Vertex x) 
  { return get(owner, x) == id; }

  template <typename Vertex>
  bool operator()(Vertex x) const
  { return get(owner, x) == id; }

private:
  OwnerMap owner;
  ProcessId id;
};

// Returns true if a vertex belongs to a process according to a distribution
template <typename OwnerMap, typename ProcessId>
struct local_edge {

  local_edge(OwnerMap owner, ProcessId id) 
    : owner(owner), id(id) {}

  template <typename Vertex>
  bool operator()(std::pair<Vertex, Vertex>& x) 
  { return get(owner, x.first) == id; }

  template <typename Vertex>
  bool operator()(const std::pair<Vertex, Vertex>& x) const
  { return get(owner, x.first) == id; }

private:
  OwnerMap owner;
  ProcessId id;
};

// Turns an index iterator into a vertex iterator
template<typename IndexIterator, typename Graph>
class index_to_vertex_iterator {
  
public:
  typedef std::input_iterator_tag iterator_category;
  typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
  typedef std::pair<Vertex, Vertex> value_type;
  typedef const value_type& reference;
  typedef const value_type* pointer;
  typedef void difference_type;

  index_to_vertex_iterator(IndexIterator index,
                           const Graph& g) 
    : index(index), g(g), current(to_edge(*index)) {}

  reference operator*() { current = to_edge(*index); return current; }
  pointer operator->() { current = to_edge(*index); return &current; }

  index_to_vertex_iterator& operator++()
  {
    ++index;
    return *this;
  }

  index_to_vertex_iterator operator++(int)
  {
    index_to_vertex_iterator temp(*this);
    ++(*this);
    return temp;
  }

  bool operator==(const index_to_vertex_iterator& other) const
  { return index == other.index; }
  
  bool operator!=(const index_to_vertex_iterator& other) const
  { return !(*this == other); }

private:
  value_type to_edge(const typename std::iterator_traits<IndexIterator>::value_type& x)
  { return std::make_pair(vertex(x.first, g), vertex(x.second, g)); }

  IndexIterator index;
  const Graph& g;  
  value_type current;
};

template <typename Distribution, typename Graph>
struct index_to_vertex_func {

  typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_descriptor;
  typedef typename boost::graph_traits<Graph>::vertices_size_type vertices_size_type;
  typedef std::pair<vertex_descriptor, vertex_descriptor> result_type;
  typedef std::pair<vertices_size_type, vertices_size_type> base_iterator_type;

  index_to_vertex_func(const Distribution& dist, const Graph& g)
    : dist(dist), g(g) {}


  result_type operator()(const base_iterator_type& p) const 
  {
    return std::make_pair(vertex(p.first, g), vertex(p.second, g));
  }

private:
  const Distribution& dist;
  const Graph& g;
};

// NGE: This method only works with iterators that have a difference_type,
// the index_to_vertex_iterator class above is retained for compatibility
// with BGL generators which have no difference_type
template <typename IndexIterator, typename Distribution, typename Graph>
boost::transform_iterator<index_to_vertex_func<Distribution, Graph>, IndexIterator>
make_index_to_vertex_iterator(IndexIterator it, const Distribution& dist, 
                              const Graph& g) {
  return boost::make_transform_iterator(
    it, index_to_vertex_func<Distribution, Graph>(dist, g));
}

// Forward declaration of csr_vertex_owner_map
template<typename ProcessID, typename Key> class csr_vertex_owner_map;

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template<typename InputIterator>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(edges_are_unsorted_t,
                            InputIterator edge_begin, InputIterator edge_end,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(parallel::block(m_process_group, numverts)),
    m_base(edges_are_unsorted_global,
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_begin, *this),
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_end, *this),
           m_distribution.block_size(process_id(m_process_group), numverts),
           get(vertex_local, *this),
           local_vertex<csr_vertex_owner_map<process_id_type, vertex_descriptor>, 
                        process_id_type> (get(vertex_owner, *this), process_id(pg)),
           prop)
{ }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template <typename InputIterator, typename Distribution>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(edges_are_unsorted_t,
                            InputIterator edge_begin, InputIterator edge_end,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const Distribution& dist,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(dist),
    m_base(edges_are_unsorted_global,
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_begin, *this),
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_end, *this),
           m_distribution.block_size(process_id(m_process_group), numverts),
           get(vertex_local, *this),
           local_vertex<csr_vertex_owner_map<process_id_type, vertex_descriptor>, 
                        process_id_type> (get(vertex_owner, *this), process_id(pg)),
           prop)
{ }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template<typename InputIterator, typename EdgePropertyIterator>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(edges_are_unsorted_t,
                            InputIterator edge_begin, InputIterator edge_end,
                            EdgePropertyIterator ep_iter,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(parallel::block(m_process_group, numverts)),
    m_base(edges_are_unsorted_global,
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_begin, *this),
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_end, *this),
           ep_iter,
           m_distribution.block_size(process_id(m_process_group), numverts),
           get(vertex_local, *this),
           local_vertex<csr_vertex_owner_map<process_id_type, vertex_descriptor>, 
                        process_id_type> (get(vertex_owner, *this), process_id(pg)),
           prop)
{ }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template <typename InputIterator, typename EdgePropertyIterator,
          typename Distribution>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(edges_are_unsorted_t,
                            InputIterator edge_begin, InputIterator edge_end,
                            EdgePropertyIterator ep_iter,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const Distribution& dist,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(dist),
    m_base(edges_are_unsorted_global,
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_begin, *this),
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_end, *this),
           ep_iter,
           m_distribution.block_size(process_id(m_process_group), numverts),
           get(vertex_local, *this),
           local_vertex<csr_vertex_owner_map<process_id_type, vertex_descriptor>, 
                        process_id_type> (get(vertex_owner, *this), process_id(pg)),
           prop)
{ }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template<typename InputIterator>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(edges_are_sorted_t,
                            InputIterator edge_begin, InputIterator edge_end,
                            vertices_size_type numverts,
                            edges_size_type numedges, // This is not used as there is no appropriate BGL ctor
                            const ProcessGroup& pg,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(parallel::block(m_process_group, numverts)),
    m_base(edges_are_sorted_global,
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_begin, *this),
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_end, *this),
           get(vertex_local, *this),
           local_vertex<csr_vertex_owner_map<process_id_type, vertex_descriptor>, 
                        process_id_type> (get(vertex_owner, *this), process_id(pg)),
           m_distribution.block_size(process_id(m_process_group), numverts),
           prop)
{ }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template <typename InputIterator, typename Distribution>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(edges_are_sorted_t,
                            InputIterator edge_begin, InputIterator edge_end,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const Distribution& dist,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(dist),
    m_base(edges_are_sorted_global,
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_begin, *this),
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_end, *this),
           get(vertex_local, *this),
           local_vertex<csr_vertex_owner_map<process_id_type, vertex_descriptor>, 
                        process_id_type> (get(vertex_owner, *this), process_id(pg)),
           m_distribution.block_size(process_id(m_process_group), numverts),
           prop)
{ }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template<typename InputIterator, typename EdgePropertyIterator>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(edges_are_sorted_t,
                            InputIterator edge_begin, InputIterator edge_end,
                            EdgePropertyIterator ep_iter,
                            vertices_size_type numverts,
                            edges_size_type numedges, // This is not used as there is no appropriate BGL ctor
                            const ProcessGroup& pg,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(parallel::block(m_process_group, numverts)),
    m_base(edges_are_sorted_global,
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_begin, *this),
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_end, *this),
           ep_iter,
           get(vertex_local, *this),
           local_vertex<csr_vertex_owner_map<process_id_type, vertex_descriptor>, 
                        process_id_type> (get(vertex_owner, *this), process_id(pg)),
           m_distribution.block_size(process_id(m_process_group), numverts),
           prop)
{ }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template<typename InputIterator, typename EdgePropertyIterator,
         typename Distribution>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(edges_are_sorted_t,
                            InputIterator edge_begin, InputIterator edge_end,
                            EdgePropertyIterator ep_iter,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const Distribution& dist,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(dist),
    m_base(edges_are_sorted_global,
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_begin, *this),
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_end, *this),
           ep_iter,
           get(vertex_local, *this),
           local_vertex<csr_vertex_owner_map<process_id_type, vertex_descriptor>, 
                        process_id_type> (get(vertex_owner, *this), process_id(pg)),
           m_distribution.block_size(process_id(m_process_group), numverts),
           prop)
{ }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template<typename MultiPassInputIterator>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(edges_are_unsorted_multi_pass_t,
                            MultiPassInputIterator edge_begin, 
                            MultiPassInputIterator edge_end,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(parallel::block(m_process_group, numverts)),
    m_base(edges_are_unsorted_multi_pass_global,
           make_index_to_vertex_iterator(edge_begin, parallel::block(m_process_group, numverts), *this),
           make_index_to_vertex_iterator(edge_end, parallel::block(m_process_group, numverts), *this),
           m_distribution.block_size(process_id(m_process_group), numverts),
           get(vertex_local, *this),
           local_vertex<csr_vertex_owner_map<process_id_type, vertex_descriptor>, 
                        process_id_type> (get(vertex_owner, *this), process_id(pg)),
           prop)
{ }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template <typename MultiPassInputIterator, typename Distribution>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(edges_are_unsorted_multi_pass_t,
                            MultiPassInputIterator edge_begin, 
                            MultiPassInputIterator edge_end,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const Distribution& dist,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(dist),
    m_base(edges_are_unsorted_multi_pass_global,
           make_index_to_vertex_iterator(edge_begin, parallel::block(m_process_group, numverts), *this),
           make_index_to_vertex_iterator(edge_end, parallel::block(m_process_group, numverts), *this),
           m_distribution.block_size(process_id(m_process_group), numverts),
           get(vertex_local, *this),
           local_vertex<csr_vertex_owner_map<process_id_type, vertex_descriptor>, 
                        process_id_type> (get(vertex_owner, *this), process_id(pg)),
           prop)
{ }


template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template<typename MultiPassInputIterator, typename EdgePropertyIterator>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(edges_are_unsorted_multi_pass_t,
                            MultiPassInputIterator edge_begin, 
                            MultiPassInputIterator edge_end,
                            EdgePropertyIterator ep_iter,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(parallel::block(m_process_group, numverts)),
    m_base(edges_are_unsorted_multi_pass_global,
           make_index_to_vertex_iterator(edge_begin, parallel::block(m_process_group, numverts), *this),
           make_index_to_vertex_iterator(edge_end, parallel::block(m_process_group, numverts), *this),
           ep_iter,
           m_distribution.block_size(process_id(m_process_group), numverts),
           get(vertex_local, *this),
           local_vertex<csr_vertex_owner_map<process_id_type, vertex_descriptor>, 
                        process_id_type> (get(vertex_owner, *this), process_id(pg)),
           prop)
{ }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template <typename MultiPassInputIterator, typename EdgePropertyIterator,
          typename Distribution>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(edges_are_unsorted_multi_pass_t,
                            MultiPassInputIterator edge_begin, 
                            MultiPassInputIterator edge_end,
                            EdgePropertyIterator ep_iter,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const Distribution& dist,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(dist),
    m_base(edges_are_unsorted_multi_pass_global,
           make_index_to_vertex_iterator(edge_begin, parallel::block(m_process_group, numverts), *this),
           make_index_to_vertex_iterator(edge_end, parallel::block(m_process_group, numverts), *this),
           ep_iter,
           m_distribution.block_size(process_id(m_process_group), numverts),
           get(vertex_local, *this),
           local_vertex<csr_vertex_owner_map<process_id_type, vertex_descriptor>, 
                        process_id_type> (get(vertex_owner, *this), process_id(pg)),
           prop)
{ }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template<typename Source>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(distributed_construct_inplace_from_sources_and_targets_t,
                            std::vector<Source>& sources,
                            std::vector<vertex_descriptor>& targets,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(parallel::block(m_process_group, numverts)),
    m_base(m_distribution.block_size(process_id(m_process_group), numverts))
{ 
  // Convert linear indices to global indices
  for (edges_size_type i = 0; i < sources.size(); ++i) {
    sources[i] = m_distribution.local(sources[i]);
    targets[i] = make_vertex_descriptor(m_distribution(targets[i]), 
                                        m_distribution.local(targets[i]));
  }

  m_base.assign_sources_and_targets_global(
    sources, targets, m_distribution.block_size(process_id(m_process_group), numverts),
    identity_property_map());

  // TODO: set property on m_base?
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template <typename Distribution, typename Source> 
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(distributed_construct_inplace_from_sources_and_targets_t,
                            std::vector<Source>& sources,
                            std::vector<vertex_descriptor>& targets,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const Distribution& dist,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(dist),
    m_base(m_distribution.block_size(process_id(m_process_group), numverts))
{ 
  // Convert linear indices to global indices
  for (edges_size_type i = 0; i < sources.size(); ++i) {
    sources[i] = m_distribution.local(sources[i]);
    targets[i] = make_vertex_descriptor(m_distribution(targets[i]), 
                                        m_distribution.local(targets[i]));
  }

  m_base.assign_sources_and_targets_global(
    sources, targets, m_distribution.block_size(process_id(m_process_group), numverts),
    identity_property_map());

  // TODO: set property on m_base?
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template<typename Source>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(distributed_construct_inplace_from_sources_and_targets_t,
                            std::vector<Source>& sources,
                            std::vector<vertex_descriptor>& targets,
                            std::vector<edge_bundled>& edge_props,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(parallel::block(m_process_group, numverts)),
    m_base(m_distribution.block_size(process_id(m_process_group), numverts))
{ 
  // Convert linear indices to global indices
  for (edges_size_type i = 0; i < sources.size(); ++i) {
    sources[i] = m_distribution.local(sources[i]);
    targets[i] = make_vertex_descriptor(m_distribution(targets[i]), 
                                        m_distribution.local(targets[i]));
  }

  m_base.assign_sources_and_targets_global(
    sources, targets, edge_props, 
    m_distribution.block_size(process_id(m_process_group), numverts),
    identity_property_map());

  // TODO: set property on m_base?
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template <typename Distribution, typename Source> 
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(distributed_construct_inplace_from_sources_and_targets_t,
                            std::vector<Source>& sources,
                            std::vector<vertex_descriptor>& targets,
                            std::vector<edge_bundled>& edge_props,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const Distribution& dist,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(dist),
    m_base(m_distribution.block_size(process_id(m_process_group), numverts))
{ 
  // Convert linear indices to global indices
  for (edges_size_type i = 0; i < sources.size(); ++i) {
    sources[i] = m_distribution.local(sources[i]);
    targets[i] = make_vertex_descriptor(m_distribution(targets[i]), 
                                        m_distribution.local(targets[i]));
  }

  m_base.assign_sources_and_targets_global(
    sources, targets, edge_props, 
    m_distribution.block_size(process_id(m_process_group), numverts),
    identity_property_map());

  // TODO: set property on m_base?
}

//
// Old (untagged) ctors, these default to the unsorted sequential ctors
//
template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template<typename InputIterator>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(InputIterator edge_begin, InputIterator edge_end,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(parallel::block(m_process_group, numverts)),
    m_base(edges_are_unsorted_global,
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_begin, *this),
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_end, *this),
           m_distribution.block_size(process_id(m_process_group), numverts),
           get(vertex_local, *this),
           local_vertex<csr_vertex_owner_map<process_id_type, vertex_descriptor>, 
                        process_id_type> (get(vertex_owner, *this), process_id(pg)),
           prop)
           
{
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template<typename InputIterator, typename EdgePropertyIterator>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(InputIterator edge_begin, InputIterator edge_end,
                            EdgePropertyIterator ep_iter,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const GraphProperty& prop)
  : m_process_group(pg),

    m_distribution(parallel::block(m_process_group, numverts)),
    m_base(edges_are_unsorted_global,
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_begin, *this),
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_end, *this),
           ep_iter,
           m_distribution.block_size(process_id(m_process_group), numverts),
           get(vertex_local, *this),
           local_vertex<csr_vertex_owner_map<process_id_type, vertex_descriptor>, 
                        process_id_type> (get(vertex_owner, *this), process_id(pg)),
           prop)
{
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template<typename InputIterator, typename Distribution>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(InputIterator edge_begin, InputIterator edge_end,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const Distribution& dist,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(dist),
    m_base(edges_are_unsorted_global,
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_begin, *this),
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_end, *this),
           m_distribution.block_size(process_id(m_process_group), numverts),
           get(vertex_local, *this),
           local_vertex<csr_vertex_owner_map<process_id_type, vertex_descriptor>, 
                        process_id_type> (get(vertex_owner, *this), process_id(pg)),
           prop)
{
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
template<typename InputIterator, typename EdgePropertyIterator, 
         typename Distribution>
BOOST_DISTRIB_CSR_GRAPH_TYPE::
compressed_sparse_row_graph(InputIterator edge_begin, InputIterator edge_end,
                            EdgePropertyIterator ep_iter,
                            vertices_size_type numverts,
                            const ProcessGroup& pg,
                            const Distribution& dist,
                            const GraphProperty& prop)
  : m_process_group(pg),
    m_distribution(dist),
    m_base(edges_are_unsorted_global,
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_begin, *this),
           index_to_vertex_iterator<InputIterator, BOOST_DISTRIB_CSR_GRAPH_TYPE>(edge_end, *this),
           m_distribution.block_size(process_id(m_process_group), numverts),
           get(vertex_local, *this),
           local_vertex<csr_vertex_owner_map<process_id_type, vertex_descriptor>, 
                        process_id_type> (get(vertex_owner, *this), process_id(pg)),
           prop)
{
}

// -----------------------------------------------------------------
// Vertex Global Property Map
template<typename ProcessID, typename Key>
class csr_vertex_global_map
{
 public:
  // -----------------------------------------------------------------
  // Readable Property Map concept requirements
  typedef std::pair<ProcessID, Key> value_type;
  typedef value_type reference;
  typedef Key key_type;
  typedef readable_property_map_tag category;
};

template<typename ProcessID, typename Key>
inline std::pair<ProcessID, Key>
get(csr_vertex_global_map<ProcessID, Key>,
    typename csr_vertex_global_map<ProcessID, Key>::key_type k)
{
  const int local_index_bits = sizeof(Key) * CHAR_BIT - processor_bits;
  const Key local_index_mask = Key(-1) >> processor_bits;

  return std::pair<ProcessID, Key>(k >> local_index_bits,
                                   k & local_index_mask);
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
class property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_global_t>
{
 public:
  typedef csr_vertex_global_map<
            typename ProcessGroup::process_id_type,
            typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor> type;
  typedef type const_type;
};

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_global_t>::type
get(vertex_global_t, BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_global_t>
    ::type result_type;
  return result_type();
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
std::pair<typename ProcessGroup::process_id_type,
          typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor>
get(vertex_global_t, BOOST_DISTRIB_CSR_GRAPH_TYPE& g,
    typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor k)
{
  return get(vertex_global, 
             const_cast<const BOOST_DISTRIB_CSR_GRAPH_TYPE&>(g), 
             k);
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_global_t>::const_type
get(vertex_global_t, const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_global_t>
    ::const_type result_type;
  return result_type();
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
std::pair<typename ProcessGroup::process_id_type,
          typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor>
get(vertex_global_t, const BOOST_DISTRIB_CSR_GRAPH_TYPE& g,
    typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor k)
{
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor
    vertex_descriptor;
  typedef std::pair<typename ProcessGroup::process_id_type, vertex_descriptor>
    result_type;
  const int local_index_bits = 
    sizeof(vertex_descriptor) * CHAR_BIT - processor_bits;
  const vertex_descriptor local_index_mask = 
    vertex_descriptor(-1) >> processor_bits;

  return result_type(k >> local_index_bits, k & local_index_mask);
}

// -----------------------------------------------------------------
// Extra, common functions
template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor
vertex(typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertices_size_type i,
       const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  return g.make_vertex_descriptor(g.distribution()(i), 
                                  g.distribution().local(i));
}

// Unlike for an adjacency_matrix, edge_range and edge take lg(out_degree(i))
// time
template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline std::pair<typename BOOST_DISTRIB_CSR_GRAPH_TYPE::out_edge_iterator,
                 typename BOOST_DISTRIB_CSR_GRAPH_TYPE::out_edge_iterator>
edge_range(typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor i,
           typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor j,
           const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor Vertex;
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edges_size_type EdgeIndex;
  typedef typename std::vector<Vertex>::const_iterator adj_iter;
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::out_edge_iterator out_edge_iter;
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edge_descriptor edge_desc;
  std::pair<adj_iter, adj_iter> raw_adjacencies = adjacent_vertices(i, g);
  std::pair<adj_iter, adj_iter> adjacencies =
    std::equal_range(raw_adjacencies.first, raw_adjacencies.second, j);
  EdgeIndex idx_begin = adjacencies.first - g.base().m_forward.m_column.begin();
  EdgeIndex idx_end = adjacencies.second - g.base().m_forward.m_column.begin();
  return std::make_pair(out_edge_iter(edge_desc(i, idx_begin)),
                        out_edge_iter(edge_desc(i, idx_end)));
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline std::pair<typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edge_descriptor, bool>
edge(typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor i,
     typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor j,
     const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::out_edge_iterator out_edge_iter;
  std::pair<out_edge_iter, out_edge_iter> range = edge_range(i, j, g);
  if (range.first == range.second)
    return std::make_pair(typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edge_descriptor(),
                          false);
  else
    return std::make_pair(*range.first, true);
}

// A helper that turns requests for property maps for const graphs
// into property maps for non-const graphs.
template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS, typename Property>
class property_map<const BOOST_DISTRIB_CSR_GRAPH_TYPE, Property>
{
 public:
  typedef typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, Property>
    ::const_type type;
  typedef type const_type;
};

// -----------------------------------------------------------------
// Structural modifiers

#if 0
template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor
add_vertex(BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{ return g.add_vertex(); }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor
add_vertex(const typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_bundled& p, 
           BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{ return g.add_vertex(p); }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor
add_vertices(typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertices_size_type count, 
             BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{ return g.add_vertices(count); }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS, typename InputIterator>
void 
add_edges(InputIterator first, InputIterator last,
          BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{ g.add_edges(first, last); }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS, typename InputIterator, 
         typename EdgePropertyIterator>
void 
add_edges(InputIterator first, InputIterator last,
          EdgePropertyIterator ep_iter,
          EdgePropertyIterator ep_iter_end,
          BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{ return g.add_edges(first, last, ep_iter, ep_iter_end); }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS, typename InputIterator>
void 
add_edges_sorted(InputIterator first, InputIterator last,
                 BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{ return g.add_edges_sorted(first, last); }

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS, typename InputIterator, 
         typename EdgePropertyIterator>
void 
add_edges_sorted(InputIterator first_sorted, InputIterator last_sorted,
                 EdgePropertyIterator ep_iter_sorted,
                 BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{ g.add_edges_sorted(first_sorted, last_sorted, ep_iter_sorted); }
#endif

// -----------------------------------------------------------------
// Vertex Owner Property Map
template<typename ProcessID, typename Key>
class csr_vertex_owner_map
{
 public:
  // -----------------------------------------------------------------
  // Readable Property Map concept requirements
  typedef ProcessID value_type;
  typedef value_type reference;
  typedef Key key_type;
  typedef readable_property_map_tag category;
};

template<typename ProcessID, typename Key>
inline ProcessID
get(csr_vertex_owner_map<ProcessID, Key> pm,
    typename csr_vertex_owner_map<ProcessID, Key>::key_type k)
{
  const int local_index_bits = sizeof(Key) * CHAR_BIT - processor_bits;
  return k >> local_index_bits;
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
class property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_owner_t>
{
 public:
  typedef csr_vertex_owner_map<
            typename ProcessGroup::process_id_type,
            typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor> type;
  typedef type const_type;
};

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_owner_t>::type
get(vertex_owner_t, BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_owner_t>
    ::type result_type;
  return result_type();
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename ProcessGroup::process_id_type
get(vertex_owner_t, BOOST_DISTRIB_CSR_GRAPH_TYPE& g,
    typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor k)
{
  return get(vertex_owner, 
             const_cast<const BOOST_DISTRIB_CSR_GRAPH_TYPE&>(g),
             k);
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_owner_t>::const_type
get(vertex_owner_t, const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_owner_t>
    ::const_type result_type;
  return result_type();
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename ProcessGroup::process_id_type
get(vertex_owner_t, const BOOST_DISTRIB_CSR_GRAPH_TYPE& g,
    typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor k)
{
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor
    vertex_descriptor;
  const int local_index_bits = 
    sizeof(vertex_descriptor) * CHAR_BIT - processor_bits;
  return k >> local_index_bits;
}

// -----------------------------------------------------------------
// Vertex Local Property Map
template<typename Key>
class csr_vertex_local_map
{
 public:
  // -----------------------------------------------------------------
  // Readable Property Map concept requirements
  typedef Key value_type;
  typedef value_type reference;
  typedef Key key_type;
  typedef readable_property_map_tag category;
};

template<typename Key>
inline Key
get(csr_vertex_local_map<Key> pm,
    typename csr_vertex_local_map<Key>::key_type k)
{
  const Key local_index_mask = Key(-1) >> processor_bits;
  return k & local_index_mask;
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
class property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_local_t>
{
 public:
  typedef csr_vertex_local_map<
            typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor> type;
  typedef type const_type;
};

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_local_t>::type
get(vertex_local_t, BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_local_t>
    ::type result_type;
  return result_type();
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor
get(vertex_local_t, BOOST_DISTRIB_CSR_GRAPH_TYPE& g,
    typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor k)
{
  return get(vertex_local, 
             const_cast<const BOOST_DISTRIB_CSR_GRAPH_TYPE&>(g),
             k);
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_local_t>::const_type
get(vertex_local_t, const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_local_t>
    ::const_type result_type;
  return result_type();
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor
get(vertex_local_t, const BOOST_DISTRIB_CSR_GRAPH_TYPE& g,
    typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor k)
{
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor 
    vertex_descriptor;
  const vertex_descriptor local_index_mask = 
    vertex_descriptor(-1) >> processor_bits;
  return k & local_index_mask;
}

// -----------------------------------------------------------------
// Vertex Index Property Map
template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
class property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_index_t>
{
  typedef typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, 
                                vertex_global_t>::const_type
    global_map;
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::process_group_type
    process_group_type;

  typedef property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_local_t> local;

public:
  typedef local_property_map<process_group_type, 
                             global_map, 
                             typename local::type> type;
  typedef local_property_map<process_group_type, 
                             global_map, 
                             typename local::const_type> const_type;
};

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_index_t>::type
get(vertex_index_t, BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_index_t>
    ::type result_type;

  return result_type(g.process_group(), get(vertex_global, g),
                     get(vertex_local, g));
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertices_size_type
get(vertex_index_t, BOOST_DISTRIB_CSR_GRAPH_TYPE& g,
    typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor k)
{
  return get(vertex_local, g, k);
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_index_t>::const_type
get(vertex_index_t, const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_index_t>
    ::const_type result_type;
  return result_type(g.process_group(), get(vertex_global, g),
                     get(vertex_local, g));
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertices_size_type
get(vertex_index_t, const BOOST_DISTRIB_CSR_GRAPH_TYPE& g,
    typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor k)
{
  return get(vertex_local, g, k);
}

// -----------------------------------------------------------------
// Vertex Local Index Property Map
template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
class property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_local_index_t>
  : public property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_local_t> { };

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_local_index_t>::type
get(vertex_local_index_t, BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  return get(vertex_local, g);
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertices_size_type
get(vertex_local_index_t, BOOST_DISTRIB_CSR_GRAPH_TYPE& g,
    typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor k)
{
  return get(vertex_local, g, k);
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, vertex_local_index_t>::const_type
get(vertex_local_index_t, const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  return get(vertex_local, g);
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertices_size_type
get(vertex_local_index_t, const BOOST_DISTRIB_CSR_GRAPH_TYPE& g,
    typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor k)
{
  return get(vertex_local, g, k);
}

// -----------------------------------------------------------------
// Edge Global Property Map
template<typename ProcessID, typename Vertex, typename EdgeIndex>
class csr_edge_global_map
{
 public:
  // -----------------------------------------------------------------
  // Readable Property Map concept requirements
  typedef detail::csr_edge_descriptor<Vertex, EdgeIndex> key_type;
  typedef std::pair<ProcessID, detail::csr_edge_descriptor<Vertex, EdgeIndex> > value_type;
  typedef value_type reference;
  typedef readable_property_map_tag category;
};

template<typename ProcessID, typename Vertex, typename EdgeIndex>
inline std::pair<ProcessID, detail::csr_edge_descriptor<Vertex, EdgeIndex> >
get(csr_edge_global_map<ProcessID, Vertex, EdgeIndex> pm,
    typename csr_edge_global_map<ProcessID, Vertex, EdgeIndex>::key_type k)
{
  const int local_index_bits = sizeof(Vertex) * CHAR_BIT - processor_bits;
  const Vertex local_index_mask = Vertex(-1) >> processor_bits;
  return std::pair<ProcessID, detail::csr_edge_descriptor<Vertex, EdgeIndex> >
           ((k.src >> local_index_bits),
            detail::csr_edge_descriptor<Vertex, EdgeIndex>(k.src & local_index_mask, k.idx));
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
class property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, edge_global_t>
{
 public:
  typedef csr_edge_global_map<
            typename ProcessGroup::process_id_type,
            typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor,
            typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edges_size_type> type;
  typedef type const_type;
};

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, edge_global_t>::type
get(edge_global_t, BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, edge_global_t>
    ::type result_type;
  return result_type();
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
std::pair<typename ProcessGroup::process_id_type,
          typename BOOST_DISTRIB_CSR_GRAPH_TYPE::base_type::edge_descriptor>
get(edge_global_t, BOOST_DISTRIB_CSR_GRAPH_TYPE& g,
    typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edge_descriptor k)
{
  return get(edge_global, 
             const_cast<const BOOST_DISTRIB_CSR_GRAPH_TYPE&>(g),
             k);
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, edge_global_t>::const_type
get(edge_global_t, const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, edge_global_t>
    ::const_type result_type;
  return result_type();
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
std::pair<typename ProcessGroup::process_id_type,
          typename BOOST_DISTRIB_CSR_GRAPH_TYPE::base_type::edge_descriptor>
get(edge_global_t, const BOOST_DISTRIB_CSR_GRAPH_TYPE& g,
    typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edge_descriptor k)
{
  typedef typename BOOST_DISTRIB_CSR_GRAPH_TYPE::vertex_descriptor
    vertex_descriptor;

  const int local_index_bits = 
    sizeof(vertex_descriptor) * CHAR_BIT - processor_bits;
  const typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edges_size_type local_index_mask =
    typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edges_size_type(-1) >> processor_bits;
  
  typedef std::pair<typename ProcessGroup::process_id_type,
                    typename BOOST_DISTRIB_CSR_GRAPH_TYPE::base_type::edge_descriptor>
    result_type;

  return result_type(k.src >> local_index_bits,
                     typename BOOST_DISTRIB_CSR_GRAPH_TYPE::base_type::edge_descriptor
                       (k.src & local_index_mask, k.idx));
}

// -----------------------------------------------------------------
// Edge Index Property Map
template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
class property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, edge_index_t>
{
   typedef typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, edge_global_t>
    ::type global_map;

 public:
  typedef local_property_map<
            typename BOOST_DISTRIB_CSR_GRAPH_TYPE::process_group_type,
            global_map,
            typename property_map<typename BOOST_DISTRIB_CSR_GRAPH_TYPE::base_type, edge_index_t>::type
          > type;
  typedef type const_type;
};

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, edge_index_t>::type
get(edge_index_t, BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, edge_index_t>
    ::type result_type;
  return result_type(g.process_group(), get(edge_global, g),
                     get(edge_index, g.base()));
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edges_size_type
get(edge_index_t, BOOST_DISTRIB_CSR_GRAPH_TYPE& g,
    typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edge_descriptor k)
{
  return k.idx;
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline
typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, edge_index_t>::const_type
get(edge_index_t, const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, edge_index_t>
    ::const_type result_type;
  return result_type(g.process_group(), get(edge_global, g),
                     get(edge_index, g.base()));
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS>
inline typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edges_size_type
get(edge_index_t, const BOOST_DISTRIB_CSR_GRAPH_TYPE& g,
    typename BOOST_DISTRIB_CSR_GRAPH_TYPE::edge_descriptor k)
{
  return k.idx;
}

template <BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
class property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, Tag> {
  typedef BOOST_DISTRIB_CSR_GRAPH_TYPE graph_type;
  typedef typename graph_type::process_group_type process_group_type;
  typedef typename graph_type::base_type base_graph_type;
  typedef typename property_map<base_graph_type, Tag>::type
    local_pmap;
  typedef typename property_map<base_graph_type, Tag>::const_type
    local_const_pmap;

  typedef graph_traits<graph_type> traits;
  typedef typename graph_traits<base_graph_type>::vertex_descriptor local_vertex;
  typedef typename property_traits<local_pmap>::key_type local_key_type;

  typedef typename property_traits<local_pmap>::value_type value_type;

  typedef typename property_map<graph_type, vertex_global_t>::const_type
    vertex_global_map;
  typedef typename property_map<graph_type, edge_global_t>::const_type
    edge_global_map;

  typedef typename mpl::if_<is_same<typename detail::property_kind_from_graph<base_graph_type, Tag>::type,
                                    vertex_property_tag>,
                            vertex_global_map, edge_global_map>::type
    global_map;

public:
  typedef ::boost::parallel::distributed_property_map<
            process_group_type, global_map, local_pmap> type;

  typedef ::boost::parallel::distributed_property_map<
            process_group_type, global_map, local_const_pmap> const_type;
};

template <BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, Tag>::type
get(Tag tag, BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef BOOST_DISTRIB_CSR_GRAPH_TYPE Graph;
  typedef typename property_map<Graph, Tag>::type result_type;
  typedef typename property_traits<result_type>::value_type value_type;
  typedef typename property_reduce<Tag>::template apply<value_type>
    reduce;

  typedef typename mpl::if_<is_same<typename detail::property_kind_from_graph<Graph, Tag>::type,
                                    vertex_property_tag>,
                            vertex_global_t, edge_global_t>::type
    global_map_t;

  return result_type(g.process_group(), get(global_map_t(), g),
                     get(tag, g.base()), reduce());
}

template<BOOST_DISTRIB_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
typename property_map<BOOST_DISTRIB_CSR_GRAPH_TYPE, Tag>::const_type
get(Tag tag, const BOOST_DISTRIB_CSR_GRAPH_TYPE& g)
{
  typedef BOOST_DISTRIB_CSR_GRAPH_TYPE Graph;
  typedef typename property_map<Graph, Tag>::const_type result_type;
  typedef typename property_traits<result_type>::value_type value_type;
  typedef typename property_reduce<Tag>::template apply<value_type>
    reduce;

  typedef typename property_traits<result_type>::key_type descriptor;
  typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
  typedef typename mpl::if_<is_same<descriptor, vertex_descriptor>,
                            vertex_global_t, edge_global_t>::type
    global_map_t;

  return result_type(g.process_group(), get(global_map_t(), g),
                     get(tag, g.base()), reduce());
}

namespace mpi {
  template<typename Vertex, typename EdgeIndex>
  struct is_mpi_datatype<boost::detail::csr_edge_descriptor<Vertex, EdgeIndex> >
    : mpl::true_ { };
}

namespace serialization {
  template<typename Vertex, typename EdgeIndex>
  struct is_bitwise_serializable<boost::detail::csr_edge_descriptor<Vertex, EdgeIndex> >
    : mpl::true_ { };

  template<typename Vertex, typename EdgeIndex>
  struct implementation_level<boost::detail::csr_edge_descriptor<Vertex, EdgeIndex> >
   : mpl::int_<object_serializable> {} ;

  template<typename Vertex, typename EdgeIndex>
  struct tracking_level<boost::detail::csr_edge_descriptor<Vertex, EdgeIndex> >
   : mpl::int_<track_never> {} ;

}

} // end namespace boost

#endif // BOOST_GRAPH_DISTRIBUTED_CSR_HPP
",16372,True,3391.3967544136613,median
"/****************************************************************************
 * Copyright (C) from 2009 to Present EPAM Systems.
 *
 * This file is part of Indigo toolkit.
 *
 * 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.
 ***************************************************************************/

#include ""molecule/smiles_saver.h""
#include ""base_cpp/array.h""
#include ""base_cpp/output.h""
#include ""base_cpp/tlscont.h""
#include ""graph/cycle_basis.h""
#include ""graph/dfs_walk.h""
#include ""molecule/canonical_smiles_saver.h""
#include ""molecule/elements.h""
#include ""molecule/molecule.h""
#include ""molecule/molecule_arom_match.h""
#include ""molecule/molecule_rgroups.h""
#include ""molecule/molecule_savers.h""
#include ""molecule/molecule_stereocenters.h""
#include ""molecule/query_molecule.h""

using namespace indigo;

IMPL_ERROR(SmilesSaver, ""SMILES saver"");

CP_DEF(SmilesSaver);

SmilesSaver::SmilesSaver(Output& output)
    : _output(output), CP_INIT, TL_CP_GET(_neipool), TL_CP_GET(_atoms), TL_CP_GET(_hcount), TL_CP_GET(_hcount_ignored), TL_CP_GET(_dbonds),
      TL_CP_GET(_written_atoms), TL_CP_GET(_written_atoms_inv), TL_CP_GET(_written_bonds), TL_CP_GET(_polymer_indices), TL_CP_GET(_attachment_indices),
      TL_CP_GET(_attachment_cycle_numbers), TL_CP_GET(_aromatic_bonds), TL_CP_GET(_ignored_vertices), TL_CP_GET(_complicated_cistrans), TL_CP_GET(_ban_slashes),
      TL_CP_GET(_cis_trans_parity)
{
    vertex_ranks = 0;
    ignore_hydrogens = false;
    canonize_chiralities = false;
    write_extra_info = true;
    _mol = 0;
    smarts_mode = false;
    inside_rsmiles = false;
    ignore_invalid_hcount = true;
    separate_rsites = true;
    rsite_indices_as_aam = true;
    _n_attachment_points = 0;
    _have_complicated_cistrans = false;
}

SmilesSaver::~SmilesSaver()
{
    _atoms.clear(); // to avoid data race when it is reused in another thread
}

void SmilesSaver::saveMolecule(Molecule& mol)
{
    _bmol = &mol;
    _qmol = 0;
    _mol = &mol;
    _saveMolecule();
}

void SmilesSaver::saveQueryMolecule(QueryMolecule& mol)
{
    _bmol = &mol;
    _qmol = &mol;
    _mol = 0;
    _saveMolecule();
}

void SmilesSaver::_saveMolecule()
{
    int i, j, k;

    _ignored_vertices.clear_resize(_bmol->vertexEnd());
    _ignored_vertices.zerofill();
    if (ignore_hydrogens)
    {
        if (_qmol != 0)
            throw Error(""ignore_hydrogens does not make sense for query molecules"");

        for (i = _bmol->vertexBegin(); i < _bmol->vertexEnd(); i = _bmol->vertexNext(i))
            if (_mol->asMolecule().convertableToImplicitHydrogen(i))
                _ignored_vertices[i] = 1;
    }

    _checkRGroupsAndAttachmentPoints();
    _checkSRU();

    _touched_cistransbonds = 0;
    _complicated_cistrans.clear_resize(_bmol->edgeEnd());
    _complicated_cistrans.zerofill();
    _ban_slashes.clear_resize(_bmol->edgeEnd());
    _ban_slashes.zerofill();
    _cis_trans_parity.clear_resize(_bmol->edgeEnd());
    _cis_trans_parity.zerofill();
    _markCisTrans();

    _atoms.clear();
    while (_atoms.size() < _bmol->vertexEnd())
        _atoms.push(_neipool);

    _written_atoms.clear();
    _written_bonds.clear();
    _written_components = 0;

    _aromatic_bonds.clear();

    _hcount.clear_resize(_bmol->vertexEnd());
    _hcount_ignored.clear_resize(_bmol->vertexEnd());

    for (i = _bmol->vertexBegin(); i < _bmol->vertexEnd(); i = _bmol->vertexNext(i))
    {
        _hcount[i] = 0;
        if (_mol != 0)
        {
            if (!_mol->isPseudoAtom(i) && !_mol->isRSite(i))
                _hcount[i] = _mol->getImplicitH_NoThrow(i, -1);
        }
        else
        {
            int atom_number = _bmol->getAtomNumber(i);
            int atom_charge = _bmol->getAtomCharge(i);
            _hcount[i] = MoleculeSavers::getHCount(*_bmol, i, atom_number, atom_charge);
        }
        _hcount_ignored[i] = 0;

        const Vertex& vertex = _bmol->getVertex(i);

        if (ignore_hydrogens)
        {
            if (_hcount[i] >= 0)
            {
                for (j = vertex.neiBegin(); j != vertex.neiEnd(); j = vertex.neiNext(j))
                {
                    int idx = vertex.neiVertex(j);
                    if (_bmol->getAtomNumber(idx) == ELEM_H && _bmol->getAtomIsotope(idx) == 0)
                        if (_ignored_vertices[idx])
                            _hcount_ignored[i]++;
                }
                _hcount[i] += _hcount_ignored[i];
            }
        }

        if (_bmol->getAtomAromaticity(i) == ATOM_AROMATIC)
        {
            _atoms[i].aromatic = true;
            // From the SMILES specification:
            // Please note that only atoms on the following list
            // can be considered aromatic: C, N, O, P, S, As, Se, and * (wildcard).
            static int allowed_lowercase[] = {ELEM_B, ELEM_C, ELEM_N, ELEM_O, ELEM_P, ELEM_S, ELEM_Se, ELEM_As};
            if (_bmol->atomNumberBelongs(i, allowed_lowercase, NELEM(allowed_lowercase)))
                _atoms[i].lowercase = true;
        }
    }

    DfsWalk walk(*_bmol);

    walk.ignored_vertices = _ignored_vertices.ptr();
    walk.vertex_ranks = vertex_ranks;
    if (_bmol->sgroups.isPolimer())
        walk.vertex_classes = _polymer_indices.ptr();

    if (separate_rsites)
    {
        for (i = _bmol->vertexBegin(); i < _bmol->vertexEnd(); i = _bmol->vertexNext(i))
        {
            if (_bmol->isRSite(i))
                // We break the DFS walk when going through R-sites. For details, see
                // http://blueobelisk.shapado.com/questions/how-r-group-atoms-should-be-represented-in-smiles
                walk.mustBeRootVertex(i);
        }
    }

    walk.walk();

    const Array<DfsWalk::SeqElem>& v_seq = walk.getSequence();

    // fill up neighbor lists for the stereocenters calculation
    for (i = 0; i < v_seq.size(); i++)
    {
        int v_idx = v_seq[i].idx;
        int e_idx = v_seq[i].parent_edge;
        int v_prev_idx = v_seq[i].parent_vertex;

        _Atom& atom = _atoms[v_idx];

        if (e_idx >= 0)
        {
            if (walk.isClosure(e_idx))
            {
                int k;
                for (k = atom.neighbors.begin(); k != atom.neighbors.end(); k = atom.neighbors.next(k))
                {
                    if (atom.neighbors[k] == -1)
                    {
                        atom.neighbors[k] = v_prev_idx;
                        break;
                    }
                }
                if (k == atom.neighbors.end())
                    throw Error(""internal: can not put closing bond to its place"");
            }
            else
            {
                atom.neighbors.add(v_prev_idx);
                atom.parent = v_prev_idx;
            }
            _atoms[v_prev_idx].neighbors.add(v_idx);
        }

        if (e_idx < 0 || !walk.isClosure(e_idx))
        {
            int openings = walk.numOpenings(v_idx);

            for (j = 0; j < openings; j++)
                atom.neighbors.add(-1);
        }

        // also, detect polymer borders
        if (_polymer_indices[v_idx] >= 0 && (v_prev_idx == -1 || _polymer_indices[v_prev_idx] != _polymer_indices[v_idx]))
            atom.starts_polymer = true;

        if (v_prev_idx >= 0 && _polymer_indices[v_prev_idx] >= 0 && _polymer_indices[v_prev_idx] != _polymer_indices[v_idx])
            _atoms[v_prev_idx].ends_polymer = true;
    }

    _written_atoms_inv.clear_resize(_bmol->vertexEnd());
    _written_atoms_inv.fffill();

    for (i = 0; i < v_seq.size(); i++)
    {
        int v_idx = v_seq[i].idx;
        int e_idx = v_seq[i].parent_edge;

        if (e_idx == -1 || !walk.isClosure(e_idx))
        {
            _written_atoms.push(v_idx);
            _written_atoms_inv[v_idx] = _written_atoms.size() - 1;
        }

        if (e_idx != -1)
            _written_bonds.push(e_idx);
    }

    // detect chiral configurations
    MoleculeStereocenters& stereocenters = _bmol->stereocenters;

    for (i = stereocenters.begin(); i != stereocenters.end(); i = stereocenters.next(i))
    {
        int atom_idx, type, group, pyramid[4];

        stereocenters.get(i, atom_idx, type, group, pyramid);

        if (type < MoleculeStereocenters::ATOM_AND)
            continue;

        int implicit_h_idx = -1;

        if (pyramid[3] == -1)
            implicit_h_idx = 3;
        else
            for (j = 0; j < 4; j++)
                if (_ignored_vertices[pyramid[j]])
                {
                    implicit_h_idx = j;
                    break;
                }

        int pyramid_mapping[4];
        int counter = 0;

        _Atom& atom = _atoms[atom_idx];

        if (atom.parent != -1)
            for (k = 0; k < 4; k++)
                if (pyramid[k] == atom.parent)
                {
                    pyramid_mapping[counter++] = k;
                    break;
                }

        if (implicit_h_idx != -1)
            pyramid_mapping[counter++] = implicit_h_idx;

        for (j = atom.neighbors.begin(); j != atom.neighbors.end(); j = atom.neighbors.next(j))
        {
            if (atom.neighbors[j] == atom.parent)
                continue;

            for (k = 0; k < 4; k++)
                if (atom.neighbors[j] == pyramid[k])
                {
                    if (counter >= 4)
                        throw Error(""internal: pyramid overflow"");
                    pyramid_mapping[counter++] = k;
                    break;
                }
        }

        if (counter == 4)
        {
            // move the 'from' atom to the end
            counter = pyramid_mapping[0];
            pyramid_mapping[0] = pyramid_mapping[1];
            pyramid_mapping[1] = pyramid_mapping[2];
            pyramid_mapping[2] = pyramid_mapping[3];
            pyramid_mapping[3] = counter;
        }
        else if (counter != 3)
            throw Error(""cannot calculate chirality"");

        if (MoleculeStereocenters::isPyramidMappingRigid(pyramid_mapping))
            _atoms[atom_idx].chirality = 1;
        else
            _atoms[atom_idx].chirality = 2;
    }

    MoleculeAlleneStereo& allene_stereo = _bmol->allene_stereo;

    for (i = allene_stereo.begin(); i != allene_stereo.end(); i = allene_stereo.next(i))
    {
        int atom_idx, left, right, parity, subst[4], subst_map[4] = {-1, -1, -1, -1};
        int tmp;

        allene_stereo.get(i, atom_idx, left, right, subst, parity);

        for (j = 0; j < 4; j++)
            if (subst[j] >= 0)
                subst_map[j] = _written_atoms_inv[subst[j]];

        // Daylight doc says: Hydrogens attached to substituted allene-like atoms
        // are taken to be immediately following that atom
        if (subst_map[0] < 0)
            subst_map[0] = _written_atoms_inv[left];
        else if (subst_map[1] < 0)
            subst_map[1] = _written_atoms_inv[left];

        if (subst_map[2] < 0)
            subst_map[2] = _written_atoms_inv[right];
        else if (subst_map[3] < 0)
            subst_map[3] = _written_atoms_inv[right];

        if (subst_map[0] < 0 || subst_map[1] < 0 || subst_map[2] < 0 || subst_map[3] < 0)
            throw Error(""internal: allene subsituent not mapped"");

        if (subst_map[1] < subst_map[0])
        {
            __swap(subst_map[0], subst_map[1], tmp);
            parity = 3 - parity;
        }
        if (subst_map[3] < subst_map[2])
        {
            __swap(subst_map[2], subst_map[3], tmp);
            parity = 3 - parity;
        }

        _atoms[atom_idx].chirality = 3 - parity;
    }

    if (canonize_chiralities)
    {
        int i, j;
        QS_DEF(Array<int>, marked);
        QS_DEF(Array<int>, ids);
        const MoleculeStereocenters& stereocenters = _bmol->stereocenters;

        marked.clear_resize(_bmol->vertexEnd());
        marked.zerofill();

        for (i = 0; i < _written_atoms.size(); i++)
        {
            if (marked[i])
                continue;

            int idx = _written_atoms[i];

            if (_atoms[idx].chirality == 0)
                continue;

            int type = stereocenters.getType(idx);

            if (type != MoleculeStereocenters::ATOM_AND && type != MoleculeStereocenters::ATOM_OR)
                continue;

            ids.clear();
            ids.push(idx);

            int group = stereocenters.getGroup(idx);

            for (j = i + 1; j < _written_atoms.size(); j++)
            {
                if (marked[j])
                    continue;

                int idx2 = _written_atoms[j];

                if (_atoms[idx2].chirality == 0)
                    continue;

                int type2 = stereocenters.getType(idx2);
                int group2 = stereocenters.getGroup(idx2);

                if (type2 == type && group2 == group)
                {
                    ids.push(idx2);
                    marked[j] = 1;
                }
            }

            if (_atoms[ids[0]].chirality == 1)
                for (j = 0; j < ids.size(); j++)
                    _atoms[ids[j]].chirality = 3 - _atoms[ids[j]].chirality;
        }
    }

    // write the SMILES itself

    // cycle_numbers[i] == -1 means that the number is available
    // cycle_numbers[i] == n means that the number is used by vertex n
    QS_DEF(Array<int>, cycle_numbers);

    int rsites_closures_starting_num = 91;
    int rbonds = _countRBonds() + _n_attachment_points;

    if (rbonds > 9)
        rsites_closures_starting_num = 99 - rbonds;

    cycle_numbers.clear();
    cycle_numbers.push(0); // never used

    bool first_component = true;

    for (i = 0; i < v_seq.size(); i++)
    {
        int v_idx = v_seq[i].idx;
        int e_idx = v_seq[i].parent_edge;
        int v_prev_idx = v_seq[i].parent_vertex;
        bool write_atom = true;

        if (v_prev_idx >= 0)
        {
            int branches = walk.numBranches(v_prev_idx);

            if (branches > 1)
                if (_atoms[v_prev_idx].branch_cnt > 0 && _atoms[v_prev_idx].paren_written)
                    _output.writeChar(')');
            /*
             * Fix IND-673 unused if-statement
             */
            //         if (v_prev_idx >= 0)
            //         {

            if (branches > 1)
                if (_atoms[v_prev_idx].branch_cnt < branches - 1)
                {
                    if (walk.isClosure(e_idx))
                        _atoms[v_prev_idx].paren_written = false;
                    else
                    {
                        _output.writeChar('(');
                        _atoms[v_prev_idx].paren_written = true;
                    }
                }

            _atoms[v_prev_idx].branch_cnt++;

            if (_atoms[v_prev_idx].branch_cnt > branches)
                throw Error(""unexpected branch"");
            /*
             * Fix IND-673 unused if-statement
             */
            //         }

            const Edge& edge = _bmol->getEdge(e_idx);
            bool bond_written = true;

            int dir = 0;
            int bond_order = _bmol->getBondOrder(e_idx);

            if (bond_order == BOND_SINGLE)
                dir = _calcBondDirection(e_idx, v_prev_idx);

            if ((dir == 1 && v_idx == edge.end) || (dir == 2 && v_idx == edge.beg))
                _output.writeChar('/');
            else if ((dir == 2 && v_idx == edge.end) || (dir == 1 && v_idx == edge.beg))
                _output.writeChar('\\\\');
            else if (smarts_mode && _qmol != 0)
                _writeSmartsBond(e_idx, &_qmol->getBond(e_idx), false);
            else if (bond_order == BOND_DOUBLE)
                _output.writeChar('=');
            else if (bond_order == BOND_TRIPLE)
                _output.writeChar('#');
            else if (bond_order == BOND_AROMATIC && _shouldWriteAromaticBond(e_idx))
                _output.writeChar(':');
            else if (bond_order == BOND_SINGLE && _atoms[edge.beg].aromatic && _atoms[edge.end].aromatic)
                _output.writeChar('-');
            else
                bond_written = false;

            if (walk.isClosure(e_idx))
            {
                for (j = 1; j < cycle_numbers.size(); j++)
                    if (cycle_numbers[j] == v_idx)
                        break;

                if (j == cycle_numbers.size())
                    throw Error(""cycle number not found"");

                _writeCycleNumber(j);

                cycle_numbers[j] = -1;
                write_atom = false;
            }
        }
        else
        {
            if (!first_component)
                _output.writeChar('.');
            first_component = false;
            _written_components++;
        }
        if (write_atom)
        {
            if (!smarts_mode)
                _writeAtom(v_idx, _atoms[v_idx].aromatic, _atoms[v_idx].lowercase, _atoms[v_idx].chirality);
            else if (_qmol != 0)
                _writeSmartsAtom(v_idx, &_qmol->getAtom(v_idx), _atoms[v_idx].chirality, 0, false);
            else
                throw Error(""SMARTS format availble for query only"");

            QS_DEF(Array<int>, closing);

            walk.getNeighborsClosing(v_idx, closing);

            for (int ap = 1; ap <= _bmol->attachmentPointCount(); ap++)
            {
                int idx = 0, atom_idx;

                for (idx = 0; (atom_idx = _bmol->getAttachmentPoint(ap, idx)) != -1; idx++)
                    if (atom_idx == v_idx)
                    {
                        // Here is the problem: if we have an attachment point, the resulting
                        // SMILES is supposed to contain an extra atom not present in the given
                        // molecule. For example, chlorine with an attachment point will
                        // become Cl%91.[*:1]%91 |;_AP1| (two atoms).
                        // We can not modify the given molecule, but we want the closure to
                        // be here. To achieve that, we add a link to an imagimary atom with
                        // incredibly big number.
                        closing.push(10000 + ap);
                    }
            }

            for (j = 0; j < closing.size(); j++)
            {
                bool ap = (closing[j] >= 10000);
                bool rsite = !ap && (separate_rsites && _bmol->isRSite(closing[j]));

                if (ap || rsite)
                {
                    cycle_numbers.expandFill(rsites_closures_starting_num + 1, -1);
                    for (k = rsites_closures_starting_num; k < cycle_numbers.size(); k++)
                        if (cycle_numbers[k] == -1)
                            break;
                }
                else
                {
                    for (k = 1; k < cycle_numbers.size(); k++)
                        if (cycle_numbers[k] == -1)
                            break;
                }

                if (ap)
                {
                    _attachment_indices.push(closing[j] - 10000);
                    _attachment_cycle_numbers.push(k);
                }

                if (k == cycle_numbers.size())
                    cycle_numbers.push(v_idx);
                else
                    cycle_numbers[k] = v_idx;

                _writeCycleNumber(k);
            }

            if (_atoms[v_idx].starts_polymer)
                _output.writeString(""{-}"");
            if (_atoms[v_idx].ends_polymer)
                _output.writeString(""{+n}"");
        }
    }

    if (write_extra_info)
    {
        // Before we write the |...| block (ChemAxon's Extended SMILES),
        // we must clean up the mess we did with the attachment points
        // (see big comment above). That is, we append separated atoms,
        // not present in the original molecule, to the end, and connect
        // them with the ""cycle"" closure to the real atoms that are the
        // attachment points.
        for (i = 0; i < _attachment_indices.size(); i++)
        {
            _output.printf("".[*:%d]"", _attachment_indices[i]);
            _writeCycleNumber(_attachment_cycle_numbers[i]);
        }

        _comma = false;
        _writeRingCisTrans();
        _writeStereogroups();
        _writeRadicals();
        _writePseudoAtoms();
        _writeHighlighting();
        _writeRGroups();

        if (_comma)
            _output.writeChar('|');
    }
}

bool SmilesSaver::_shouldWriteAromaticBond(int e_idx)
{
    const Edge& edge = _bmol->getEdge(e_idx);

    if (_mol == 0)
        return true;

    if (!_atoms[edge.beg].lowercase || !_atoms[edge.end].lowercase)
        return true;

    if (_bmol->getBondTopology(e_idx) != TOPOLOGY_RING)
        return true;

    return false;
}

void SmilesSaver::_writeCycleNumber(int n) const
{
    if (n > 0 && n < 10)
        _output.printf(""%d"", n);
    else if (n >= 10 && n < 100)
        _output.printf(""%%%2d"", n);
    else
        throw Error(""bad cycle number: %d"", n);
}

void SmilesSaver::_writeAtom(int idx, bool aromatic, bool lowercase, int chirality) const
{
    int i;
    bool need_brackets = false;
    int hydro = -1;
    int aam = 0;

    if (_bmol->isRSite(idx))
    {
        if (rsite_indices_as_aam && _bmol->getRSiteBits(idx) != 0)
        {
            QS_DEF(Array<int>, allowed_rgroups);
            _bmol->getAllowedRGroups(idx, allowed_rgroups);
            _output.printf(""[*:%d]"", allowed_rgroups[0]);
        }
        else
            _output.printf(""[*]"");

        return;
    }

    int atom_number = _bmol->getAtomNumber(idx);
    int charge = _bmol->getAtomCharge(idx);
    int isotope = _bmol->getAtomIsotope(idx);

    if (charge == CHARGE_UNKNOWN)
        charge = 0;

    if (_bmol->isPseudoAtom(idx)) // pseudo-atom
    {
        if ((chirality == 0) && (charge == 0))
            _output.printf(""*"");
        else
        {
            _output.printf(""[*"");
            _writeChirality(chirality);
            _writeCharge(charge);
            _output.printf(""]"");
        }

        return;
    }

    if (atom_number < 1)
    {
        if (_qmol != 0)
        {
            // Check special atom
            if (QueryMolecule::queryAtomIsSpecial(*_qmol, idx))
            {
                _output.printf(""*"");
                return;
            }

            // Check for !H meaning any atom in SMILES
            int value;
            if (_qmol->getAtom(idx).sureValueInv(QueryMolecule::ATOM_NUMBER, value))
            {
                if (value == ELEM_H)
                {
                    if ((chirality == 0) && (charge == 0))
                        _output.printf(""*"");
                    else
                    {
                        _output.printf(""[*"");
                        _writeChirality(chirality);
                        _writeCharge(charge);
                        _output.printf(""]"");
                    }
                    return;
                }
            }
            // Check atom list

            QS_DEF(Array<int>, list);

            int query_atom_type;
            if ((query_atom_type = QueryMolecule::parseQueryAtom(*_qmol, idx, list)) != -1)
            {
                if (list.size() > 0)
                    throw Error(""atom list can be used only with smarts_mode"");
            }
        }

        throw Error(""undefined atom number"");
    }

    if (inside_rsmiles)
        aam = _bmol->reaction_atom_mapping[idx];

    if (atom_number != ELEM_C && atom_number != ELEM_P && atom_number != ELEM_N && atom_number != ELEM_S && atom_number != ELEM_O && atom_number != ELEM_Cl &&
        atom_number != ELEM_F && atom_number != ELEM_Br && atom_number != ELEM_B && atom_number != ELEM_I)
        need_brackets = true;

    if (chirality > 0 || charge != 0 || isotope > 0 || aam > 0)
        need_brackets = true;

    // Ignored hydrogens will be converted to implicit hydrogens.
    // So number of ignored hydrogens should be passed into
    // shouldWriteHCount to save correctly [H]S([H])([H])C
    // as C[SH3] when hydrogens are ignored (as in canonical smiles)
    // instead of getting CS.
    if (_mol != 0)
    {
        if (Molecule::shouldWriteHCountEx(*_mol, idx, _hcount_ignored[idx]))
        {
            hydro = _hcount[idx];
            if (hydro < 0 && !ignore_invalid_hcount && need_brackets)
            {
                // This function will throw better error message with a description
                _mol->getImplicitH(idx);
                // If not error was thrown then throw it explicitly
                throw Error(""unsure hydrogen count on atom #%d"", idx);
            }
        }
    }
    else if (_qmol != 0)
    {
        // For query molecules write hydrogens if is was specified
        hydro = _hcount[idx];
    }
    if (_qmol != 0)
        _qmol->getAtom(idx).sureValue(QueryMolecule::ATOM_TOTAL_H, hydro);

    if (hydro >= 0)
        need_brackets = true;

    if (need_brackets)
    {
        // Check sure number of hydrogens only for the ordinary molecule
        if (hydro == -1 && _mol != 0)
        {
            hydro = _hcount[idx];

            if (hydro < 0 && !ignore_invalid_hcount)
                throw Error(""unsure hydrogen count on atom #%d"", idx);
        }
        if (chirality > 0 && hydro > 1)
        {
            if (charge != 0 || isotope > 0 || aam > 0)
                _output.writeChar('[');
            else
                need_brackets = false;
        }
        else
            _output.writeChar('[');
    }

    if (isotope > 0)
        _output.printf(""%d"", isotope);

    const char* elem = Element::toString(atom_number);

    if (lowercase)
    {
        for (i = 0; i < (int)strlen(elem); i++)
            _output.printf(""%c"", tolower(elem[i]));
    }
    else
        _output.printf(""%s"", elem);

    if (!need_brackets)
        return;

    if (hydro < 2)
        _writeChirality(chirality);

    if (hydro > 1)
        _output.printf(""H%d"", hydro);
    else if (hydro == 1)
        _output.printf(""H"");

    _writeCharge(charge);

    if (aam > 0)
        _output.printf("":%d"", aam);

    if (need_brackets)
        _output.writeChar(']');
}

void SmilesSaver::_writeChirality(int chirality) const
{
    if (chirality > 0)
    {
        if (chirality == 1)
            _output.printf(""@"");
        else // chirality == 2
            _output.printf(""@@"");
    }
}

void SmilesSaver::_writeCharge(int charge) const
{
    if (charge > 1)
        _output.printf(""+%d"", charge);
    else if (charge < -1)
        _output.printf(""-%d"", -charge);
    else if (charge == 1)
        _output.printf(""+"");
    else if (charge == -1)
        _output.printf(""-"");
}

void SmilesSaver::_writeSmartsAtom(int idx, QueryMolecule::Atom* atom, int chirality, int depth, bool has_or_parent) const
{
    int i;

    if (depth == 0)
        _output.printf(""["");

    switch (atom->type)
    {
    case QueryMolecule::OP_NOT: {
        _output.writeChar('!');
        _writeSmartsAtom(idx, (QueryMolecule::Atom*)atom->children[0], chirality, depth + 1, has_or_parent);
        break;
    }
    case QueryMolecule::OP_AND: {
        for (i = 0; i < atom->children.size(); i++)
        {
            if (i > 0)
                _output.writeChar(has_or_parent ? '&' : ';');
            _writeSmartsAtom(idx, (QueryMolecule::Atom*)atom->children[i], chirality, depth + 1, has_or_parent);
        }
        break;
    }
    case QueryMolecule::OP_OR: {
        for (i = 0; i < atom->children.size(); i++)
        {
            if (i > 0)
                _output.printf("","");
            _writeSmartsAtom(idx, (QueryMolecule::Atom*)atom->children[i], chirality, depth + 1, true);
        }
        break;
    }
    case QueryMolecule::ATOM_ISOTOPE:
        _output.printf(""%d"", atom->value_max);
        break;
    case QueryMolecule::ATOM_NUMBER: {
        _output.printf(""#%d"", atom->value_max);
        if (chirality == 1)
            _output.printf(""@"");
        else if (chirality == 2)
            _output.printf(""@@"");

        if (chirality > 0 || _bmol->getAtomRadical_NoThrow(idx, 0) > 0)
        {
            int hydro = _bmol->getAtomTotalH(idx);

            if (hydro > 1)
                _output.printf(""H%d"", hydro);
            else if (hydro == 1)
                _output.printf(""H"");
        }

        int aam = _bmol->reaction_atom_mapping[idx];

        if (aam > 0)
            _output.printf("":%d"", aam);

        break;
    }
    case QueryMolecule::ATOM_CHARGE: {
        int charge = atom->value_max;

        if (charge > 1)
            _output.printf(""+%d"", charge);
        else if (charge < -1)
            _output.printf(""-%d"", -charge);
        else if (charge == 1)
            _output.printf(""+"");
        else if (charge == -1)
            _output.printf(""-"");
        break;
    }
    case QueryMolecule::ATOM_FRAGMENT: {
        if (atom->fragment->fragment_smarts.ptr() == 0)
            throw Error(""fragment_smarts has unexpectedly gone"");
        _output.printf(""$(%s)"", atom->fragment->fragment_smarts.ptr());
        break;
    }
    case QueryMolecule::ATOM_AROMATICITY: {
        if (atom->value_min == ATOM_AROMATIC)
            _output.printf(""a"");
        else
            _output.printf(""A"");
        break;
    }
    case QueryMolecule::OP_NONE:
        _output.writeChar('*');
        break;
    case QueryMolecule::ATOM_TOTAL_H: {
        int hydro = atom->value_min;

        if (hydro > 1)
            _output.printf(""H%d"", hydro);
        else if (hydro == 1)
            _output.printf(""H"");
        break;
    }
    default:;
    }

    if (depth == 0)
        _output.writeChar(']');
}

void SmilesSaver::_writeSmartsBond(int idx, QueryMolecule::Bond* bond, bool has_or_parent) const
{
    int i;

    int qb = QueryMolecule::getQueryBondType(*bond);

    if (qb == QueryMolecule::QUERY_BOND_SINGLE_OR_DOUBLE)
    {
        _output.writeString(""-,="");
        return;
    }

    switch (bond->type)
    {
    case QueryMolecule::OP_NONE:
        _output.writeChar('~');
        break;
    case QueryMolecule::OP_NOT: {
        _output.writeChar('!');
        _writeSmartsBond(idx, (QueryMolecule::Bond*)bond->children[0], has_or_parent);
        break;
    }
    case QueryMolecule::OP_OR: {
        for (i = 0; i < bond->children.size(); i++)
        {
            if (i > 0)
                _output.printf("","");
            _writeSmartsBond(idx, (QueryMolecule::Bond*)bond->children[i], true);
        }
        break;
    }
    case QueryMolecule::OP_AND: {
        for (i = 0; i < bond->children.size(); i++)
        {
            if (i > 0)
                _output.writeChar(has_or_parent ? '&' : ';');
            _writeSmartsBond(idx, (QueryMolecule::Bond*)bond->children[i], has_or_parent);
        }
        break;
    }
    case QueryMolecule::BOND_ORDER: {
        int bond_order = bond->value;

        if (bond_order == BOND_SINGLE)
            _output.writeChar('-');
        if (bond_order == BOND_DOUBLE)
            _output.writeChar('=');
        else if (bond_order == BOND_TRIPLE)
            _output.writeChar('#');
        else if (bond_order == BOND_AROMATIC)
            _output.writeChar(':');
        break;
    }
    default:;
    }
}

void SmilesSaver::_banSlashes()
{
    QS_DEF(Array<int>, slashes);
    BaseMolecule& mol = *_bmol;
    int i, j;

    slashes.clear_resize(mol.edgeEnd());
    slashes.zerofill();

    // mark bonds that are are about to be written as slashes
    for (i = mol.edgeBegin(); i != mol.edgeEnd(); i = mol.edgeNext(i))
    {
        // those are only chain cis-trans bonds
        if (_cis_trans_parity[i] != 0)
        {
            const Vertex& beg = mol.getVertex(mol.getEdge(i).beg);
            const Vertex& end = mol.getVertex(mol.getEdge(i).end);

            if (mol.getEdgeTopology(i) == TOPOLOGY_CHAIN)
            {
                for (j = beg.neiBegin(); j != beg.neiEnd(); j = beg.neiNext(j))
                    if (mol.getBondOrder(beg.neiEdge(j)) == BOND_SINGLE)
                        slashes[beg.neiEdge(j)] = 1;

                for (j = end.neiBegin(); j != end.neiEnd(); j = end.neiNext(j))
                    if (mol.getBondOrder(end.neiEdge(j)) == BOND_SINGLE)
                        slashes[end.neiEdge(j)] = 1;
            }
            else
            {
                // Do not write slashes in rings till it is not fixed
                for (j = beg.neiBegin(); j != beg.neiEnd(); j = beg.neiNext(j))
                    if (mol.getBondOrder(beg.neiEdge(j)) == BOND_SINGLE)
                        _ban_slashes[beg.neiEdge(j)] = 1;

                for (j = end.neiBegin(); j != end.neiEnd(); j = end.neiNext(j))
                    if (mol.getBondOrder(end.neiEdge(j)) == BOND_SINGLE)
                        _ban_slashes[end.neiEdge(j)] = 1;
            }
        }
    }

    // find if any ""potentially but not actively cis-trans"" or ring cis-trans bond will be affected
    // by the slashes
    for (i = mol.edgeBegin(); i != mol.edgeEnd(); i = mol.edgeNext(i))
    {
        if (!mol.cis_trans.isGeomStereoBond(mol, i, 0, false))
            continue;

        if (mol.getEdgeTopology(i) == TOPOLOGY_RING || _cis_trans_parity[i] == 0)
        {
            const Vertex& beg = mol.getVertex(mol.getEdge(i).beg);
            const Vertex& end = mol.getVertex(mol.getEdge(i).end);
            bool slash_beg = false;
            bool slash_end = false;

            for (j = beg.neiBegin(); j != beg.neiEnd(); j = beg.neiNext(j))
                if (slashes[beg.neiEdge(j)])
                {
                    slash_beg = true;
                    break;
                }

            for (j = end.neiBegin(); j != end.neiEnd(); j = end.neiNext(j))
                if (slashes[end.neiEdge(j)])
                {
                    slash_end = true;
                    break;
                }

            if (!slash_beg || !slash_end)
                // the bond will not be affected by slashes (at lest, not both sides of it)
                continue;

            for (j = beg.neiBegin(); j != beg.neiEnd(); j = beg.neiNext(j))
                if (slashes[beg.neiEdge(j)])
                    _ban_slashes[beg.neiEdge(j)] = 1;

            for (j = end.neiBegin(); j != end.neiEnd(); j = end.neiNext(j))
                if (slashes[end.neiEdge(j)])
                    _ban_slashes[end.neiEdge(j)] = 1;
        }
    }
}

void SmilesSaver::_filterCisTransParity()
{
    BaseMolecule& mol = *_bmol;

    for (int i = mol.edgeBegin(); i != mol.edgeEnd(); i = mol.edgeNext(i))
    {
        const Edge& edge = mol.getEdge(i);

        if (mol.cis_trans.getParity(i) != 0)
        {
            const Vertex& beg = mol.getVertex(edge.beg);
            const Vertex& end = mol.getVertex(edge.end);

            // Aromatic bonds can not be cis or trans. That is a limitation of the SMILES syntax.
            // Structures like N1\\C=C/N\\C=C/C=C/C=C\\C=C\\1, when aromatized,
            // become SMILES like c1cccc[nH]cc[nH]ccc1, and the cis-trans info is lost.

            // Rare structures like C1C=NC2=C1C=C(S2=CC3=CC=CN3)C(=O)[O-] (CID 17932462),
            // which have cis-trans double bond attached to an aromatic ring, lose the
            // cis-trans information too (although Marvin works that around saving to
            // N#Cc1cc2CC=Nc2\\s1=C/c1ccc[nH]1).

            bool have_singlebond_beg = false, have_singlebond_end = false;
            //         bool have_allowed_singlebond_beg = false, have_allowed_singlebond_end = false;

            for (int j = beg.neiBegin(); j != beg.neiEnd(); j = beg.neiNext(j))
            {
                if (_ignored_vertices[beg.neiVertex(j)])
                    continue;
                int idx = beg.neiEdge(j);

                if (idx != i && mol.getBondOrder(idx) == BOND_SINGLE)
                    have_singlebond_beg = true;
            }

            for (int j = end.neiBegin(); j != end.neiEnd(); j = end.neiNext(j))
            {
                if (_ignored_vertices[end.neiVertex(j)])
                    continue;
                int idx = end.neiEdge(j);

                if (idx != i && mol.getBondOrder(idx) == BOND_SINGLE)
                    have_singlebond_end = true;
            }

            if (!have_singlebond_beg || !have_singlebond_end)
                continue;

            if (mol.getBondTopology(i) == TOPOLOGY_RING)
            {
                // But cis-trans bonds can have only rings with size more then 7:
                // C1=C\\C=C/C=C/C=C\\1
                // C1=CC=CC=CC=C1
                // C1=C/C=C\\C=C/C=C\\1
                if (mol.edgeSmallestRingSize(i) <= 7)
                    continue;
            }

            // This bond will be saved as cis-trans
            _cis_trans_parity[i] = mol.cis_trans.getParity(i);
        }
    }
}

void SmilesSaver::_markCisTrans()
{
    BaseMolecule& mol = *_bmol;
    int i, j;

    _dbonds.clear_resize(mol.edgeEnd());

    for (i = mol.edgeBegin(); i != mol.edgeEnd(); i = mol.edgeNext(i))
    {
        _dbonds[i].ctbond_beg = -1;
        _dbonds[i].ctbond_end = -1;
        _dbonds[i].saved = 0;
    }

    _filterCisTransParity();

    if (!mol.cis_trans.exists())
        return;

    _banSlashes();

    for (i = mol.edgeBegin(); i != mol.edgeEnd(); i = mol.edgeNext(i))
    {
        const Edge& edge = mol.getEdge(i);

        if (_cis_trans_parity[i] != 0)
        {
            // This cis-trans bond has already been filtered in _filterCisTransParity
            // and we have to write cis-trans infromation for this bond
            const Vertex& beg = mol.getVertex(edge.beg);
            const Vertex& end = mol.getVertex(edge.end);

            bool have_allowed_singlebond_beg = false, have_allowed_singlebond_end = false;

            for (j = beg.neiBegin(); j != beg.neiEnd(); j = beg.neiNext(j))
            {
                if (_ignored_vertices[beg.neiVertex(j)])
                    continue;
                int idx = beg.neiEdge(j);

                if (idx != i && mol.getBondOrder(idx) == BOND_SINGLE)
                {
                    if (!_ban_slashes[idx])
                        have_allowed_singlebond_beg = true;
                }
            }

            for (j = end.neiBegin(); j != end.neiEnd(); j = end.neiNext(j))
            {
                if (_ignored_vertices[end.neiVertex(j)])
                    continue;
                int idx = end.neiEdge(j);

                if (idx != i && mol.getBondOrder(idx) == BOND_SINGLE)
                {
                    if (!_ban_slashes[idx])
                        have_allowed_singlebond_end = true;
                }
            }

            if (!have_allowed_singlebond_beg || !have_allowed_singlebond_end)
            {
                _complicated_cistrans[i] = 1;
                _have_complicated_cistrans = true;
                continue;
            }

            for (j = beg.neiBegin(); j != beg.neiEnd(); j = beg.neiNext(j))
            {
                if (_ignored_vertices[beg.neiVertex(j)])
                    continue;
                int idx = beg.neiEdge(j);

                if (idx != i)
                {
                    if (mol.getEdge(idx).beg == edge.beg)
                        _dbonds[idx].ctbond_beg = i;
                    else
                        _dbonds[idx].ctbond_end = i;
                }
            }

            for (j = end.neiBegin(); j != end.neiEnd(); j = end.neiNext(j))
            {
                if (_ignored_vertices[end.neiVertex(j)])
                    continue;
                int idx = end.neiEdge(j);

                if (idx != i)
                {
                    if (mol.getEdge(idx).beg == edge.end)
                        _dbonds[idx].ctbond_beg = i;
                    else
                        _dbonds[idx].ctbond_end = i;
                }
            }
        }
    }
}

bool SmilesSaver::_updateSideBonds(int bond_idx)
{
    BaseMolecule& mol = *_bmol;
    const Edge& edge = mol.getEdge(bond_idx);
    int subst[4];

    mol.cis_trans.getSubstituents_All(bond_idx, subst);
    int parity = _cis_trans_parity[bond_idx];

    int sidebonds[4] = {-1, -1, -1, -1};

    sidebonds[0] = mol.findEdgeIndex(subst[0], edge.beg);
    if (subst[1] != -1)
        sidebonds[1] = mol.findEdgeIndex(subst[1], edge.beg);

    sidebonds[2] = mol.findEdgeIndex(subst[2], edge.end);
    if (subst[3] != -1)
        sidebonds[3] = mol.findEdgeIndex(subst[3], edge.end);

    int n1 = 0, n2 = 0, n3 = 0, n4 = 0;

    if (_dbonds[sidebonds[0]].saved != 0)
    {
        if ((_dbonds[sidebonds[0]].saved == 1 && mol.getEdge(sidebonds[0]).beg == edge.beg) ||
            (_dbonds[sidebonds[0]].saved == 2 && mol.getEdge(sidebonds[0]).end == edge.beg))
            n1++;
        else
            n2++;
    }
    if (sidebonds[1] != -1 && _dbonds[sidebonds[1]].saved != 0)
    {
        if ((_dbonds[sidebonds[1]].saved == 2 && mol.getEdge(sidebonds[1]).beg == edge.beg) ||
            (_dbonds[sidebonds[1]].saved == 1 && mol.getEdge(sidebonds[1]).end == edge.beg))
            n1++;
        else
            n2++;
    }
    if (_dbonds[sidebonds[2]].saved != 0)
    {
        if ((_dbonds[sidebonds[2]].saved == 1 && mol.getEdge(sidebonds[2]).beg == edge.end) ||
            (_dbonds[sidebonds[2]].saved == 2 && mol.getEdge(sidebonds[2]).end == edge.end))
            n3++;
        else
            n4++;
    }
    if (sidebonds[3] != -1 && _dbonds[sidebonds[3]].saved != 0)
    {
        if ((_dbonds[sidebonds[3]].saved == 2 && mol.getEdge(sidebonds[3]).beg == edge.end) ||
            (_dbonds[sidebonds[3]].saved == 1 && mol.getEdge(sidebonds[3]).end == edge.end))
            n3++;
        else
            n4++;
    }

    if (parity == MoleculeCisTrans::CIS)
    {
        n1 += n3;
        n2 += n4;
    }
    else
    {
        n1 += n4;
        n2 += n3;
    }

    if (n1 > 0 && n2 > 0)
        throw Error(""incompatible cis-trans configuration"");

    if (n1 == 0 && n2 == 0)
        return false;

    if (n1 > 0)
    {
        _dbonds[sidebonds[0]].saved = (mol.getEdge(sidebonds[0]).beg == edge.beg) ? 1 : 2;

        if (sidebonds[1] != -1)
            _dbonds[sidebonds[1]].saved = (mol.getEdge(sidebonds[1]).beg == edge.beg) ? 2 : 1;

        _dbonds[sidebonds[2]].saved = ((mol.getEdge(sidebonds[2]).beg == edge.end) == (parity == MoleculeCisTrans::CIS)) ? 1 : 2;

        if (sidebonds[3] != -1)
            _dbonds[sidebonds[3]].saved = ((mol.getEdge(sidebonds[3]).beg == edge.end) == (parity == MoleculeCisTrans::CIS)) ? 2 : 1;
    }
    if (n2 > 0)
    {
        _dbonds[sidebonds[0]].saved = (mol.getEdge(sidebonds[0]).beg == edge.beg) ? 2 : 1;

        if (sidebonds[1] != -1)
            _dbonds[sidebonds[1]].saved = (mol.getEdge(sidebonds[1]).beg == edge.beg) ? 1 : 2;

        _dbonds[sidebonds[2]].saved = ((mol.getEdge(sidebonds[2]).beg == edge.end) == (parity == MoleculeCisTrans::CIS)) ? 2 : 1;

        if (sidebonds[3] != -1)
            _dbonds[sidebonds[3]].saved = ((mol.getEdge(sidebonds[3]).beg == edge.end) == (parity == MoleculeCisTrans::CIS)) ? 1 : 2;
    }

    return true;
}

int SmilesSaver::_calcBondDirection(int idx, int vprev)
{
    BaseMolecule& mol = *_bmol;
    int i, ntouched;
    int ctbond_beg = _dbonds[idx].ctbond_beg;
    int ctbond_end = _dbonds[idx].ctbond_end;

    if (ctbond_beg == -1 && ctbond_end == -1)
        return 0;

    if (mol.getBondOrder(idx) != BOND_SINGLE)
        throw Error(""internal: directed bond order %d"", mol.getBondOrder(idx));

    while (1)
    {
        ntouched = 0;
        for (i = mol.edgeBegin(); i != mol.edgeEnd(); i = mol.edgeNext(i))
            if (_cis_trans_parity[i] != 0 && mol.getEdgeTopology(i) == TOPOLOGY_CHAIN)
            {
                if (_updateSideBonds(i))
                    ntouched++;
            }
        if (ntouched == _touched_cistransbonds)
            break;
        _touched_cistransbonds = ntouched;
    }

    if (_dbonds[idx].saved == 0)
    {
        if (vprev == mol.getEdge(idx).beg)
            _dbonds[idx].saved = 1;
        else
            _dbonds[idx].saved = 2;
    }

    return _dbonds[idx].saved;
}

void SmilesSaver::_startExtension()
{
    if (_comma)
        _output.writeChar(',');
    else
    {
        _output.writeString("" |"");
        _comma = true;
    }
}

void SmilesSaver::_writeStereogroups()
{
    BaseMolecule& mol = *_bmol;
    MoleculeStereocenters& stereocenters = mol.stereocenters;
    int i, j;

    for (i = stereocenters.begin(); i != stereocenters.end(); i = stereocenters.next(i))
    {
        int atom, type, group;
        stereocenters.get(i, atom, type, group, 0);

        if (type != MoleculeStereocenters::ATOM_ABS)
            break;
    }

    if (i == stereocenters.end())
        return;

    int and_group_idx = 1;
    int or_group_idx = 1;

    QS_DEF(Array<int>, marked);

    marked.clear_resize(_written_atoms.size());
    marked.zerofill();

    for (i = 0; i < _written_atoms.size(); i++)
    {
        if (marked[i])
            continue;

        int type = stereocenters.getType(_written_atoms[i]);

        if (type == MoleculeStereocenters::ATOM_ANY)
        {
            _startExtension();
            _output.printf(""w:%d"", i);

            for (j = i + 1; j < _written_atoms.size(); j++)
                if (stereocenters.getType(_written_atoms[j]) == MoleculeStereocenters::ATOM_ANY)
                {
                    marked[j] = 1;
                    _output.printf("",%d"", j);
                }
        }
        else
        {
            if (type == MoleculeStereocenters::ATOM_ABS)
            {
                _startExtension();
                _output.printf(""a:%d"", i);

                for (j = i + 1; j < _written_atoms.size(); j++)
                    if (stereocenters.getType(_written_atoms[j]) == MoleculeStereocenters::ATOM_ABS)
                    {
                        marked[j] = 1;
                        _output.printf("",%d"", j);
                    }
            }
            else if (type == MoleculeStereocenters::ATOM_AND)
            {
                int group = stereocenters.getGroup(_written_atoms[i]);

                _startExtension();
                _output.printf(""&%d:%d"", and_group_idx++, i);
                for (j = i + 1; j < _written_atoms.size(); j++)
                    if (stereocenters.getType(_written_atoms[j]) == MoleculeStereocenters::ATOM_AND && stereocenters.getGroup(_written_atoms[j]) == group)
                    {
                        marked[j] = 1;
                        _output.printf("",%d"", j);
                    }
            }
            else if (type == MoleculeStereocenters::ATOM_OR)
            {
                int group = stereocenters.getGroup(_written_atoms[i]);

                _startExtension();
                _output.printf(""o%d:%d"", or_group_idx++, i);
                for (j = i + 1; j < _written_atoms.size(); j++)
                    if (stereocenters.getType(_written_atoms[j]) == MoleculeStereocenters::ATOM_OR && stereocenters.getGroup(_written_atoms[j]) == group)
                    {
                        marked[j] = 1;
                        _output.printf("",%d"", j);
                    }
            }
        }
    }

    if (!mol.isChiral())
        _output.printf("",r"");
}

void SmilesSaver::_writeRadicals()
{
    BaseMolecule& mol = *_bmol;
    QS_DEF(Array<int>, marked);
    int i, j;

    marked.clear_resize(_written_atoms.size());
    marked.zerofill();

    for (i = 0; i < _written_atoms.size(); i++)
    {
        if (marked[i] || mol.isRSite(_written_atoms[i]) || mol.isPseudoAtom(_written_atoms[i]))
            continue;

        int radical = mol.getAtomRadical_NoThrow(_written_atoms[i], 0);

        if (radical <= 0)
            continue;

        _startExtension();

        if (radical == RADICAL_SINGLET)
            _output.writeString(""^3:"");
        else if (radical == RADICAL_DOUBLET)
            _output.writeString(""^1:"");
        else // RADICAL_TRIPLET
            _output.writeString(""^4:"");

        _output.printf(""%d"", i);

        for (j = i + 1; j < _written_atoms.size(); j++)
        {
            if (mol.isPseudoAtom(_written_atoms[j]) || mol.isRSite(_written_atoms[j]))
                continue;
            if (mol.getAtomRadical_NoThrow(_written_atoms[j], 0) == radical)
            {
                marked[j] = 1;
                _output.printf("",%d"", j);
            }
        }
    }
}

void SmilesSaver::_writePseudoAtoms()
{
    BaseMolecule& mol = *_bmol;

    int i;

    if (_attachment_indices.size() == 0)
    {
        for (i = 0; i < _written_atoms.size(); i++)
        {
            if (mol.isPseudoAtom(_written_atoms[i]) || (mol.isRSite(_written_atoms[i]) && mol.getRSiteBits(_written_atoms[i]) != 0))
                break;
            if (_qmol != 0)
            {
                if (QueryMolecule::queryAtomIsSpecial(*_qmol, _written_atoms[i]))
                {
                    break;
                }
            }
        }

        if (i == _written_atoms.size())
            return;
    }

    _startExtension();

    _output.writeChar('$');

    for (i = 0; i < _written_atoms.size(); i++)
    {
        if (i > 0)
            _output.writeChar(';');

        if (mol.isPseudoAtom(_written_atoms[i]))
            writePseudoAtom(mol.getPseudoAtom(_written_atoms[i]), _output);
        else if (mol.isRSite(_written_atoms[i]) && mol.getRSiteBits(_written_atoms[i]) != 0)
        // ChemAxon's Extended SMILES notation for R-sites
        // and added support of multiple R-groups on one R-site
        {
            QS_DEF(Array<int>, allowed_rgroups);
            mol.getAllowedRGroups(_written_atoms[i], allowed_rgroups);
            for (int j = 0; j < allowed_rgroups.size(); j++)
            {
                _output.printf(""_R%d"", allowed_rgroups[j]);
                if (j < allowed_rgroups.size() - 1)
                    _output.printf("","");
            }
        }
        else if ((_qmol != 0) && (QueryMolecule::queryAtomIsSpecial(*_qmol, _written_atoms[i])))
            writeSpecialAtom(_written_atoms[i], _output);
    }

    for (i = 0; i < _attachment_indices.size(); i++)
        // ChemAxon's Extended SMILES notation for attachment points
        _output.printf("";_AP%d"", _attachment_indices[i]);

    _output.writeChar('$');
}

void SmilesSaver::writePseudoAtom(const char* label, Output& out)
{
    if (*label == 0)
        throw Error(""empty pseudo-atom"");

    do
    {
        if (*label == '\\n' || *label == '\\r' || *label == '\\t')
            throw Error(""character 0x%x is not allowed inside pseudo-atom"", *label);
        if (*label == '$' || *label == ';')
            throw Error(""'%c' not allowed inside pseudo-atom"", *label);

        out.writeChar(*label);
    } while (*(++label) != 0);
    //   out.writeString(""_p"");
}

void SmilesSaver::writeSpecialAtom(int aid, Output& out)
{
    QS_DEF(Array<int>, list);
    int query_atom_type;

    query_atom_type = QueryMolecule::parseQueryAtom(*_qmol, aid, list);
    if (query_atom_type == QueryMolecule::QUERY_ATOM_Q)
        out.writeString(""Q_e"");
    else if (query_atom_type == QueryMolecule::QUERY_ATOM_X)
        out.writeString(""X_p"");
    else if (query_atom_type == QueryMolecule::QUERY_ATOM_M)
        out.writeString(""M_p"");
    else if (query_atom_type == QueryMolecule::QUERY_ATOM_AH)
        out.writeString(""AH_p"");
    else if (query_atom_type == QueryMolecule::QUERY_ATOM_QH)
        out.writeString(""QH_p"");
    else if (query_atom_type == QueryMolecule::QUERY_ATOM_XH)
        out.writeString(""XH_p"");
    else if (query_atom_type == QueryMolecule::QUERY_ATOM_MH)
        out.writeString(""MH_p"");
}

void SmilesSaver::_writeHighlighting()
{
    if (!_bmol->hasHighlighting())
        return;

    int i;

    bool ha = false;

    for (i = 0; i < _written_atoms.size(); i++)
    {
        if (_bmol->isAtomHighlighted(_written_atoms[i]))
        {
            if (ha)
                _output.writeChar(',');
            else
            {
                _startExtension();
                _output.writeString(""ha:"");
                ha = true;
            }

            _output.printf(""%d"", i);
        }
    }

    bool hb = false;

    for (i = 0; i < _written_bonds.size(); i++)
    {
        if (_bmol->isBondHighlighted(_written_bonds[i]))
        {
            if (hb)
                _output.writeChar(',');
            else
            {
                _startExtension();
                _output.writeString(""hb:"");
                hb = true;
            }

            _output.printf(""%d"", i);
        }
    }
}

void SmilesSaver::_writeRGroups()
{
    if (_bmol->rgroups.getRGroupCount() > 0)
    {
        MoleculeRGroups& rgroups = _bmol->rgroups;
        int n_rgroups = rgroups.getRGroupCount();
        bool first_rg = true;
        bool rlogic_found = false;

        for (int i = 1; i <= n_rgroups; i++)
        {
            RGroup& rgroup = rgroups.getRGroup(i);

            if (rgroup.fragments.size() == 0)
                continue;

            bool empty_fragments = true;
            PtrPool<BaseMolecule>& frags = rgroup.fragments;
            for (int j = frags.begin(); j != frags.end(); j = frags.next(j))
            {
                BaseMolecule* fragment = frags[j];
                if (fragment->vertexCount() > 0)
                    empty_fragments = false;
            }
            if (empty_fragments)
                continue;

            if (first_rg)
            {
                _startExtension();
                _output.writeString(""RG:"");
                first_rg = false;
            }
            _output.printf(""_R%d="", i);

            bool first_fr = true;

            for (int j = frags.begin(); j != frags.end(); j = frags.next(j))
            {
                if (!first_fr)
                    _output.writeString("","");
                else
                    first_fr = false;

                BaseMolecule* fragment = frags[j];
                Array<char> out_buffer;
                ArrayOutput fr_out(out_buffer);

                if (ignore_hydrogens)
                {
                    CanonicalSmilesSaver fr_saver(fr_out);
                    if (_qmol != 0)
                        fr_saver.saveQueryMolecule(fragment->asQueryMolecule());
                    else
                        fr_saver.saveMolecule(fragment->asMolecule());
                }
                else
                {
                    SmilesSaver fr_saver(fr_out);
                    if (_qmol != 0)
                        fr_saver.saveQueryMolecule(fragment->asQueryMolecule());
                    else
                        fr_saver.saveMolecule(fragment->asMolecule());
                }

                _output.writeString(""{"");
                _output.writeArray(out_buffer);
                _output.writeString(""}"");
            }
            if (i < n_rgroups)
                _output.writeString("","");

            if ((rgroup.if_then > 0) || (rgroup.rest_h > 0) || (rgroup.occurrence.size() > 0))
                rlogic_found = true;
        }
        if (rlogic_found)
        {
            _output.writeString("",LOG={"");

            for (int i = 1; i <= n_rgroups; i++)
            {
                if (i > 1)
                    _output.writeString(""."");

                RGroup& rgroup = rgroups.getRGroup(i);
                _output.printf(""_R%d:"", i);

                if (rgroup.if_then > 0)
                    _output.printf(""_R%d;"", rgroup.if_then);
                else
                    _output.printf("";"");

                if (rgroup.rest_h > 0)
                    _output.printf(""H;"");
                else
                    _output.printf("";"");

                if (rgroup.occurrence.size() > 0)
                    _writeOccurrenceRanges(_output, rgroup.occurrence);
            }
            _output.writeString(""}"");
        }
    }
}

void SmilesSaver::_writeOccurrenceRanges(Output& out, const Array<int>& occurrences)
{
    for (int i = 0; i < occurrences.size(); i++)
    {
        int occurrence = occurrences[i];

        if ((occurrence & 0xFFFF) == 0xFFFF)
            out.printf("">%d"", (occurrence >> 16) - 1);
        else if ((occurrence >> 16) == (occurrence & 0xFFFF))
            out.printf(""%d"", occurrence >> 16);
        else if ((occurrence >> 16) == 0)
            out.printf(""<%d"", (occurrence & 0xFFFF) + 1);
        else
            out.printf(""%d-%d"", occurrence >> 16, occurrence & 0xFFFF);

        if (i != occurrences.size() - 1)
            out.printf("","");
    }
}

int SmilesSaver::writtenComponents()
{
    return _written_components;
}

const Array<int>& SmilesSaver::writtenAtoms()
{
    return _written_atoms;
}

const Array<int>& SmilesSaver::writtenBonds()
{
    return _written_bonds;
}

SmilesSaver::_Atom::_Atom(Pool<List<int>::Elem>& neipool) : neighbors(neipool)
{
    aromatic = 0;
    lowercase = false;
    chirality = 0;
    branch_cnt = 0;
    paren_written = false;
    starts_polymer = false;
    ends_polymer = false;

    parent = -1;
}

SmilesSaver::_Atom::~_Atom()
{
}

void SmilesSaver::_checkSRU()
{
    _polymer_indices.clear_resize(_bmol->vertexEnd());
    _polymer_indices.fffill();

    int i, j, k;

    // check overlapping (particularly nested) blocks
    for (i = _bmol->sgroups.begin(); i != _bmol->sgroups.end(); i = _bmol->sgroups.next(i))
    {
        SGroup* sg = &_bmol->sgroups.getSGroup(i);
        if (sg->sgroup_type == SGroup::SG_TYPE_SRU)
        {
            Array<int>& atoms = sg->atoms;

            for (j = 0; j < atoms.size(); j++)
            {
                if (_polymer_indices[atoms[j]] >= 0)
                    throw Error(""overlapping (nested?) repeating units can not be saved"");
                _polymer_indices[atoms[j]] = i;

                // check also disconnected blocks (possible to handle, but unsupported at the moment)
                if (_bmol->vertexComponent(atoms[j]) != _bmol->vertexComponent(atoms[0]))
                    throw Error(""disconnected repeating units not supported"");
            }
        }
    }

    // check that each block has exactly two outgoing bonds
    for (i = _bmol->sgroups.begin(); i != _bmol->sgroups.end(); i = _bmol->sgroups.next(i))
    {
        SGroup* sg = &_bmol->sgroups.getSGroup(i);
        if (sg->sgroup_type == SGroup::SG_TYPE_SRU)
        {
            Array<int>& atoms = sg->atoms;
            int cnt = 0;

            for (j = 0; j < atoms.size(); j++)
            {
                const Vertex& vertex = _bmol->getVertex(atoms[j]);
                for (k = vertex.neiBegin(); k != vertex.neiEnd(); k = vertex.neiNext(k))
                    if (_polymer_indices[vertex.neiVertex(k)] != i)
                        cnt++;
            }
            if (cnt != 2)
                throw Error(""repeating units must have exactly two outgoing bonds, has %d"", cnt);
        }
    }
}

int SmilesSaver::_countRBonds()
{
    int i, sum = 0;

    for (i = _bmol->vertexBegin(); i != _bmol->vertexEnd(); i = _bmol->vertexNext(i))
        if (_bmol->isRSite(i))
            sum += _bmol->getVertex(i).degree();
    return sum;
}

void SmilesSaver::_checkRGroupsAndAttachmentPoints()
{
    _attachment_indices.clear();
    _attachment_cycle_numbers.clear();

    _n_attachment_points = 0;

    for (int i = 1; i <= _bmol->attachmentPointCount(); i++)
        for (int idx = 0; _bmol->getAttachmentPoint(i, idx) != -1; idx++)
            _n_attachment_points++;

    if (_n_attachment_points && !write_extra_info)
        throw Error(""can not write attachment points without permission to write ""
                    ""the Extended SMILES block (probably because you are saving reaction SMILES)"");
}

void SmilesSaver::_writeRingCisTrans()
{
    if (!_have_complicated_cistrans)
        return;

    _startExtension();

    int i, j;

    QS_DEF(Array<int>, cis_bonds);
    QS_DEF(Array<int>, trans_bonds);

    cis_bonds.clear();
    trans_bonds.clear();

    for (i = 0; i < _written_bonds.size(); i++)
    {
        int bond_idx = _written_bonds[i];

        if (!_complicated_cistrans[bond_idx])
            continue;

        int nei_atom_beg = -1, nei_atom_end = -1;

        const Edge& edge = _bmol->getEdge(bond_idx);

        // TODO: a more effective looping is possible
        for (j = 0; j < _written_atoms.size(); j++)
        {
            if (nei_atom_beg == -1)
                if (_written_atoms[j] != edge.end && _bmol->findEdgeIndex(_written_atoms[j], edge.beg) >= 0)
                    nei_atom_beg = _written_atoms[j];
            if (nei_atom_end == -1)
                if (_written_atoms[j] != edge.beg && _bmol->findEdgeIndex(_written_atoms[j], edge.end) >= 0)
                    nei_atom_end = _written_atoms[j];
        }

        if (nei_atom_beg == -1 || nei_atom_end == -1)
            throw Error(""_writeRingCisTrans(): internal"");

        int parity = _cis_trans_parity[bond_idx];

        if (parity == 0 && _mol != 0 && _mol->getAtomRingBondsCount(edge.beg) == 2 && _mol->getAtomRingBondsCount(edge.end) == 2)
        {
            // That is some ""simple"" cis-trans bond, i.e. in a benzene ring.
            // It came unspecified, but we better write it explicitly, not to
            // produce different canonical SMILES for identical structures.
            // We write is as ""cis"" (if both substituents are in a ring),
            // or ""trans"" if one substituent is in a ring  and another is not.
            parity = MoleculeCisTrans::CIS;

            if (_bmol->getEdgeTopology(_bmol->findEdgeIndex(nei_atom_beg, edge.beg)) == TOPOLOGY_CHAIN)
                parity = 3 - parity;
            if (_bmol->getEdgeTopology(_bmol->findEdgeIndex(nei_atom_end, edge.end)) == TOPOLOGY_CHAIN)
                parity = 3 - parity;
        }
        else
        {
            const int* subst = _bmol->cis_trans.getSubstituents(bond_idx);

            if (nei_atom_beg == subst[0])
                ;
            else if (nei_atom_beg == subst[1])
                parity = 3 - parity;
            else
                throw Error(""_writeRingCisTrans(): internal (substituent not found)"");

            if (nei_atom_end == subst[2])
                ;
            else if (nei_atom_end == subst[3])
                parity = 3 - parity;
            else
                throw Error(""_writeRingCisTrans(): internal (substituent not found)"");
        }

        if (parity == MoleculeCisTrans::CIS)
            cis_bonds.push(i);
        else
            trans_bonds.push(i);
    }

    if (cis_bonds.size() != 0)
    {
        _output.printf(""c:%d"", cis_bonds[0]);
        for (i = 1; i < cis_bonds.size(); i++)
            _output.printf("",%d"", cis_bonds[i]);
    }
    if (trans_bonds.size() != 0)
    {
        if (cis_bonds.size() != 0)
            _output.printf("","");

        _output.printf(""t:%d"", trans_bonds[0]);
        for (i = 1; i < trans_bonds.size(); i++)
            _output.printf("",%d"", trans_bonds[i]);
    }
}

const Array<int>& SmilesSaver::getSavedCisTransParities()
{
    return _cis_trans_parity;
}
",16226,True,3093.1315176868206,median
"*&---------------------------------------------------------------------*
*& Report  ZANGRY_BIRDS
*& Just for fun
*&---------------------------------------------------------------------*
*&
*&
*&---------------------------------------------------------------------*

REPORT zangry_birds.

DATA: lo_excel                TYPE REF TO zcl_excel,
      lo_excel_writer         TYPE REF TO zif_excel_writer,
      lo_worksheet            TYPE REF TO zcl_excel_worksheet,
      lo_border_light         TYPE REF TO zcl_excel_style_border,
      lo_style_color0         TYPE REF TO zcl_excel_style,
      lo_style_color1         TYPE REF TO zcl_excel_style,
      lo_style_color2         TYPE REF TO zcl_excel_style,
      lo_style_color3         TYPE REF TO zcl_excel_style,
      lo_style_color4         TYPE REF TO zcl_excel_style,
      lo_style_color5         TYPE REF TO zcl_excel_style,
      lo_style_color6         TYPE REF TO zcl_excel_style,
      lo_style_color7         TYPE REF TO zcl_excel_style,
      lo_style_credit         TYPE REF TO zcl_excel_style,
      lo_style_link           TYPE REF TO zcl_excel_style,
      lo_column               TYPE REF TO zcl_excel_column,
      lo_row                  TYPE REF TO zcl_excel_row,
      lo_hyperlink            TYPE REF TO zcl_excel_hyperlink.

DATA: lv_style_color0_guid    TYPE zexcel_cell_style,
      lv_style_color1_guid    TYPE zexcel_cell_style,
      lv_style_color2_guid    TYPE zexcel_cell_style,
      lv_style_color3_guid    TYPE zexcel_cell_style,
      lv_style_color4_guid    TYPE zexcel_cell_style,
      lv_style_color5_guid    TYPE zexcel_cell_style,
      lv_style_color6_guid    TYPE zexcel_cell_style,
      lv_style_color7_guid    TYPE zexcel_cell_style,
      lv_style_credit_guid    TYPE zexcel_cell_style,
      lv_style_link_guid      TYPE zexcel_cell_style.

DATA: lv_col_str        TYPE zexcel_cell_column_alpha,
      lv_row            TYPE i,
      lv_col            TYPE i,
      lt_mapper         TYPE TABLE OF zexcel_cell_style,
      ls_mapper         TYPE zexcel_cell_style.

DATA: lv_file           TYPE xstring,
      lv_bytecount      TYPE i,
      lt_file_tab       TYPE solix_tab.

DATA: lv_full_path      TYPE string,
      lv_workdir        TYPE string,
      lv_file_separator TYPE c.

CONSTANTS: lv_default_file_name TYPE string VALUE 'angry_birds.xlsx'.

PARAMETERS: p_path TYPE zexcel_export_dir.

AT SELECTION-SCREEN ON VALUE-REQUEST FOR p_path.
  lv_workdir = p_path.
  cl_gui_frontend_services=>directory_browse( EXPORTING initial_folder  = lv_workdir
                                              CHANGING  selected_folder = lv_workdir ).
  p_path = lv_workdir.

INITIALIZATION.
  cl_gui_frontend_services=>get_sapgui_workdir( CHANGING sapworkdir = lv_workdir ).
  cl_gui_cfw=>flush( ).
  p_path = lv_workdir.

START-OF-SELECTION.

  IF p_path IS INITIAL.
    p_path = lv_workdir.
  ENDIF.
  cl_gui_frontend_services=>get_file_separator( CHANGING file_separator = lv_file_separator ).
  CONCATENATE p_path lv_file_separator lv_default_file_name INTO lv_full_path.

  "" Creates active sheet
  CREATE OBJECT lo_excel.

  CREATE OBJECT lo_border_light.
  lo_border_light->border_color-rgb = zcl_excel_style_color=>c_white.
  lo_border_light->border_style = zcl_excel_style_border=>c_border_thin.

  "" Create color white
  lo_style_color0                      = lo_excel->add_new_style( ).
  lo_style_color0->fill->filltype      = zcl_excel_style_fill=>c_fill_solid.
  lo_style_color0->fill->fgcolor-rgb   = 'FFFFFFFF'.
  lo_style_color0->borders->allborders = lo_border_light.
  lv_style_color0_guid                 = lo_style_color0->get_guid( ).

  "" Create color black
  lo_style_color1                      = lo_excel->add_new_style( ).
  lo_style_color1->fill->filltype      = zcl_excel_style_fill=>c_fill_solid.
  lo_style_color1->fill->fgcolor-rgb   = 'FF252525'.
  lo_style_color1->borders->allborders = lo_border_light.
  lv_style_color1_guid                 = lo_style_color1->get_guid( ).

  "" Create color dark green
  lo_style_color2                      = lo_excel->add_new_style( ).
  lo_style_color2->fill->filltype      = zcl_excel_style_fill=>c_fill_solid.
  lo_style_color2->fill->fgcolor-rgb   = 'FF75913A'.
  lo_style_color2->borders->allborders = lo_border_light.
  lv_style_color2_guid                 = lo_style_color2->get_guid( ).

  "" Create color light green
  lo_style_color3                      = lo_excel->add_new_style( ).
  lo_style_color3->fill->filltype      = zcl_excel_style_fill=>c_fill_solid.
  lo_style_color3->fill->fgcolor-rgb   = 'FF9DFB73'.
  lo_style_color3->borders->allborders = lo_border_light.
  lv_style_color3_guid                 = lo_style_color3->get_guid( ).

  "" Create color green
  lo_style_color4                      = lo_excel->add_new_style( ).
  lo_style_color4->fill->filltype      = zcl_excel_style_fill=>c_fill_solid.
  lo_style_color4->fill->fgcolor-rgb   = 'FF92CF56'.
  lo_style_color4->borders->allborders = lo_border_light.
  lv_style_color4_guid                 = lo_style_color4->get_guid( ).

  "" Create color 2dark green
  lo_style_color5                      = lo_excel->add_new_style( ).
  lo_style_color5->fill->filltype      = zcl_excel_style_fill=>c_fill_solid.
  lo_style_color5->fill->fgcolor-rgb   = 'FF506228'.
  lo_style_color5->borders->allborders = lo_border_light.
  lv_style_color5_guid                 = lo_style_color5->get_guid( ).

  "" Create color yellow
  lo_style_color6                      = lo_excel->add_new_style( ).
  lo_style_color6->fill->filltype      = zcl_excel_style_fill=>c_fill_solid.
  lo_style_color6->fill->fgcolor-rgb   = 'FFC3E224'.
  lo_style_color6->borders->allborders = lo_border_light.
  lv_style_color6_guid                 = lo_style_color6->get_guid( ).

  "" Create color yellow
  lo_style_color7                      = lo_excel->add_new_style( ).
  lo_style_color7->fill->filltype      = zcl_excel_style_fill=>c_fill_solid.
  lo_style_color7->fill->fgcolor-rgb   = 'FFB3C14F'.
  lo_style_color7->borders->allborders = lo_border_light.
  lv_style_color7_guid                 = lo_style_color7->get_guid( ).

  "" Credits
  lo_style_credit = lo_excel->add_new_style( ).
  lo_style_credit->alignment->horizontal = zcl_excel_style_alignment=>c_horizontal_center.
  lo_style_credit->alignment->vertical = zcl_excel_style_alignment=>c_vertical_center.
  lo_style_credit->font->size   = 20.
  lv_style_credit_guid = lo_style_credit->get_guid( ).

  "" Link
  lo_style_link = lo_excel->add_new_style( ).
  lo_style_link->alignment->horizontal = zcl_excel_style_alignment=>c_horizontal_center.
  lo_style_link->alignment->vertical = zcl_excel_style_alignment=>c_vertical_center.
*  lo_style_link->font->size   = 20.
  lv_style_link_guid = lo_style_link->get_guid( ).

  "" Create image map                                                          "" line 2
  DO 30 TIMES. APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 3
  DO 28 TIMES. APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 5 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 4
  DO 27 TIMES. APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 5
  DO 9 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 15 TIMES. APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 6 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 6
  DO 7 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 6 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 13 TIMES. APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 7
  DO 6 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 5 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 11 TIMES. APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 5 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 8
  DO 5 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 9 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 6 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 9
  DO 5 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 9 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 10
  DO 4 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 6 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 9 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 11
  DO 4 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 7 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 9 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 12
  DO 4 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 13
  DO 5 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 8 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 14
  DO 5 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 12 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 15
  DO 6 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 8 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color4_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 16
  DO 7 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 7 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color4_guid TO lt_mapper. ENDDO.
  DO 5 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color4_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color4_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 17
  DO 8 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 6 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color4_guid TO lt_mapper. ENDDO.
  DO 13 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color4_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 18
  DO 6 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 23 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color4_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 19
  DO 5 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 27 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 20
  DO 5 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 23 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 21
  DO 4 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 19 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 22
  DO 4 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 17 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 23
  DO 4 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 17 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 8 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 24
  DO 4 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color4_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 10 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 9 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 25
  DO 3 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color4_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 6 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 8 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 6 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 26
  DO 3 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color4_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color6_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 27
  DO 3 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color4_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color6_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 28
  DO 3 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color4_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color6_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 29
  DO 3 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color4_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 5 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 30
  DO 3 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color4_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 31
  DO 3 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color4_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 32
  DO 3 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 8 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 9 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color5_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 33
  DO 3 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 9 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 9 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 34
  DO 3 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 9 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 9 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 10 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 35
  DO 4 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 9 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 6 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 11 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 36
  DO 4 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 10 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 11 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 37
  DO 5 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 10 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color7_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 11 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 38
  DO 6 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 10 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 11 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 39
  DO 7 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 22 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 1 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 40
  DO 7 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 17 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 41
  DO 8 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 3 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 15 TIMES. APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 42
  DO 9 TIMES.  APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 5 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 6 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 9 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 2 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 43
  DO 11 TIMES. APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 6 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 5 TIMES.  APPEND lv_style_color3_guid TO lt_mapper. ENDDO.
  DO 7 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 44
  DO 13 TIMES. APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 6 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  DO 4 TIMES.  APPEND lv_style_color2_guid TO lt_mapper. ENDDO.
  DO 8 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 45
  DO 16 TIMES. APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 13 TIMES. APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape
                                                            "" line 46
  DO 18 TIMES. APPEND lv_style_color0_guid TO lt_mapper. ENDDO.
  DO 8 TIMES.  APPEND lv_style_color1_guid TO lt_mapper. ENDDO.
  APPEND INITIAL LINE TO lt_mapper. "" escape

  "" Get active sheet
  lo_worksheet = lo_excel->get_active_worksheet( ).
  lo_worksheet->set_title( ip_title = 'Angry Birds' ).

  lv_row = 1.
  lv_col = 1.

  LOOP AT lt_mapper INTO ls_mapper.
    lv_col_str = zcl_excel_common=>convert_column2alpha( lv_col ).
    IF ls_mapper IS INITIAL.
      lo_row = lo_worksheet->get_row( ip_row = lv_row ).
      lo_row->set_row_height( ip_row_height = 8 ).
      lv_col = 1.
      lv_row = lv_row + 1.
      CONTINUE.
    ENDIF.
    lo_worksheet->set_cell( ip_column = lv_col_str
                            ip_row    = lv_row
                            ip_value  = space
                            ip_style  = ls_mapper ).
    lv_col = lv_col + 1.

    lo_column = lo_worksheet->get_column( ip_column = lv_col_str ).
    lo_column->set_width( ip_width = 2 ).
  ENDLOOP.

  lo_worksheet->set_show_gridlines( i_show_gridlines = abap_false ).

  lo_worksheet->set_cell( ip_column = 'AP'
                          ip_row    = 15
                          ip_value  = 'Created with abap2xlsx'
                          ip_style  = lv_style_credit_guid ).

  lo_hyperlink = zcl_excel_hyperlink=>create_external_link( iv_url = 'https://sapmentors.github.io/abap2xlsx' ).
  lo_worksheet->set_cell( ip_column    = 'AP'
                          ip_row       = 24
                          ip_value     = 'https://sapmentors.github.io/abap2xlsx'
                          ip_style     = lv_style_link_guid
                          ip_hyperlink = lo_hyperlink ).

  lo_column = lo_worksheet->get_column( ip_column = 'AP' ).
  lo_column->set_auto_size( ip_auto_size = abap_true ).
  lo_worksheet->set_merge( ip_row = 15 ip_column_start = 'AP' ip_row_to = 22 ip_column_end = 'AR' ).
  lo_worksheet->set_merge( ip_row = 24 ip_column_start = 'AP' ip_row_to = 26 ip_column_end = 'AR' ).

  CREATE OBJECT lo_excel_writer TYPE zcl_excel_writer_2007.
  lv_file = lo_excel_writer->write_file( lo_excel ).

  "" Convert to binary
  CALL FUNCTION 'SCMS_XSTRING_TO_BINARY'
    EXPORTING
      buffer        = lv_file
    IMPORTING
      output_length = lv_bytecount
    TABLES
      binary_tab    = lt_file_tab.
*  "" This method is only available on AS ABAP > 6.40
*  lt_file_tab = cl_bcs_convert=>xstring_to_solix( iv_xstring  = lv_file ).
*  lv_bytecount = xstrlen( lv_file ).

  "" Save the file
  cl_gui_frontend_services=>gui_download( EXPORTING bin_filesize = lv_bytecount
                                                    filename     = lv_full_path
                                                    filetype     = 'BIN'
                                           CHANGING data_tab     = lt_file_tab ).
",13094,True,4590.399933819308,median
"CLASS lcl_file DEFINITION.
  PUBLIC SECTION.
    CLASS-METHODS upload RETURNING VALUE(result) TYPE y_if_profile_manager=>file
                         RAISING   ycx_object_not_processed
                                   cx_abap_invalid_value.
    CLASS-METHODS download IMPORTING profile   TYPE y_if_profile_manager=>file-profile
                                     checks    TYPE y_if_profile_manager=>file-checks
                                     delegates TYPE y_if_profile_manager=>file-delegates
                           RAISING   ycx_object_not_processed.
ENDCLASS.

CLASS lcl_file IMPLEMENTATION.

  METHOD download.
    DATA file_content TYPE TABLE OF string.
    DATA file_path TYPE string.
    DATA file_fullpath TYPE string.

    CONCATENATE 'CODE_PAL_PROFILE-' sy-sysid sy-mandt '-' profile-profile INTO DATA(file_name).

    DATA(structure) = NEW y_if_profile_manager=>file( profile = profile
                                                      checks = checks
                                                      delegates = delegates ).

    APPEND /ui2/cl_json=>serialize( structure ) TO file_content.

    cl_gui_frontend_services=>file_save_dialog(
      EXPORTING
        default_extension         = 'json'
        default_file_name         = file_name
      CHANGING
        filename                  = file_name
        path                      = file_path
        fullpath                  = file_fullpath
      EXCEPTIONS
        cntl_error                = 1
        error_no_gui              = 2
        not_supported_by_gui      = 3
        invalid_default_file_name = 4
        OTHERS                    = 5
    ).

    IF sy-subrc <> 0.
      RAISE EXCEPTION TYPE ycx_object_not_processed.
    ENDIF.

    cl_gui_frontend_services=>gui_download(
      EXPORTING
        filename                  = file_fullpath
      CHANGING
        data_tab                  = file_content
      EXCEPTIONS
        file_write_error          = 1
        no_batch                  = 2
        gui_refuse_filetransfer   = 3
        invalid_type              = 4
        no_authority              = 5
        unknown_error             = 6
        header_not_allowed        = 7
        separator_not_allowed     = 8
        filesize_not_allowed      = 9
        header_too_long           = 10
        dp_error_create           = 11
        dp_error_send             = 12
        dp_error_write            = 13
        unknown_dp_error          = 14
        access_denied             = 15
        dp_out_of_memory          = 16
        disk_full                 = 17
        dp_timeout                = 18
        file_not_found            = 19
        dataprovider_exception    = 20
        control_flush_error       = 21
        not_supported_by_gui      = 22
        error_no_gui              = 23
        OTHERS                    = 24
    ).

    IF sy-subrc <> 0.
      RAISE EXCEPTION TYPE ycx_object_not_processed.
    ENDIF.
  ENDMETHOD.

  METHOD upload.
    DATA files TYPE filetable.
    DATA files_rc TYPE i.
    DATA filename TYPE string.
    DATA data_tab TYPE TABLE OF string.
    DATA json TYPE /ui2/cl_json=>json.

    cl_gui_frontend_services=>file_open_dialog(
      EXPORTING
        file_filter             = 'JSON (*.json)|*.json|'
      CHANGING
        file_table              = files
        rc                      = files_rc
      EXCEPTIONS
        file_open_dialog_failed = 1
        cntl_error              = 2
        error_no_gui            = 3
        not_supported_by_gui    = 4
        OTHERS                  = 5
    ).

    IF sy-subrc <> 0.
      RAISE EXCEPTION TYPE ycx_object_not_processed.
    ENDIF.

    READ TABLE files INTO filename INDEX 1.

    cl_gui_frontend_services=>gui_upload(
      EXPORTING
        filename                = filename
      CHANGING
        data_tab                = data_tab
      EXCEPTIONS
        file_open_error         = 1
        file_read_error         = 2
        no_batch                = 3
        gui_refuse_filetransfer = 4
        invalid_type            = 5
        no_authority            = 6
        unknown_error           = 7
        bad_data_format         = 8
        header_not_allowed      = 9
        separator_not_allowed   = 10
        header_too_long         = 11
        unknown_dp_error        = 12
        access_denied           = 13
        dp_out_of_memory        = 14
        disk_full               = 15
        dp_timeout              = 16
        not_supported_by_gui    = 17
        error_no_gui            = 18
        OTHERS                  = 19
    ).

    IF sy-subrc <> 0.
      RAISE EXCEPTION TYPE ycx_object_not_processed.
    ENDIF.

    LOOP AT data_tab ASSIGNING FIELD-SYMBOL(<data>).
      CONCATENATE json ' ' <data> INTO json.
    ENDLOOP.

    /ui2/cl_json=>deserialize( EXPORTING json = json
                               CHANGING data = result ).

    IF result IS INITIAL.
      RAISE EXCEPTION TYPE cx_abap_invalid_value.
    ENDIF.

  ENDMETHOD.

ENDCLASS.

CLASS lcl_util DEFINITION.                          ""#EC NUMBER_METHODS
  PUBLIC SECTION.
    CLASS-METHODS:
      init_profiles IMPORTING sy_repid TYPE sy-repid,
      init_checks IMPORTING sy_repid TYPE sy-repid,
      init_delegates IMPORTING sy_repid TYPE sy-repid.

    CLASS-METHODS:
      refresh_all_trees,
      refresh_profiles,
      refresh_checks,
      refresh_delegates.

    CLASS-METHODS:
      get_selected_profile
        RETURNING VALUE(result) TYPE ytab_profiles
        RAISING   ycx_entry_not_found,
      set_selected_profile
        IMPORTING profile TYPE data,
      get_selected_delegate
        RETURNING VALUE(result) TYPE ytab_delegates
        RAISING   ycx_entry_not_found,
      get_selected_check
        RETURNING VALUE(result) TYPE ytab_checks
        RAISING   ycx_entry_not_found.

    CLASS-METHODS switch_toolbar_activation
      RAISING cx_failed.

    CLASS-METHODS:
      call_f4help
        IMPORTING referenced_field_name TYPE dfies-fieldname
                  window_title          TYPE c OPTIONAL
                  dynpro_program        TYPE sy-repid DEFAULT sy-cprog
                  dynpro_number         TYPE sy-dynnr DEFAULT sy-dynnr
        CHANGING  value_table           TYPE STANDARD TABLE
        RETURNING VALUE(result)         TYPE y_if_profile_manager=>value_help
        RAISING   cx_failed.    ""#EC PARAMETER_OUT ""#EC NUM_OUTPUT_PARA


    CLASS-METHODS:
      profile_f4help_200,
      profile_f4help_600,
      check_f4help.

    CLASS-METHODS:
      init_check_fields_active
        IMPORTING checkid TYPE vseoclass-clsname,
      get_disable_threshold_select
        IMPORTING checkid       TYPE vseoclass-clsname
        RETURNING VALUE(result) TYPE abap_bool,
      get_disable_on_prodcode_select
        IMPORTING checkid       TYPE vseoclass-clsname
        RETURNING VALUE(result) TYPE abap_bool,
      get_disable_on_testcode_select
        IMPORTING checkid       TYPE vseoclass-clsname
        RETURNING VALUE(result) TYPE abap_bool,
      set_threshold_active
        IMPORTING is_active TYPE abap_bool DEFAULT abap_true,
      set_on_prodcode_active
        IMPORTING is_active TYPE abap_bool DEFAULT abap_true,
      set_on_testcode_active
        IMPORTING is_active TYPE abap_bool DEFAULT abap_true,
      set_dynpro_field_active
        IMPORTING fieldname TYPE string
                  is_active TYPE abap_bool.

    CLASS-METHODS:
      assign_profile,
      unassign_profile,
      copy_profile,
      create_template_profile,
      import_profile,
      export_profile,
      get_initial_check
        RETURNING VALUE(result) TYPE ytab_checks.

    CLASS-METHODS:
      add_delegate
        RAISING cx_failed,
      remove_delegate,
      auto_re_start_delegate,
      check_delegate_rights
        RETURNING VALUE(result) TYPE abap_bool.


    CLASS-METHODS:
      init_add_check,
      init_edit_check
        IMPORTING check TYPE ytab_checks,
      check_customization
        IMPORTING edit_mode TYPE abap_bool DEFAULT abap_false
        RAISING   cx_failed,
      auto_re_start_check
        IMPORTING edit_mode TYPE abap_bool DEFAULT abap_false,
      remove_check
        IMPORTING check TYPE ytab_checks,
      remove_selected_check,
      check_check_rights
        IMPORTING profile       TYPE ycicc_profile
        RETURNING VALUE(result) TYPE abap_bool,
      check_selected_check_rights
        RETURNING VALUE(result) TYPE abap_bool.

    CLASS-METHODS:
      get_cursor_field
        RETURNING VALUE(result) TYPE char20,
      call_check_info,
      add_all_checks.
    CLASS-METHODS add_check
      IMPORTING
        edit_mode TYPE abap_bool DEFAULT abap_false
      RAISING
        cx_failed.
    CLASS-METHODS remove_all_checks.
  PRIVATE SECTION.
    CLASS-METHODS request_confirmation
      IMPORTING
        text_question TYPE string.

ENDCLASS.


CLASS lcl_profile_events DEFINITION INHERITING FROM y_alv_events.
  PUBLIC SECTION.
    METHODS y_if_alv_events~handle_selection_changed REDEFINITION.
    METHODS y_if_alv_events~handle_function_selected REDEFINITION.
  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.

CLASS lcl_profile_events IMPLEMENTATION.

  METHOD y_if_alv_events~handle_selection_changed.
    lcl_util=>refresh_checks( ).
    lcl_util=>refresh_delegates( ).
    TRY.
        lcl_util=>switch_toolbar_activation( ).
      CATCH cx_failed.
    ENDTRY.
  ENDMETHOD.

  METHOD y_if_alv_events~handle_function_selected.
    CASE fcode.
      WHEN 'BTN_ASSIGN'.
        io_profilename = ''.
        lcl_util=>assign_profile( ).

      WHEN 'BTN_UNASSIGN'.
        lcl_util=>unassign_profile( ).

      WHEN 'BTN_COPY'.
        lcl_util=>copy_profile( ).

      WHEN 'BTN_TEMP'.
        lcl_util=>create_template_profile( ).

      WHEN 'BTN_IMPORT'.
        lcl_util=>import_profile( ).

      WHEN 'BTN_EXPORT'.
        lcl_util=>export_profile( ).

    ENDCASE.
    lcl_util=>refresh_all_trees( ).
  ENDMETHOD.
ENDCLASS.

CLASS lcl_delegator_events DEFINITION INHERITING FROM y_alv_events.
  PUBLIC SECTION.
    METHODS y_if_alv_events~handle_function_selected REDEFINITION.
  PRIVATE SECTION.
ENDCLASS.

CLASS lcl_delegator_events IMPLEMENTATION.

  METHOD y_if_alv_events~handle_function_selected.
    CHECK lcl_util=>check_delegate_rights( ) EQ abap_true.

    CASE fcode.
      WHEN 'BTN_ADD'.
        io_delegate_name = ''.
        lcl_util=>auto_re_start_delegate( ).

      WHEN 'BTN_REMOVE'.
        lcl_util=>remove_delegate( ).

    ENDCASE.
    lcl_util=>refresh_delegates( ).
  ENDMETHOD.
ENDCLASS.

CLASS lcl_check_events DEFINITION INHERITING FROM y_alv_events.
  PUBLIC SECTION.
    METHODS y_if_alv_events~handle_function_selected REDEFINITION.
  PRIVATE SECTION.
    METHODS handle_btn_info.
    METHODS handle_btn_add.
    METHODS handle_btn_edit.
ENDCLASS.

CLASS lcl_check_events IMPLEMENTATION.

  METHOD y_if_alv_events~handle_function_selected.
    IF fcode EQ 'BTN_INFO'.
      handle_btn_info( ).
      RETURN.
    ENDIF.

    IF lcl_util=>check_selected_check_rights( ) = abap_false.
      RETURN.
    ENDIF.

    CASE fcode.
      WHEN 'BTN_ADD'.
        handle_btn_add( ).

      WHEN 'BTN_EDIT'.
        handle_btn_edit( ).

      WHEN 'BTN_REMOVE'.
        lcl_util=>remove_selected_check( ).

      WHEN 'BTN_ADD_ALL'.
        lcl_util=>add_all_checks( ).

      WHEN 'BTN_REMOVE_ALL'.
        lcl_util=>remove_all_checks( ).

    ENDCASE.

    lcl_util=>refresh_checks( ).
  ENDMETHOD.

  METHOD handle_btn_edit.
    TRY.
        lcl_util=>init_edit_check( lcl_util=>get_selected_check( ) ).
        lcl_util=>auto_re_start_check( abap_true ).
      CATCH ycx_entry_not_found.
        MESSAGE 'Please select a check!'(015) TYPE 'I'.
    ENDTRY.
  ENDMETHOD.

  METHOD handle_btn_add.
    TRY.
        lcl_util=>init_add_check( ).
        lcl_util=>auto_re_start_check( ).
      CATCH ycx_entry_not_found
            cx_sy_create_object_error.
        MESSAGE 'Please select a check!'(015) TYPE 'I'.
    ENDTRY.
  ENDMETHOD.

  METHOD handle_btn_info.
    TRY.
        io_check_id = lcl_util=>get_selected_check( )-checkid.
        lcl_util=>call_check_info(  ).
      CATCH ycx_entry_not_found.
        MESSAGE 'Please select a check!'(015) TYPE 'I'.
    ENDTRY.
  ENDMETHOD.

ENDCLASS.



CLASS lcl_util IMPLEMENTATION.
  METHOD init_profiles.
    TRY.
        profiles_tree = y_alv_tree_control=>create( alv_header_text = 'Profiles'(002)
                                                    dynpro_nr       = '0100'
                                                    docking_side    = cl_gui_docking_container=>align_at_left
                                                    ratio           = 21
                                                    type_name       = profile_manager->get_profiles_type_name( )
                                                    sort_table      = VALUE lvc_t_sort( ( spos = 1 fieldname = 'USERNAME' up = abap_true )
                                                                                        ( spos = 2 fieldname = 'PROFILE' up = abap_true ) )
                                                    sy_repid        = sy_repid
                                                    events          = NEW lcl_profile_events( )
                                                    event_mode      = y_if_alv_events=>mode_selection_changed ).

        profiles_tree->toolbar_control( )->add_button( fcode     = 'BTN_ASSIGN'
                                                       icon      = '@04@'
                                                       butn_type = cntb_btype_button
                                                       quickinfo = 'Assign'(003) ).

        profiles_tree->toolbar_control( )->add_button( fcode     = 'BTN_UNASSIGN'
                                                       icon      = '@05@'
                                                       butn_type = cntb_btype_button
                                                       quickinfo = 'Unassign'(004) ).

        profiles_tree->toolbar_control( )->add_button( fcode     = 'BTN_COPY'
                                                       icon      = '@14@'
                                                       butn_type = cntb_btype_button
                                                       quickinfo = 'Copy Profile' ).

        profiles_tree->toolbar_control( )->add_button( fcode     = 'BTN_IMPORT'
                                                       icon      = '@48@'
                                                       butn_type = cntb_btype_button
                                                       quickinfo = 'Import Profile' ).

        profiles_tree->toolbar_control( )->add_button( fcode     = 'BTN_EXPORT'
                                                       icon      = '@49@'
                                                       butn_type = cntb_btype_button
                                                       quickinfo = 'Export Profile' ).

        profiles_tree->set_field_header_text( fieldname   = 'USERNAME'
                                              header_text = 'User'(028) ).
        profiles_tree->set_field_header_text( fieldname   = 'PROFILE'
                                              header_text = 'Profile'(001) ).

        profiles_tree->init_display( ).

      CATCH cx_failed
            cx_sy_create_data_error.
        LEAVE TO SCREEN 0.

    ENDTRY.

    lcl_util=>refresh_profiles( ).
  ENDMETHOD.

  METHOD init_checks.
    TRY.
        checks_tree = y_alv_tree_control=>create( alv_header_text = 'Checks'(013)
                                                  dynpro_nr       = '0100'
                                                  docking_side    = cl_gui_docking_container=>align_at_right
                                                  ratio           = 60
                                                  type_name       = profile_manager->get_checks_type_name( )
                                                  sort_table      = VALUE lvc_t_sort( ( spos = 1 fieldname = 'PROFILE' up = abap_true )
                                                                                      ( spos = 2 fieldname = 'CHECKID' up = abap_true ) )
                                                  sy_repid        = sy_repid
                                                  events          = NEW lcl_check_events( ) ).

        checks_tree->toolbar_control( )->add_button( fcode     = 'BTN_ADD'
                                                     icon      = '@04@'
                                                     butn_type = cntb_btype_button
                                                     quickinfo = 'Add'(025) ).

        checks_tree->toolbar_control( )->add_button( fcode     = 'BTN_EDIT'
                                                     icon      = '@0Z@'
                                                     butn_type = cntb_btype_button
                                                     quickinfo = 'Edit'(026) ).

        checks_tree->toolbar_control( )->add_button( fcode     = 'BTN_REMOVE'
                                                     icon      = '@05@'
                                                     butn_type = cntb_btype_button
                                                     quickinfo = 'Remove'(027) ).

        checks_tree->toolbar_control( )->add_button( fcode     = 'BTN_INFO'
                                                     icon      = '@5E@'
                                                     butn_type = cntb_btype_button
                                                     quickinfo = 'Check Documentation'(052) ).

        checks_tree->toolbar_control( )->add_button( fcode     = 'BTN_ADD_ALL'
                                                     icon      = '@VY@'
                                                     butn_type = cntb_btype_button
                                                     quickinfo = 'Add All'(058) ).

        checks_tree->toolbar_control( )->add_button( fcode     = 'BTN_REMOVE_ALL'
                                                     icon      = '@VZ@'
                                                     butn_type = cntb_btype_button
                                                     quickinfo = 'Remove All'(059) ).

        checks_tree->set_field_visibility( fieldname = 'START_DATE'
                                           is_visible = abap_true ).
        checks_tree->set_field_visibility( fieldname = 'END_DATE'
                                           is_visible = abap_true ).
        checks_tree->set_field_visibility( fieldname = 'OBJECTS_CREATED_ON'
                                           is_visible = abap_true ).
        checks_tree->set_field_visibility( fieldname = 'THRESHOLD'
                                           is_visible = abap_true ).
        checks_tree->set_field_visibility( fieldname = 'PRIO'
                                           is_visible = abap_true ).
        checks_tree->set_field_visibility( fieldname = 'APPLY_ON_PRODUCTIVE_CODE'
                                           is_visible = abap_true ).
        checks_tree->set_field_visibility( fieldname = 'APPLY_ON_TESTCODE'
                                           is_visible = abap_true ).

        checks_tree->set_field_header_text( fieldname   = 'PROFILE'
                                            header_text = 'Profile'(001) ).
        checks_tree->set_field_header_text( fieldname   = 'CHECKID'
                                            header_text = 'Check ID'(014) ).
        checks_tree->set_field_header_text( fieldname   = 'START_DATE'
                                            header_text = 'Start Date'(030) ).
        checks_tree->set_field_header_text( fieldname   = 'END_DATE'
                                            header_text = 'End Date'(031) ).
        checks_tree->set_field_header_text( fieldname   = 'OBJECTS_CREATED_ON'
                                            header_text = 'Apply On Objects Created Since'(032) ).
        checks_tree->set_field_header_text( fieldname   = 'PRIO'
                                            header_text = 'Message Priority'(033) ).
        checks_tree->set_field_header_text( fieldname   = 'APPLY_ON_PRODUCTIVE_CODE'
                                            header_text = 'Apply on Productive Code'(050) ).
        checks_tree->set_field_header_text( fieldname   = 'APPLY_ON_TESTCODE'
                                            header_text = 'Apply on Testcode'(034) ).

        checks_tree->init_display( ).

        checks_tree->deactivate_toolbar( ).

      CATCH cx_failed
            cx_sy_create_data_error.
        LEAVE TO SCREEN 0.

    ENDTRY.
  ENDMETHOD.

  METHOD init_delegates.
    TRY.
        delegates_tree = y_alv_tree_control=>create( alv_header_text = 'Delegates'(029)
                                                     dynpro_nr       = '0100'
                                                     docking_side    = cl_gui_docking_container=>align_at_right
                                                     ratio           = 40
                                                     type_name       = profile_manager->get_delegates_type_name( )
                                                     sort_table      = VALUE lvc_t_sort( ( spos = 1 fieldname = 'PROFILE' up = abap_true )
                                                                                         ( spos = 2 fieldname = 'DELEGATE' up = abap_true ) )
                                                     sy_repid        = sy_repid
                                                     events          = NEW lcl_delegator_events( ) ).

        delegates_tree->toolbar_control( )->add_button( fcode     = 'BTN_ADD'
                                                        icon      = '@04@'
                                                        butn_type = cntb_btype_button
                                                        quickinfo = 'Add'(025) ).

        delegates_tree->toolbar_control( )->add_button( fcode     = 'BTN_REMOVE'
                                                        icon      = '@05@'
                                                        butn_type = cntb_btype_button
                                                        quickinfo = 'Remove'(027) ).

        delegates_tree->set_field_header_text( fieldname   = 'PROFILE'
                                               header_text = 'Profile'(001) ).
        delegates_tree->set_field_header_text( fieldname   = 'DELEGATE'
                                               header_text = 'Delegate'(036) ).


        delegates_tree->init_display( ).

        delegates_tree->deactivate_toolbar( ).

      CATCH cx_failed
            cx_sy_create_data_error.
        LEAVE TO SCREEN 0.

    ENDTRY.
  ENDMETHOD.

  METHOD call_check_info.
    DATA base TYPE REF TO y_check_base.
    TRY.
        CREATE OBJECT base TYPE (io_check_id).
        CALL FUNCTION 'CALL_BROWSER' EXPORTING url = base->settings-documentation.

      CATCH cx_sy_create_object_error.
        MESSAGE 'Failed to find the check!'(043) TYPE 'I'.

    ENDTRY.
  ENDMETHOD.

  METHOD get_cursor_field.
    GET CURSOR FIELD result.
  ENDMETHOD.

  METHOD get_selected_profile.
    DATA(line) = profiles_tree->get_selected_line( ).
    FIELD-SYMBOLS: <line> TYPE ytab_profiles.
    ASSIGN line->* TO <line>.
    IF sy-subrc NE 0.
      RAISE EXCEPTION TYPE ycx_entry_not_found.
    ENDIF.
    result = <line>.
    UNASSIGN <line>.
  ENDMETHOD.

  METHOD set_selected_profile.
    DATA(index) = profiles_tree->list_control( )->get_line_index( profile ).
    profiles_tree->set_selected_index( index ).
  ENDMETHOD.

  METHOD get_selected_delegate.
    DATA(line) = delegates_tree->get_selected_line( ).
    FIELD-SYMBOLS: <line> TYPE ytab_delegates.
    ASSIGN line->* TO <line>.
    IF sy-subrc NE 0.
      RAISE EXCEPTION TYPE ycx_entry_not_found.
    ENDIF.
    result = <line>.
    UNASSIGN <line>.
  ENDMETHOD.

  METHOD get_selected_check.
    DATA(line) = checks_tree->get_selected_line( ).
    FIELD-SYMBOLS: <line> TYPE ytab_checks.
    ASSIGN line->* TO <line>.
    IF sy-subrc NE 0.
      RAISE EXCEPTION TYPE ycx_entry_not_found.
    ENDIF.
    result = <line>.
    UNASSIGN <line>.
  ENDMETHOD.

  METHOD switch_toolbar_activation.
    TRY.
        get_selected_profile( ).
        checks_tree->activate_toolbar( ).
        delegates_tree->activate_toolbar( ).
      CATCH ycx_entry_not_found.
        checks_tree->deactivate_toolbar( ).
        delegates_tree->deactivate_toolbar( ).
    ENDTRY.
  ENDMETHOD.

  METHOD refresh_checks.
    CHECK checks_tree IS BOUND.
    TRY.
        checks_tree->list_control( )->set_table( profile_manager->select_checks( get_selected_profile( )-profile ) ).

      CATCH ycx_entry_not_found.
        checks_tree->list_control( )->delete_all( ).

    ENDTRY.
    checks_tree->refresh_display( ).
  ENDMETHOD.

  METHOD refresh_delegates.
    CHECK delegates_tree IS BOUND.
    TRY.
        delegates_tree->list_control( )->set_table( profile_manager->select_delegates( get_selected_profile( )-profile ) ).

      CATCH ycx_entry_not_found.
        delegates_tree->list_control( )->delete_all( ).

    ENDTRY.
    delegates_tree->refresh_display( ).
  ENDMETHOD.

  METHOD refresh_profiles.
    CHECK profiles_tree IS BOUND.
    TRY.
        profiles_tree->list_control( )->set_table( profile_manager->select_profiles( sy-uname ) ).

      CATCH ycx_entry_not_found.
        profiles_tree->list_control( )->delete_all( ).

    ENDTRY.
    profiles_tree->refresh_display( ).
  ENDMETHOD.

  METHOD refresh_all_trees.
    refresh_profiles( ).
    refresh_checks( ).
    refresh_delegates( ).
  ENDMETHOD.

  METHOD call_f4help.
    DATA tmp_retval TYPE STANDARD TABLE OF ddshretval.
    CALL FUNCTION 'F4IF_INT_TABLE_VALUE_REQUEST'
      EXPORTING
        retfield     = referenced_field_name
        value_org    = 'S'
        dynpprog     = dynpro_program
        dynpnr       = dynpro_number
        window_title = window_title
      TABLES
        value_tab    = value_table
        return_tab   = result
      EXCEPTIONS
        OTHERS       = 4.
    IF sy-subrc NE 0.
      RAISE EXCEPTION TYPE cx_failed.
    ENDIF.
  ENDMETHOD.

  METHOD profile_f4help_200.
    TRY.
        DATA(tmp_profiles) = profile_manager->get_registered_profiles( ).
        DATA(tmp_retval) = lcl_util=>call_f4help( EXPORTING
                                                   referenced_field_name = 'PROFILE'
                                                   window_title          = 'Available Profiles'(009)
                                                   dynpro_program        = sy-cprog
                                                   dynpro_number         = sy-dynnr
                                                  CHANGING
                                                   value_table  = tmp_profiles ).
        IF tmp_retval IS NOT INITIAL.
          io_profilename = tmp_retval[ 1 ]-fieldval.
        ENDIF.

        LEAVE TO SCREEN 200.

      CATCH cx_failed.
        MESSAGE 'Profiles not found!'(010) TYPE 'I'.

      CATCH ycx_entry_not_found.
        MESSAGE 'Profiles not registered!'(011) TYPE 'I'.

    ENDTRY.
    FREE tmp_profiles.
  ENDMETHOD.

  METHOD profile_f4help_600.
    TRY.
        DATA(tmp_profiles) = profile_manager->get_registered_profiles( ).
        DATA(tmp_retval) = lcl_util=>call_f4help( EXPORTING
                                                   referenced_field_name = 'PROFILE'
                                                   window_title          = 'Available Profiles'(009)
                                                   dynpro_program        = sy-cprog
                                                   dynpro_number         = sy-dynnr
                                                  CHANGING
                                                   value_table  = tmp_profiles ).
        IF tmp_retval IS NOT INITIAL.
          io_profilename = tmp_retval[ 1 ]-fieldval.
        ENDIF.

        LEAVE TO SCREEN 600.

      CATCH cx_failed.
        MESSAGE 'Profiles not found!'(010) TYPE 'I'.

      CATCH ycx_entry_not_found.
        MESSAGE 'Profiles not registered!'(011) TYPE 'I'.

    ENDTRY.
    FREE tmp_profiles.
  ENDMETHOD.

  METHOD check_f4help.
    TRY.
        DATA(tmp_checks) = profile_manager->select_existing_checks( ).
        DATA(tmp_retval) = lcl_util=>call_f4help( EXPORTING
                                                    referenced_field_name = 'CHECKID'
                                                    window_title          = 'Available Checks'(019)
                                                    dynpro_program        = sy-cprog
                                                    dynpro_number         = sy-dynnr
                                                  CHANGING
                                                    value_table  = tmp_checks ).
        IF tmp_retval IS NOT INITIAL.
          io_check_id = tmp_retval[ 1 ]-fieldval.
          has_edit_mode_started = abap_true.
        ELSE.
          io_check_id = lcl_util=>get_selected_check( )-checkid.
        ENDIF.
        io_check_description = profile_manager->get_check_description( io_check_id ).

        LEAVE TO SCREEN 400.

      CATCH cx_failed.
        MESSAGE 'Checks not found!'(020) TYPE 'S'.

      CATCH ycx_entry_not_found.
        MESSAGE 'Checks not registered!'(021) TYPE 'S'.

    ENDTRY.
    FREE: tmp_checks, tmp_retval.
  ENDMETHOD.

  METHOD init_check_fields_active.
    DATA obj TYPE REF TO y_check_base.

    TRY.
        IF get_disable_threshold_select( checkid ) EQ abap_true.
          set_threshold_active( abap_false ).
        ELSE.
          set_threshold_active( abap_true ).
        ENDIF.

        IF get_disable_on_prodcode_select( checkid ) EQ abap_true.
          set_on_prodcode_active( abap_false ).
        ELSE.
          set_on_prodcode_active( abap_true ).
        ENDIF.

        IF get_disable_on_testcode_select( checkid ) EQ abap_true.
          set_on_testcode_active( abap_false ).
        ELSE.
          set_on_testcode_active( abap_true ).
        ENDIF.

        CREATE OBJECT obj TYPE (io_check_id).
        IF has_edit_mode_started EQ abap_true.
          io_threshold = obj->settings-threshold.
          io_prio = obj->settings-prio.
          io_creation_date = obj->settings-object_created_on.
          chbx_on_prodcode = obj->settings-apply_on_productive_code.
          chbx_on_testcode = obj->settings-apply_on_test_code.
          has_edit_mode_started = abap_false.
        ENDIF.

      CATCH cx_sy_create_object_error.
        RETURN.
    ENDTRY.
  ENDMETHOD.

  METHOD get_disable_on_prodcode_select.
    DATA obj TYPE REF TO y_check_base.
    TRY.
        CREATE OBJECT obj TYPE (checkid).
        result =  obj->settings-disable_on_prodcode_selection.

      CATCH cx_sy_create_object_error.
        result = abap_false.

    ENDTRY.
  ENDMETHOD.

  METHOD get_disable_on_testcode_select.
    DATA obj TYPE REF TO y_check_base.
    TRY.
        CREATE OBJECT obj TYPE (checkid).
        result =  obj->settings-disable_on_testcode_selection.

      CATCH cx_sy_create_object_error.
        result = abap_false.

    ENDTRY.
  ENDMETHOD.

  METHOD get_disable_threshold_select.
    DATA obj TYPE REF TO y_check_base.
    TRY.
        CREATE OBJECT obj TYPE (checkid).
        result =  obj->settings-disable_threshold_selection.

      CATCH cx_sy_create_object_error.
        result = abap_false.

    ENDTRY.
  ENDMETHOD.

  METHOD set_on_prodcode_active.
    set_dynpro_field_active( fieldname = 'LBL_ON_PRODCODE'
                             is_active = is_active ).
    set_dynpro_field_active( fieldname = 'CHBX_ON_PRODCODE'
                             is_active = is_active ).
  ENDMETHOD.

  METHOD set_on_testcode_active.
    set_dynpro_field_active( fieldname = 'LBL_ON_TESTCODE'
                             is_active = is_active ).
    set_dynpro_field_active( fieldname = 'CHBX_ON_TESTCODE'
                             is_active = is_active ).
  ENDMETHOD.

  METHOD set_threshold_active.
    set_dynpro_field_active( fieldname = 'LBL_TEXT_THRESHOLD'
                             is_active = is_active ).
    set_dynpro_field_active( fieldname = 'IO_THRESHOLD'
                             is_active = is_active ).
  ENDMETHOD.

  METHOD set_dynpro_field_active.
    LOOP AT SCREEN INTO DATA(line).

      IF line-name EQ to_upper( fieldname ).
        IF is_active EQ abap_true.
          line-input = 1.
        ELSE.
          line-input = 0.
        ENDIF.

        MODIFY SCREEN FROM line.
        EXIT.

      ENDIF.

    ENDLOOP.
  ENDMETHOD.

  METHOD assign_profile.
    CALL SCREEN 200 STARTING AT 10 10.

    IF user_command <> 'ENTR_200'
    OR io_profilename IS INITIAL.
      RETURN.
    ENDIF.

    TRY.
        profile_manager->insert_profile( VALUE #( username = sy-uname
                                                  profile  = io_profilename
                                                  is_standard = abap_false
                                                  last_changed_by = sy-uname
                                                  last_changed_on = sy-datum
                                                  last_changed_at = sy-timlo ) ).

      CATCH ycx_failed_to_add_a_line.
        MESSAGE 'Profile already assigned!'(007) TYPE 'I'.

    ENDTRY.
  ENDMETHOD.

  METHOD unassign_profile.
    TRY.
        profile_manager->delete_profile( lcl_util=>get_selected_profile( ) ).

      CATCH ycx_failed_to_remove_a_line.
        MESSAGE 'Profile cannot be unassigned!'(008) TYPE 'I'.

      CATCH ycx_entry_not_found.
        MESSAGE 'Please select a profile!'(005) TYPE 'I'.

    ENDTRY.
  ENDMETHOD.

  METHOD copy_profile.
    CALL SCREEN 600 STARTING AT 10 10.

    IF user_command <> 'ENTR_600'
    OR io_profilename IS INITIAL
    OR io_to_profile IS INITIAL.
      RETURN.
    ENDIF.

    TRY.
        IF profile_manager->profile_exists( io_to_profile ) = abap_true.
          RAISE EXCEPTION TYPE ycx_failed_to_add_a_line.
        ENDIF.

        DATA(checklist) = profile_manager->select_checks( io_profilename ).

        profile_manager->insert_profile( VALUE #( username = sy-uname
                                            profile  = io_to_profile
                                            is_standard = abap_false
                                            last_changed_by = sy-uname
                                            last_changed_on = sy-datum
                                            last_changed_at = sy-timlo ) ).

        profile_manager->check_delegation_rights( io_to_profile ).

        LOOP AT checklist INTO DATA(check).
          check-profile = io_to_profile.
          check-last_changed_by = sy-uname.
          check-last_changed_on = sy-datum.
          check-last_changed_at = sy-timlo.
          TRY.
              profile_manager->insert_check( check ).
            CATCH ycx_failed_to_add_a_line
                  ycx_time_overlap.
              MESSAGE 'Failed to Copy the Check:'(049) && check-checkid TYPE 'I'.
          ENDTRY.
        ENDLOOP.

      CATCH ycx_no_delegation_rights.
        MESSAGE 'You are not a delegate of the profile!'(006) TYPE 'I'.

      CATCH ycx_entry_not_found.
        MESSAGE 'Please choose a valid profile to copy from!'(047) TYPE 'I'.

      CATCH ycx_failed_to_add_a_line.
        MESSAGE 'A profile can not be copied into another existing profile!'(048) TYPE 'I'.

    ENDTRY.

  ENDMETHOD.

  METHOD  create_template_profile.
    CALL SCREEN 500 STARTING AT 10 10.

    IF user_command <> 'ENTR_500'
    OR io_profilename IS INITIAL.
      RETURN.
    ENDIF.

    TRY.

        IF profile_manager->profile_exists( io_profilename ) = abap_true.
          RAISE EXCEPTION TYPE ycx_failed_to_add_a_line.
        ENDIF.

        profile_manager->insert_profile( VALUE #( username = sy-uname
                                                  profile  = io_profilename
                                                  is_standard = abap_false
                                                  last_changed_by = sy-uname
                                                  last_changed_on = sy-datum
                                                  last_changed_at = sy-timlo ) ).

        profile_manager->check_delegation_rights( io_profilename ).

      CATCH ycx_failed_to_add_a_line
            ycx_time_overlap.
        MESSAGE 'Template creation has failed!'(045) TYPE 'I'.

      CATCH ycx_no_delegation_rights.
        MESSAGE 'You are not a delegate of the profile!'(006) TYPE 'I'.

    ENDTRY.
  ENDMETHOD.

  METHOD import_profile.
    TRY.
        DATA(structure) = lcl_file=>upload( ).
      CATCH ycx_object_not_processed.
        MESSAGE 'Failed to Import!'(054) TYPE 'E'.
      CATCH cx_abap_invalid_value.
        MESSAGE 'Invalid Imported File!'(055) TYPE 'E'.
    ENDTRY.

    IF profile_manager->profile_exists( structure-profile-profile ) = abap_true.
      request_confirmation( | Would you like to replace the { structure-profile-profile } profile? | ).
      check_check_rights( structure-profile-profile ).
    ENDIF.

    TRY.
        profile_manager->import_profile( structure ).
      CATCH ycx_failed_to_add_a_line
            ycx_time_overlap
            ycx_no_delegation_rights.
        MESSAGE 'Failed to Import!'(054) TYPE 'E'.
    ENDTRY.

    MESSAGE 'Action Executed Successfully!'(056) TYPE 'S'.
  ENDMETHOD.

  METHOD export_profile.
    TRY.
        DATA(profile) = lcl_util=>get_selected_profile( ).
      CATCH ycx_entry_not_found.
        MESSAGE 'Please select a profile!'(005) TYPE 'W'.
    ENDTRY.

    TRY.
        DATA(checks) = profile_manager->select_checks( profile-profile ).
      CATCH ycx_entry_not_found.
        MESSAGE 'Checks not found!'(020) TYPE 'E'.
    ENDTRY.

    TRY.
        DATA(delegates) = profile_manager->select_delegates( profile-profile ).
      CATCH ycx_entry_not_found.
        MESSAGE 'There must be at least one delegate!'(024) TYPE 'E'.
    ENDTRY.

    TRY.
        lcl_file=>download( profile = profile
                            checks = checks
                            delegates = delegates ).
      CATCH ycx_object_not_processed.
        MESSAGE 'Failed to Export!'(053) TYPE 'E'.
    ENDTRY.

    MESSAGE 'Action Executed Successfully!'(056) TYPE 'S'.
  ENDMETHOD.

  METHOD get_initial_check.
    result-profile = ''.
    result-checkid = ''.
    result-start_date = '20190101'.
    result-end_date = '99991231'.
    result-objects_created_on = '20160101'.
    result-apply_on_testcode = abap_false.
    result-threshold = 0.
    result-prio = 'E'.
    result-last_changed_by = sy-uname.
    result-last_changed_on = sy-datum.
    result-last_changed_at = sy-timlo.
  ENDMETHOD.

  METHOD auto_re_start_delegate.
    TRY.
        CALL SCREEN 300 STARTING AT 10 10.
        add_delegate( ).

      CATCH cx_failed.
        auto_re_start_delegate( ).

    ENDTRY.
  ENDMETHOD.

  METHOD add_delegate.
    CHECK user_command EQ 'ENTR_300' AND io_delegate_name NE space.

    TRY.
        profile_manager->insert_delegate( VALUE #( profile = lcl_util=>get_selected_profile( )-profile
                                                   delegate = io_delegate_name ) ).

      CATCH ycx_entry_not_found.
        MESSAGE 'Please select a profile!'(005) TYPE 'I'.

      CATCH ycx_failed_to_add_a_line.
        MESSAGE 'Delegate already exist!'(022) TYPE 'I'.
        RAISE EXCEPTION TYPE cx_failed.
    ENDTRY.
  ENDMETHOD.

  METHOD remove_delegate.
    TRY.
        lcl_util=>get_selected_delegate( ).

      CATCH ycx_entry_not_found.
        MESSAGE 'Please select a delegate!'(035)  TYPE 'I'.
        RETURN.

    ENDTRY.

    TRY.
        DATA(lines_of_delegates) = lines( profile_manager->select_delegates( lcl_util=>get_selected_profile( )-profile ) ).
        IF lines_of_delegates LE 1.
          RAISE EXCEPTION TYPE ycx_entry_not_found.
        ENDIF.

        profile_manager->delete_delegate( lcl_util=>get_selected_delegate( ) ).

      CATCH ycx_entry_not_found.
        MESSAGE 'There must be at least one delegate!'(024) TYPE 'I'.

      CATCH ycx_failed_to_remove_a_line.
        MESSAGE 'Delegate cannot be removed!'(023) TYPE 'I'.

    ENDTRY.
  ENDMETHOD.

  METHOD check_delegate_rights.
    TRY.
        DATA(prof) = lcl_util=>get_selected_profile( ).
        IF prof-is_standard EQ abap_true.
          RAISE EXCEPTION TYPE cx_failed.
        ENDIF.

        profile_manager->check_delegation_rights( prof-profile ).
        result = abap_true.

      CATCH ycx_entry_not_found.
        MESSAGE 'Please select a profile!'(005) TYPE 'I'.
      CATCH ycx_no_delegation_rights.

        MESSAGE 'You are not a delegate of the profile!'(006) TYPE 'I'.

      CATCH cx_failed.
        MESSAGE 'The rights of the standard profile cannot be delegated!'(040) TYPE 'I'.

    ENDTRY.
  ENDMETHOD.

  METHOD auto_re_start_check.
    TRY.
        CALL SCREEN 400 STARTING AT 10 10.
        check_customization( edit_mode ).

      CATCH cx_failed.
        auto_re_start_check( edit_mode ).

    ENDTRY.
  ENDMETHOD.

  METHOD init_add_check.
    DATA obj TYPE REF TO y_check_base.

    ""io_check_id = ''.
    io_check_description = ''.
    io_start_date = '20190101'.
    io_end_date = '99991231'.
    io_creation_date = '20160101'.
    io_prio = 'E'.
    io_threshold = 0.
    chbx_on_prodcode = abap_true.
    chbx_on_testcode = abap_true.

    TRY.
        CREATE OBJECT obj TYPE (io_check_id).
        io_creation_date = obj->settings-object_created_on.
        io_threshold = obj->settings-threshold.
        io_prio = obj->settings-prio.
        chbx_on_prodcode = obj->settings-apply_on_productive_code.
        chbx_on_testcode = obj->settings-apply_on_test_code.

      CATCH cx_sy_create_object_error.
        RETURN.
    ENDTRY.
  ENDMETHOD.

  METHOD init_edit_check.
    DATA(check_line) = check.

    io_check_id = check_line-checkid.
    io_start_date = check_line-start_date.
    io_end_date = check_line-end_date.
    io_creation_date = check_line-objects_created_on.
    io_threshold = check_line-threshold.
    io_prio = check_line-prio.
    chbx_on_prodcode = check_line-apply_on_productive_code.
    chbx_on_testcode = check_line-apply_on_testcode.

    TRY.
        io_check_description = profile_manager->get_check_description( check_line-checkid ).

      CATCH ycx_entry_not_found.
        io_check_description = ''.

    ENDTRY.

    FREE check_line.
  ENDMETHOD.

  METHOD check_customization.
    CHECK user_command EQ 'ENTR_400'
    AND io_check_id NE space.

    add_check( edit_mode ).
  ENDMETHOD.

  METHOD add_check.
    TRY.
        DATA(profile) = lcl_util=>get_selected_profile( )-profile.
      CATCH ycx_entry_not_found.
        MESSAGE 'Please select a profile!'(005) TYPE 'I'.
    ENDTRY.

    DATA(check) = VALUE ytab_checks( profile = profile
                                     checkid = io_check_id
                                     start_date = io_start_date
                                     end_date = io_end_date
                                     objects_created_on = io_creation_date
                                     threshold = io_threshold
                                     prio = io_prio
                                     apply_on_productive_code = chbx_on_prodcode
                                     apply_on_testcode = chbx_on_testcode
                                     last_changed_by = sy-uname
                                     last_changed_on = sy-datum
                                     last_changed_at = sy-timlo ).

    TRY.
        profile_manager->get_check_description( check-checkid ).
      CATCH ycx_entry_not_found.
        MESSAGE 'Check is not registered!'(044) TYPE 'I'.
        RAISE EXCEPTION TYPE cx_failed.
    ENDTRY.

    IF chbx_on_prodcode = abap_false
    AND chbx_on_testcode = abap_false.
      MESSAGE 'Please choose Productive Code and/or Testcode for check execution!'(051) TYPE 'I'.
      RAISE EXCEPTION TYPE cx_failed.
    ENDIF.

    TRY.
        IF edit_mode = abap_true.
          profile_manager->check_time_overlap( check = check
                                               selected_check = lcl_util=>get_selected_check( ) ).

          profile_manager->delete_check( lcl_util=>get_selected_check( ) ).
        ELSE.
          profile_manager->check_time_overlap( check = check ).
        ENDIF.

        profile_manager->insert_check( check ).
      CATCH ycx_entry_not_found.
        MESSAGE 'Check is not registered!'(044) TYPE 'I'.
        RAISE EXCEPTION TYPE cx_failed.

      CATCH ycx_failed_to_add_a_line
            ycx_failed_to_remove_a_line.
        MESSAGE 'Check already exist!'(016) TYPE 'I'.
        RAISE EXCEPTION TYPE cx_failed.

      CATCH ycx_time_overlap.
        MESSAGE 'Please select a different start / end date to avoid a time overlap!'(037) TYPE 'I'.
        RAISE EXCEPTION TYPE cx_failed.

    ENDTRY.
  ENDMETHOD.

  METHOD remove_check.
    TRY.
        profile_manager->delete_check( check ).
      CATCH ycx_failed_to_remove_a_line.
        MESSAGE 'Check cannot be removed!'(018) TYPE 'E'.
    ENDTRY.
  ENDMETHOD.

  METHOD remove_selected_check.
    TRY.
        remove_check( lcl_util=>get_selected_check( ) ).
      CATCH ycx_entry_not_found.
        MESSAGE 'Please select a check!'(015) TYPE 'W'.
    ENDTRY.
  ENDMETHOD.

  METHOD check_check_rights.
    TRY.
        profile_manager->check_delegation_rights( profile ).
        result = abap_true.
      CATCH ycx_no_delegation_rights.
        MESSAGE 'You are not a delegate of the profile!'(006) TYPE 'W'.
      CATCH cx_failed.
        MESSAGE 'Insufficient rights to edit the standard profile!'(039) TYPE 'W'.
    ENDTRY.
  ENDMETHOD.

  METHOD check_selected_check_rights.
    TRY.
        result = check_check_rights( lcl_util=>get_selected_profile( )-profile ).
      CATCH ycx_entry_not_found.
        MESSAGE 'Please select a profile!'(005) TYPE 'W'.
    ENDTRY.
  ENDMETHOD.

  METHOD request_confirmation.
    DATA answer TYPE c.

    CALL FUNCTION 'POPUP_TO_CONFIRM'
      EXPORTING
        titlebar              = | Confirmation |
        text_question         = text_question
        display_cancel_button = abap_false
      IMPORTING
        answer                = answer.

    IF answer <> 1.
      MESSAGE 'Action Canceled.' TYPE 'W'.
    ENDIF.
  ENDMETHOD.

  METHOD add_all_checks.
    TRY.
        DATA(profile) = lcl_util=>get_selected_profile( )-profile.
      CATCH ycx_entry_not_found.
        MESSAGE 'Please select a profile!'(005) TYPE 'I'.
    ENDTRY.

    TRY.
        profile_manager->check_delegation_rights( profile ).
      CATCH ycx_no_delegation_rights.
        MESSAGE 'You are not a delegate of the profile!'(006) TYPE 'W'.
    ENDTRY.

    TRY.
        profile_manager->select_checks( profile ).
        request_confirmation( | Would you like to replace the current checks? | ).
      CATCH ycx_entry_not_found.
        request_confirmation( | Would you like to add all the checks? | ).
    ENDTRY.

    profile_manager->remove_all_checks( profile ).

    TRY.
        DATA(available_checks) = profile_manager->select_existing_checks( ).
      CATCH ycx_entry_not_found.
        MESSAGE 'Checks not registered!'(021) TYPE 'S'.
    ENDTRY.

    LOOP AT available_checks ASSIGNING FIELD-SYMBOL(<check>).
      io_check_id = <check>-checkid.
      init_add_check( ).
      TRY.
          add_check( ).
        CATCH cx_failed.
          CONTINUE.
      ENDTRY.
    ENDLOOP.

    MESSAGE 'Action Executed Successfully!'(056) TYPE 'S'.
  ENDMETHOD.


  METHOD remove_all_checks.
    TRY.
        DATA(profile) = lcl_util=>get_selected_profile( )-profile.
      CATCH ycx_entry_not_found.
        MESSAGE 'Please select a profile!'(005) TYPE 'I'.
    ENDTRY.

    TRY.
        profile_manager->check_delegation_rights( profile ).
      CATCH ycx_no_delegation_rights.
        MESSAGE 'You are not a delegate of the profile!'(006) TYPE 'W'.
    ENDTRY.

    TRY.
        DATA(checks) = profile_manager->select_checks( profile ).
      CATCH ycx_entry_not_found.
        RETURN.
    ENDTRY.

    request_confirmation( | Would you like to remove all the checks? | ).

    profile_manager->remove_all_checks( profile ).

    MESSAGE 'Action Executed Successfully!'(056) TYPE 'S'.
  ENDMETHOD.

ENDCLASS.
",10680,False,2101.7774158646653,median
"CLASS zcl_abapgit_object_clas DEFINITION
  PUBLIC
  INHERITING FROM zcl_abapgit_objects_program
  CREATE PUBLIC .

  PUBLIC SECTION.

    INTERFACES zif_abapgit_object .

    ALIASES mo_files
      FOR zif_abapgit_object~mo_files .

    METHODS constructor
      IMPORTING
        !is_item     TYPE zif_abapgit_definitions=>ty_item
        !iv_language TYPE spras .
  PROTECTED SECTION.
    DATA: mi_object_oriented_object_fct TYPE REF TO zif_abapgit_oo_object_fnc,
          mv_skip_testclass             TYPE abap_bool,
          mv_classpool_name             TYPE progname.
    METHODS:
      deserialize_abap
        IMPORTING ii_xml     TYPE REF TO zif_abapgit_xml_input
                  iv_package TYPE devclass
        RAISING   zcx_abapgit_exception,
      deserialize_docu
        IMPORTING ii_xml TYPE REF TO zif_abapgit_xml_input
        RAISING   zcx_abapgit_exception,
      deserialize_tpool
        IMPORTING ii_xml TYPE REF TO zif_abapgit_xml_input
        RAISING   zcx_abapgit_exception,
      deserialize_sotr
        IMPORTING ii_ml      TYPE REF TO zif_abapgit_xml_input
                  iv_package TYPE devclass
        RAISING   zcx_abapgit_exception,
      serialize_xml
        IMPORTING ii_xml TYPE REF TO zif_abapgit_xml_output
        RAISING   zcx_abapgit_exception,
      serialize_attr
        IMPORTING
          !ii_xml     TYPE REF TO zif_abapgit_xml_output
          !iv_clsname TYPE seoclsname
        RAISING
          zcx_abapgit_exception,
      serialize_descr
        IMPORTING
          !ii_xml     TYPE REF TO zif_abapgit_xml_output
          !iv_clsname TYPE seoclsname
        RAISING
          zcx_abapgit_exception,
      serialize_docu
        IMPORTING
          !ii_xml              TYPE REF TO zif_abapgit_xml_output
          !it_langu_additional TYPE zif_abapgit_lang_definitions=>ty_langus OPTIONAL
          !iv_clsname          TYPE seoclsname
        RAISING
          zcx_abapgit_exception,
      serialize_tpool
        IMPORTING
          !ii_xml              TYPE REF TO zif_abapgit_xml_output
          !it_langu_additional TYPE zif_abapgit_lang_definitions=>ty_langus OPTIONAL
          !iv_clsname          TYPE seoclsname
        RAISING
          zcx_abapgit_exception,
      serialize_sotr
        IMPORTING
          !ii_xml TYPE REF TO zif_abapgit_xml_output
        RAISING
          zcx_abapgit_exception,
      source_apack_replacement
        CHANGING
          !ct_source TYPE seop_source_string
        RAISING
          zcx_abapgit_exception,
      repo_apack_replacement
        CHANGING
          !ct_source TYPE seop_source_string
        RAISING
          zcx_abapgit_exception.

  PRIVATE SECTION.
    METHODS:
      is_class_locked
        RETURNING VALUE(rv_is_class_locked) TYPE abap_bool
        RAISING   zcx_abapgit_exception.
    METHODS interface_replacement
      IMPORTING
        !iv_from_interface TYPE seoclsname
        !iv_to_interface   TYPE seoclsname
      CHANGING
        !ct_source         TYPE seop_source_string .
ENDCLASS.



CLASS ZCL_ABAPGIT_OBJECT_CLAS IMPLEMENTATION.


  METHOD constructor.
    super->constructor( is_item     = is_item
                        iv_language = iv_language ).

    CREATE OBJECT mi_object_oriented_object_fct TYPE zcl_abapgit_oo_class.

    mv_classpool_name = cl_oo_classname_service=>get_classpool_name( |{ is_item-obj_name }| ).

  ENDMETHOD.


  METHOD deserialize_abap.

    DATA: ls_vseoclass             TYPE vseoclass,
          lt_source                TYPE seop_source_string,
          lt_local_definitions     TYPE seop_source_string,
          lt_local_implementations TYPE seop_source_string,
          lt_local_macros          TYPE seop_source_string,
          lt_test_classes          TYPE seop_source_string,
          lt_descriptions          TYPE zif_abapgit_oo_object_fnc=>ty_seocompotx_tt,
          ls_class_key             TYPE seoclskey,
          lt_attributes            TYPE zif_abapgit_definitions=>ty_obj_attribute_tt.


    lt_source = mo_files->read_abap( ).

    lt_local_definitions = mo_files->read_abap( iv_extra = zif_abapgit_oo_object_fnc=>c_parts-locals_def
                                                iv_error = abap_false ).

    lt_local_implementations = mo_files->read_abap( iv_extra = zif_abapgit_oo_object_fnc=>c_parts-locals_imp
                                                    iv_error = abap_false ).

    lt_local_macros = mo_files->read_abap( iv_extra = zif_abapgit_oo_object_fnc=>c_parts-macros
                                           iv_error = abap_false ).

    lt_test_classes = mo_files->read_abap( iv_extra = zif_abapgit_oo_object_fnc=>c_parts-testclasses
                                           iv_error = abap_false ).

    ls_class_key-clsname = ms_item-obj_name.

    ii_xml->read( EXPORTING iv_name = 'VSEOCLASS'
                  CHANGING  cg_data = ls_vseoclass ).

    ii_xml->read( EXPORTING iv_name = 'ATTRIBUTES'
                  CHANGING  cg_data = lt_attributes ).

    "" Remove code for test classes if they have been deleted
    IF ls_vseoclass-with_unit_tests = abap_false.
      CLEAR lt_test_classes.
    ENDIF.

    mi_object_oriented_object_fct->create(
      EXPORTING
        iv_package    = iv_package
        it_attributes = lt_attributes
      CHANGING
        cg_properties = ls_vseoclass ).

    mi_object_oriented_object_fct->generate_locals(
      is_key                   = ls_class_key
      it_local_definitions     = lt_local_definitions
      it_local_implementations = lt_local_implementations
      it_local_macros          = lt_local_macros
      it_local_test_classes    = lt_test_classes ).

    repo_apack_replacement( CHANGING ct_source = lt_source ).
    mi_object_oriented_object_fct->deserialize_source(
      is_key    = ls_class_key
      it_source = lt_source ).

    ii_xml->read( EXPORTING iv_name = 'DESCRIPTIONS'
                  CHANGING cg_data = lt_descriptions ).

    mi_object_oriented_object_fct->update_descriptions(
      is_key          = ls_class_key
      it_descriptions = lt_descriptions ).

    mi_object_oriented_object_fct->add_to_activation_list( ms_item ).

  ENDMETHOD.


  METHOD deserialize_docu.

    DATA: lt_lines      TYPE tlinetab,
          lv_object     TYPE dokhl-object,
          lt_i18n_lines TYPE zif_abapgit_lang_definitions=>ty_i18n_lines,
          ls_i18n_lines TYPE zif_abapgit_lang_definitions=>ty_i18n_line.

    ii_xml->read( EXPORTING iv_name = 'LINES'
                  CHANGING cg_data = lt_lines ).

    IF lines( lt_lines ) = 0.
      RETURN.
    ENDIF.

    lv_object = ms_item-obj_name.

    mi_object_oriented_object_fct->create_documentation(
      it_lines       = lt_lines
      iv_object_name = lv_object
      iv_language    = mv_language ).

    ii_xml->read( EXPORTING iv_name = 'I18N_LINES'
                  CHANGING cg_data = lt_i18n_lines ).

    LOOP AT lt_i18n_lines INTO ls_i18n_lines.
      mi_object_oriented_object_fct->create_documentation(
        it_lines         = ls_i18n_lines-lines
        iv_object_name   = lv_object
        iv_language      = ls_i18n_lines-language
        iv_no_masterlang = abap_true ).
    ENDLOOP.

  ENDMETHOD.


  METHOD deserialize_sotr.
    ""OTR stands for Online Text Repository
    mi_object_oriented_object_fct->create_sotr(
      iv_object_name = ms_item-obj_name
      iv_package     = iv_package
      ii_xml         = ii_ml ).
  ENDMETHOD.


  METHOD deserialize_tpool.

    DATA: lv_clsname    TYPE seoclsname,
          lt_tpool_ext  TYPE zif_abapgit_definitions=>ty_tpool_tt,
          lt_tpool      TYPE textpool_table,
          lt_i18n_tpool TYPE zif_abapgit_lang_definitions=>ty_i18n_tpools,
          ls_i18n_tpool TYPE zif_abapgit_lang_definitions=>ty_i18n_tpool.


    ii_xml->read( EXPORTING iv_name = 'TPOOL'
                  CHANGING cg_data = lt_tpool_ext ).
    lt_tpool = read_tpool( lt_tpool_ext ).

    IF lines( lt_tpool ) = 0.
      RETURN.
    ENDIF.

    lv_clsname = ms_item-obj_name.

    mi_object_oriented_object_fct->insert_text_pool(
      iv_class_name = lv_clsname
      it_text_pool  = lt_tpool
      iv_language   = mv_language ).

    ii_xml->read( EXPORTING iv_name = 'I18N_TPOOL'
                  CHANGING  cg_data = lt_i18n_tpool ).

    LOOP AT lt_i18n_tpool INTO ls_i18n_tpool.
      lt_tpool = read_tpool( ls_i18n_tpool-textpool ).
      mi_object_oriented_object_fct->insert_text_pool(
        iv_class_name = lv_clsname
        it_text_pool  = lt_tpool
        iv_language   = ls_i18n_tpool-language
        iv_state      = 'A' ).
    ENDLOOP.

  ENDMETHOD.


  METHOD interface_replacement.

    DATA lv_tabix TYPE sy-tabix.

    FIELD-SYMBOLS <lv_source> LIKE LINE OF ct_source.

    FIND REGEX '^\\s*INTERFACES(:| )\\s*' && iv_from_interface && '\\s*.' IN TABLE ct_source MATCH LINE lv_tabix.
    IF sy-subrc = 0.
      READ TABLE ct_source ASSIGNING <lv_source> INDEX lv_tabix.
      ASSERT sy-subrc = 0.

      REPLACE FIRST OCCURRENCE OF iv_from_interface IN <lv_source>
                             WITH iv_to_interface IGNORING CASE.

      REPLACE ALL OCCURRENCES OF iv_from_interface && '~descriptor' IN TABLE ct_source
                            WITH iv_to_interface && '~descriptor' IGNORING CASE.
      REPLACE ALL OCCURRENCES OF iv_from_interface && '=>' IN TABLE ct_source
                            WITH iv_to_interface && '=>' IGNORING CASE.
      REPLACE ALL OCCURRENCES OF iv_from_interface && '->' IN TABLE ct_source
                            WITH iv_to_interface && '->' IGNORING CASE.
    ENDIF.

  ENDMETHOD.


  METHOD is_class_locked.

    DATA: lv_argument TYPE seqg3-garg.

    lv_argument = ms_item-obj_name.
    OVERLAY lv_argument WITH '=============================='.
    lv_argument = lv_argument && '*'.

    rv_is_class_locked = exists_a_lock_entry_for( iv_lock_object = 'ESEOCLASS'
                                                  iv_argument    = lv_argument ).

  ENDMETHOD.


  METHOD repo_apack_replacement.

    DATA lv_apack TYPE seoclsname.

    "" Check if SAP-version of APACK manifest exists
    SELECT SINGLE clsname INTO lv_apack
      FROM seoclass
      WHERE clsname = zif_abapgit_apack_definitions=>c_apack_interface_sap.
    IF sy-subrc = 0.
      RETURN.
    ENDIF.

    "" If not, replace with abapGit version
    interface_replacement(
      EXPORTING
        iv_from_interface = to_lower( zif_abapgit_apack_definitions=>c_apack_interface_sap )
        iv_to_interface   = to_lower( zif_abapgit_apack_definitions=>c_apack_interface_cust )
      CHANGING
        ct_source         = ct_source ).

  ENDMETHOD.


  METHOD serialize_attr.

    DATA: lt_attributes TYPE zif_abapgit_definitions=>ty_obj_attribute_tt.

    lt_attributes = mi_object_oriented_object_fct->read_attributes( iv_clsname ).
    IF lines( lt_attributes ) = 0.
      RETURN.
    ENDIF.

    ii_xml->add( iv_name = 'ATTRIBUTES'
                 ig_data = lt_attributes ).

  ENDMETHOD.


  METHOD serialize_descr.

    DATA: lt_descriptions TYPE zif_abapgit_oo_object_fnc=>ty_seocompotx_tt,
          lv_language     TYPE spras.

    IF ii_xml->i18n_params( )-main_language_only = abap_true.
      lv_language = mv_language.
    ENDIF.

    lt_descriptions = mi_object_oriented_object_fct->read_descriptions(
      iv_obejct_name = iv_clsname
      iv_language = lv_language ).

    IF lines( lt_descriptions ) = 0.
      RETURN.
    ENDIF.

    ii_xml->add( iv_name = 'DESCRIPTIONS'
                 ig_data = lt_descriptions ).

  ENDMETHOD.


  METHOD serialize_docu.

    DATA: lt_lines      TYPE tlinetab,
          lv_langu      TYPE sy-langu,
          lt_i18n_lines TYPE zif_abapgit_lang_definitions=>ty_i18n_lines,
          ls_i18n_lines TYPE zif_abapgit_lang_definitions=>ty_i18n_line.

    lt_lines = mi_object_oriented_object_fct->read_documentation(
      iv_class_name = iv_clsname
      iv_language   = mv_language ).
    IF lines( lt_lines ) > 0.
      ii_xml->add( iv_name = 'LINES'
                   ig_data = lt_lines ).
    ENDIF.

    IF ii_xml->i18n_params( )-main_language_only = abap_true.
      RETURN.
    ENDIF.

    LOOP AT it_langu_additional INTO lv_langu.

      lt_lines = mi_object_oriented_object_fct->read_documentation(
        iv_class_name = iv_clsname
        iv_language   = lv_langu ).

      IF lines( lt_lines ) > 0.
        CLEAR ls_i18n_lines.
        ls_i18n_lines-language = lv_langu.
        ls_i18n_lines-lines    = lt_lines.
        INSERT ls_i18n_lines INTO TABLE lt_i18n_lines.
      ENDIF.

    ENDLOOP.

    IF lines( lt_i18n_lines ) > 0.
      ii_xml->add( iv_name = 'I18N_LINES'
                   ig_data = lt_i18n_lines ).
    ENDIF.

  ENDMETHOD.


  METHOD serialize_sotr.
    mi_object_oriented_object_fct->read_sotr(
      iv_object_name = ms_item-obj_name
      ii_xml         = ii_xml ).
  ENDMETHOD.


  METHOD serialize_tpool.

    DATA: lt_tpool      TYPE textpool_table,
          lv_index      TYPE i,
          lv_langu      TYPE sy-langu,
          lt_i18n_tpool TYPE zif_abapgit_lang_definitions=>ty_i18n_tpools,
          ls_i18n_tpool TYPE zif_abapgit_lang_definitions=>ty_i18n_tpool.

    FIELD-SYMBOLS <ls_tpool> LIKE LINE OF lt_tpool.

    DATA lt_tpool_main LIKE SORTED TABLE OF <ls_tpool> WITH UNIQUE KEY id key.

    lt_tpool = mi_object_oriented_object_fct->read_text_pool(
      iv_class_name = iv_clsname
      iv_language   = mv_language ).
    ii_xml->add( iv_name = 'TPOOL'
                 ig_data = add_tpool( lt_tpool ) ).

    IF ii_xml->i18n_params( )-main_language_only = abap_true OR lines( lt_tpool ) = 0.
      RETURN.
    ENDIF.

    lt_tpool_main = lt_tpool.

    LOOP AT it_langu_additional INTO lv_langu.

      lt_tpool = mi_object_oriented_object_fct->read_text_pool(
        iv_class_name = iv_clsname
        iv_language   = lv_langu ).

      LOOP AT lt_tpool ASSIGNING <ls_tpool>.
        lv_index = sy-tabix.
        READ TABLE lt_tpool_main WITH KEY id = <ls_tpool>-id key = <ls_tpool>-key
          TRANSPORTING NO FIELDS.
        IF sy-subrc <> 0.
          DELETE lt_tpool INDEX lv_index.
        ENDIF.
      ENDLOOP.

      IF lines( lt_tpool ) > 0.
        CLEAR ls_i18n_tpool.
        ls_i18n_tpool-language = lv_langu.
        ls_i18n_tpool-textpool = add_tpool( lt_tpool ).
        INSERT ls_i18n_tpool INTO TABLE lt_i18n_tpool.
      ENDIF.

    ENDLOOP.

    IF lines( lt_i18n_tpool ) > 0.
      ii_xml->add( iv_name = 'I18N_TPOOL'
                   ig_data = lt_i18n_tpool ).
    ENDIF.

  ENDMETHOD.


  METHOD serialize_xml.

    DATA: ls_vseoclass        TYPE vseoclass,
          ls_clskey           TYPE seoclskey,
          lt_langu_additional TYPE zif_abapgit_lang_definitions=>ty_langus.

    ls_clskey-clsname = ms_item-obj_name.

    ""If class was deserialized with a previous versions of abapGit and current language was different
    ""from main language at this time, this call would return SY-LANGU as main language. To fix
    ""these objects, set SY-LANGU to main language temporarily.
    zcl_abapgit_language=>set_current_language( mv_language ).

    TRY.
        ls_vseoclass = mi_object_oriented_object_fct->get_class_properties( ls_clskey ).

      CLEANUP.
        zcl_abapgit_language=>restore_login_language( ).

    ENDTRY.

    zcl_abapgit_language=>restore_login_language( ).

    CLEAR: ls_vseoclass-uuid,
           ls_vseoclass-author,
           ls_vseoclass-createdon,
           ls_vseoclass-changedby,
           ls_vseoclass-changedon,
           ls_vseoclass-r3release,
           ls_vseoclass-chgdanyby,
           ls_vseoclass-chgdanyon,
           ls_vseoclass-clsfinal,
           ls_vseoclass-clsabstrct,
           ls_vseoclass-exposure,
           ls_vseoclass-version.

    IF mv_skip_testclass = abap_true.
      CLEAR ls_vseoclass-with_unit_tests.
    ENDIF.

    "" Table d010tinf stores info. on languages in which program is maintained
    "" Select all active translations of program texts
    "" Skip main language - it was already serialized
    SELECT DISTINCT language
      INTO TABLE lt_langu_additional
      FROM d010tinf
      WHERE r3state  = 'A'
        AND prog     = mv_classpool_name
        AND language <> mv_language.

    ii_xml->add( iv_name = 'VSEOCLASS'
                 ig_data = ls_vseoclass ).

    serialize_tpool( ii_xml              = ii_xml
                     iv_clsname          = ls_clskey-clsname
                     it_langu_additional = lt_langu_additional ).

    IF ls_vseoclass-category = seoc_category_exception.
      serialize_sotr( ii_xml ).
    ENDIF.

    serialize_docu( ii_xml              = ii_xml
                    iv_clsname          = ls_clskey-clsname
                    it_langu_additional = lt_langu_additional ).

    serialize_descr( ii_xml     = ii_xml
                     iv_clsname = ls_clskey-clsname ).

    serialize_attr( ii_xml     = ii_xml
                    iv_clsname = ls_clskey-clsname ).

  ENDMETHOD.


  METHOD source_apack_replacement.

    DATA lv_clsname TYPE seoclsname.

    "" Check if abapGit version of APACK manifest is used
    SELECT SINGLE clsname INTO lv_clsname
      FROM seometarel
      WHERE clsname    = ms_item-obj_name
        AND refclsname = zif_abapgit_apack_definitions=>c_apack_interface_cust
        AND version    = '1'.
    IF sy-subrc <> 0.
      RETURN.
    ENDIF.

    "" If yes, replace with SAP-version
    interface_replacement(
      EXPORTING
        iv_from_interface = to_lower( zif_abapgit_apack_definitions=>c_apack_interface_cust )
        iv_to_interface   = to_lower( zif_abapgit_apack_definitions=>c_apack_interface_sap )
      CHANGING
        ct_source         = ct_source ).

  ENDMETHOD.


  METHOD zif_abapgit_object~changed_by.

    TYPES: BEGIN OF ty_includes,
             programm TYPE programm,
           END OF ty_includes.

    TYPES: BEGIN OF ty_reposrc,
             unam  TYPE reposrc-unam,
             udat  TYPE reposrc-udat,
             utime TYPE reposrc-utime,
           END OF ty_reposrc.

    DATA: lt_reposrc  TYPE STANDARD TABLE OF ty_reposrc,
          ls_reposrc  LIKE LINE OF lt_reposrc,
          lt_includes TYPE STANDARD TABLE OF ty_includes.

    lt_includes = mi_object_oriented_object_fct->get_includes( ms_item-obj_name ).
    ASSERT lines( lt_includes ) > 0.

    SELECT unam udat utime FROM reposrc
      INTO TABLE lt_reposrc
      FOR ALL ENTRIES IN lt_includes
      WHERE progname = lt_includes-programm
      AND r3state = 'A'.
    IF sy-subrc <> 0.
      rv_user = c_user_unknown.
    ELSE.
      SORT lt_reposrc BY udat DESCENDING utime DESCENDING.
      READ TABLE lt_reposrc INDEX 1 INTO ls_reposrc.
      ASSERT sy-subrc = 0.
      rv_user = ls_reposrc-unam.
    ENDIF.

  ENDMETHOD.


  METHOD zif_abapgit_object~delete.
    DATA: ls_clskey TYPE seoclskey.
    ls_clskey-clsname = ms_item-obj_name.

    mi_object_oriented_object_fct->delete( ls_clskey ).
  ENDMETHOD.


  METHOD zif_abapgit_object~deserialize.

    deserialize_abap( ii_xml     = io_xml
                      iv_package = iv_package ).

    deserialize_tpool( io_xml ).

    deserialize_sotr( ii_ml     = io_xml
                      iv_package = iv_package ).

    deserialize_docu( io_xml ).

  ENDMETHOD.


  METHOD zif_abapgit_object~exists.
    DATA: ls_class_key TYPE seoclskey.
    ls_class_key-clsname = ms_item-obj_name.

    rv_bool = mi_object_oriented_object_fct->exists( ls_class_key ).
  ENDMETHOD.


  METHOD zif_abapgit_object~get_comparator.
    RETURN.
  ENDMETHOD.


  METHOD zif_abapgit_object~get_deserialize_steps.
    APPEND zif_abapgit_object=>gc_step_id-abap TO rt_steps.
  ENDMETHOD.


  METHOD zif_abapgit_object~get_metadata.
    rs_metadata = get_metadata( ).
  ENDMETHOD.


  METHOD zif_abapgit_object~is_active.
    rv_active = is_active( ).
  ENDMETHOD.


  METHOD zif_abapgit_object~is_locked.

    IF is_class_locked( ) = abap_true OR is_text_locked( mv_classpool_name ) = abap_true.
      rv_is_locked = abap_true.
    ENDIF.

  ENDMETHOD.


  METHOD zif_abapgit_object~jump.
    CALL FUNCTION 'RS_TOOL_ACCESS'
      EXPORTING
        operation     = 'SHOW'
        object_name   = ms_item-obj_name
        object_type   = 'CLAS'
        in_new_window = abap_true.
  ENDMETHOD.


  METHOD zif_abapgit_object~serialize.

    DATA: lt_source    TYPE seop_source_string,
          ls_class_key TYPE seoclskey.

    ls_class_key-clsname = ms_item-obj_name.

    IF zif_abapgit_object~exists( ) = abap_false.
      RETURN.
    ENDIF.

    CALL FUNCTION 'SEO_BUFFER_REFRESH'
      EXPORTING
        version = seoc_version_active
        force   = abap_true.
    CALL FUNCTION 'SEO_BUFFER_REFRESH'
      EXPORTING
        version = seoc_version_inactive
        force   = abap_true.

    lt_source = mi_object_oriented_object_fct->serialize_abap( ls_class_key ).

    source_apack_replacement( CHANGING ct_source = lt_source ).

    mo_files->add_abap( lt_source ).

    lt_source = mi_object_oriented_object_fct->serialize_abap(
      is_class_key = ls_class_key
      iv_type      = seop_ext_class_locals_def ).
    IF lines( lt_source ) > 0.
      mo_files->add_abap( iv_extra = zif_abapgit_oo_object_fnc=>c_parts-locals_def
                          it_abap  = lt_source ).
    ENDIF.

    lt_source = mi_object_oriented_object_fct->serialize_abap(
      is_class_key = ls_class_key
      iv_type      = seop_ext_class_locals_imp ).
    IF lines( lt_source ) > 0.
      mo_files->add_abap( iv_extra = zif_abapgit_oo_object_fnc=>c_parts-locals_imp
                          it_abap  = lt_source ).
    ENDIF.

    lt_source = mi_object_oriented_object_fct->serialize_abap(
      is_class_key            = ls_class_key
      iv_type                 = seop_ext_class_testclasses ).

    mv_skip_testclass = mi_object_oriented_object_fct->get_skip_test_classes( ).
    IF lines( lt_source ) > 0 AND mv_skip_testclass = abap_false.
      mo_files->add_abap( iv_extra = zif_abapgit_oo_object_fnc=>c_parts-testclasses
                          it_abap  = lt_source ).
    ENDIF.

    lt_source = mi_object_oriented_object_fct->serialize_abap(
      is_class_key = ls_class_key
      iv_type      = seop_ext_class_macros ).
    IF lines( lt_source ) > 0.
      mo_files->add_abap( iv_extra = zif_abapgit_oo_object_fnc=>c_parts-macros
                          it_abap  = lt_source ).
    ENDIF.

    serialize_xml( io_xml ).

  ENDMETHOD.
ENDCLASS.
",5825,False,1282.7336152980083,median
"// Copyright 2021 The IREE Authors
//
// Licensed under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

#include ""iree/compiler/Dialect/Stream/IR/StreamOps.h""

#include ""iree/compiler/Dialect/Stream/Builtins/Builtins.h""
#include ""iree/compiler/Dialect/Util/IR/ClosureOpUtils.h""
#include ""iree/compiler/Dialect/Util/IR/UtilOps.h""
#include ""iree/compiler/Dialect/Util/IR/UtilTypes.h""
#include ""iree/compiler/Utils/ModuleUtils.h""
#include ""llvm/ADT/BitVector.h""
#include ""llvm/ADT/StringExtras.h""
#include ""llvm/Support/CommandLine.h""
#include ""mlir/Dialect/Arithmetic/IR/Arithmetic.h""
#include ""mlir/Dialect/Func/IR/FuncOps.h""
#include ""mlir/IR/Attributes.h""
#include ""mlir/IR/BlockAndValueMapping.h""
#include ""mlir/IR/Builders.h""
#include ""mlir/IR/BuiltinTypes.h""
#include ""mlir/IR/Matchers.h""
#include ""mlir/IR/OpDefinition.h""
#include ""mlir/IR/OpImplementation.h""
#include ""mlir/IR/PatternMatch.h""
#include ""mlir/IR/SymbolTable.h""
#include ""mlir/IR/TypeUtilities.h""
#include ""mlir/Support/LogicalResult.h""
#include ""mlir/Transforms/RegionUtils.h""

namespace mlir {
namespace iree_compiler {
namespace IREE {
namespace Stream {

//===----------------------------------------------------------------------===//
// Op utilities used within the stream dialect
//===----------------------------------------------------------------------===//

// TODO(hanchung): Have a better fix. This is a fix for
// https://reviews.llvm.org/D124649
static void createArgs(ArrayRef<OpAsmParser::UnresolvedOperand> operands,
                       ArrayRef<Type> types,
                       SmallVector<OpAsmParser::Argument> &args) {
  for (auto argAndType : llvm::zip(operands, types)) {
    auto &arg = args.emplace_back();
    arg.ssaName = std::get<0>(argAndType);
    arg.type = std::get<1>(argAndType);
  }
}

// Verifies that |dynamicDims| contains the appropriate number of dims for all
// of the dynamic dimensions in |values|.
static LogicalResult verifyOpDynamicDims(Operation *op, ValueRange values,
                                         ValueRange dynamicDims) {
  unsigned requiredCount = 0;
  for (auto value : values) {
    if (auto shapedType = value.getType().dyn_cast<ShapedType>()) {
      requiredCount += shapedType.getNumDynamicDims();
    }
  }
  if (dynamicDims.size() != requiredCount) {
    return op->emitOpError()
           << ""value set has "" << requiredCount
           << "" dynamic dimensions but only "" << dynamicDims.size()
           << "" dimension values are attached"";
  }
  return success();
}

// Verifies that |dynamicDims| contains the appropriate number of dims for all
// the dynamic dimensions in |type|.
static LogicalResult verifyOpDynamicDims(Operation *op, TypeRange types,
                                         ValueRange dynamicDims) {
  unsigned requiredCount = 0;
  for (auto type : types) {
    if (auto shapedType = type.dyn_cast<ShapedType>()) {
      requiredCount += shapedType.getNumDynamicDims();
    }
  }
  if (dynamicDims.size() != requiredCount) {
    return op->emitOpError()
           << ""type set has "" << requiredCount
           << "" dynamic dimensions but only "" << dynamicDims.size()
           << "" dimension values are attached"";
  }
  return success();
}

// Verifies that |sizes| contains the appropriate number of sizes for all of the
// sized types in |values|.
static LogicalResult verifyOpValueSizes(Operation *op, ValueRange values,
                                        ValueRange sizes) {
  unsigned requiredCount = 0;
  for (auto value : values) {
    if (value.getType().isa<IREE::Util::SizeAwareTypeInterface>()) {
      ++requiredCount;
    }
  }
  if (sizes.size() != requiredCount) {
    return op->emitOpError() << ""value set has "" << requiredCount
                             << "" dynamic dimensions but only "" << sizes.size()
                             << "" dimension values are attached"";
  }
  return success();
}

// Verifies that all !stream.resources used within |region| are captured by
// the entry arguments to the region.
static LogicalResult verifyAllResourcesCaptured(Region &region) {
  SetVector<Value> availableResources;
  for (auto arg : region.front().getArguments()) {
    availableResources.insert(arg);
  }
  for (auto &op : region.front()) {
    for (auto result : op.getResults()) {
      availableResources.insert(result);
    }
    for (auto operand : op.getOperands()) {
      if (!operand.getType().isa<IREE::Stream::ResourceType>()) continue;
      if (!availableResources.contains(operand)) {
        return op.emitOpError() << ""used resource not listed in explicit ""
                                   ""captures (or produced internally)"";
      }
    }
  }
  return success();
}

// Verifies that escaping !stream.resources have the sizes when they are
// yielded match the sizes declared on the parent op. This information is
// redundant but keeps analysis local and agnostic to the parent op structure
// which is useful for when we outline things.
static LogicalResult verifyEscapingResources(Region &region,
                                             ResultRange results,
                                             ValueRange resultSizes) {
  // Ensure yielded resources match the signature.
  for (auto yieldOp : region.getOps<IREE::Stream::YieldOp>()) {
    if (results.size() != yieldOp.operands().size()) {
      return yieldOp.emitOpError()
             << ""yield result count mismatch with parent op"";
    }
    for (auto it : llvm::zip(results, yieldOp.operands())) {
      auto outerValue = std::get<0>(it);
      auto innerValue = std::get<1>(it);
      if (outerValue.getType() != innerValue.getType()) {
        return yieldOp.emitOpError()
               << ""result type mismatch: expected "" << outerValue.getType()
               << "" but got "" << innerValue.getType();
      }
    }
    for (auto it : llvm::zip(resultSizes, yieldOp.operand_sizes())) {
      auto outerSize = std::get<0>(it);
      auto innerSize = std::get<1>(it);
      if (outerSize != innerSize) {
        return yieldOp.emitOpError() << ""result size mismatch"";
      }
    }
  }
  return success();
}

// Computes the value access bits starting from |rootValue|.
// Traverses the IR graph along tied ops but does not handle branches.
static IREE::Util::ValueAccess computeValueAccess(Value rootValue) {
  IREE::Util::ValueAccess access;
  DenseSet<Value> processedValues;
  SmallVector<Value> worklist;
  auto enqueueValue = [&](Value value) {
    if (processedValues.contains(value)) return;
    processedValues.insert(value);
    worklist.push_back(value);
  };
  enqueueValue(rootValue);
  while (!worklist.empty()) {
    Value value = worklist.back();
    worklist.pop_back();

    // Walk up the definition chain.
    if (auto definingOp = value.getDefiningOp()) {
      // Value is produced within the region and thus written.
      access.isWrite = true;
      if (auto tiedOp = dyn_cast<IREE::Util::TiedOpInterface>(definingOp)) {
        access.isRead = true;
        auto operand = tiedOp.getTiedResultOperand(value);
        if (operand) {
          // Value is tied back to another value; continue analyzing past it.
          enqueueValue(operand);
        } else {
          // Value contents are fully produced by this op.
          access.isDiscard = true;
        }
      } else if (isa<IREE::Stream::SubviewEffectOpInterface>(definingOp)) {
        // TODO(benvanik): actually query; for now assume *.
        access.isRead = true;
        access.isWrite = true;
      } else {
        // Value contents are fully produced by this op.
        access.isDiscard = true;
      }
    }

    // Walk down the use chain.
    for (auto user : value.getUsers()) {
      // Used by an op.
      access.isRead = true;
      if (auto tiedOp = dyn_cast<IREE::Util::TiedOpInterface>(user)) {
        auto tiedIndices = tiedOp.getTiedResultOperandIndices();
        for (int64_t tiedIndex : tiedIndices) {
          if (tiedIndex == IREE::Util::TiedOpInterface::kUntiedIndex) continue;
          auto operand = user->getOperand(tiedIndex);
          if (operand == value) {
            // Tied operand.
            access.isRead = true;
            access.isWrite = true;
            enqueueValue(operand);
          }
        }
      } else if (isa<IREE::Stream::SubviewEffectOpInterface>(user)) {
        // TODO(benvanik): actually query; for now assume *.
        access.isRead = true;
        access.isWrite = true;
      }
    }
  }
  return access;
}

static void eraseStreamRegionResults(Region &region,
                                     ArrayRef<unsigned> excludedResultIndices) {
  for (auto &block : region.getBlocks()) {
    auto yieldOp = dyn_cast<IREE::Stream::YieldOp>(block.getTerminator());
    if (!yieldOp) continue;
    llvm::SmallVector<Value, 4> newOperands;
    for (auto i : llvm::reverse(excludedResultIndices)) {
      yieldOp.operandsMutable().erase(i);
      yieldOp.operand_sizesMutable().erase(i);
    }
  }
}

//===----------------------------------------------------------------------===//
// custom<ResourceRegion>($operands, type($operands), $operand_sizes,
//                        type($results), $result_sizes,
//                        $tied_operands, $body)
//===----------------------------------------------------------------------===//

static ParseResult parseResourceRegion(
    OpAsmParser &parser,
    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operands,
    SmallVectorImpl<Type> &operandTypes,
    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operandSizes,
    SmallVectorImpl<Type> &resultTypes,
    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &resultSizes,
    ArrayAttr &tiedOperands, Region &body) {
  SmallVector<OpAsmParser::UnresolvedOperand, 16> regionArgs;
  if (failed(parser.parseLParen())) {
    return failure();
  }
  if (failed(parser.parseOptionalRParen())) {
    do {
      // Reserve entries in the lists.
      operands.emplace_back();
      operandTypes.emplace_back();
      operandSizes.emplace_back();
      regionArgs.emplace_back();
      if (failed(parser.parseOperand(operands.back())) ||
          failed(parser.parseKeyword(""as"")) ||
          failed(parser.parseOperand(regionArgs.back(),
                                     /*allowResultNumber=*/false)) ||
          failed(parser.parseColon()) ||
          failed(parseSizeAwareType(parser, operandTypes.back(),
                                    operandSizes.back()))) {
        return failure();
      }
    } while (succeeded(parser.parseOptionalComma()));
    if (failed(parser.parseRParen())) {
      return failure();
    }
  }

  if (succeeded(parser.parseOptionalArrow())) {
    if (succeeded(parser.parseOptionalLParen())) {
      if (succeeded(parser.parseOptionalRParen())) {
        // -> ()
      } else if (failed(parseShapedResultList(parser, operands, operandTypes,
                                              operandSizes, resultTypes,
                                              resultSizes, tiedOperands)) ||
                 failed(parser.parseRParen())) {
        return failure();
      }
    } else {
      if (failed(parseShapedResultList(parser, operands, operandTypes,
                                       operandSizes, resultTypes, resultSizes,
                                       tiedOperands))) {
        return failure();
      }
    }
  }

  SmallVector<OpAsmParser::Argument> args;
  createArgs(regionArgs, operandTypes, args);
  return parser.parseRegion(body, args);
}

static void printResourceRegion(OpAsmPrinter &p, Operation *op,
                                ValueRange operands, TypeRange operandTypes,
                                ValueRange operandSizes, TypeRange resultTypes,
                                ValueRange resultSizes, ArrayAttr tiedOperands,
                                Region &body) {
  p << ""("";
  llvm::interleaveComma(
      llvm::zip(operands, body.getArguments()), p, [&](auto it) {
        auto operand = std::get<0>(it);
        auto arg = std::get<1>(it);
        p << operand;
        p << "" as "";
        p << arg;
        p << "": "";
        p << arg.getType();
        if (arg.getType().template isa<IREE::Util::SizeAwareTypeInterface>()) {
          p << ""{"" << operandSizes.front() << ""}"";
          operandSizes = operandSizes.drop_front(1);
        }
      });
  p << "")"";
  if (!resultTypes.empty()) {
    p << "" -> "";
    if (resultTypes.size() != 1) p << ""("";
    printShapedResultList(p, op, operands, operandTypes, operandSizes,
                          resultTypes, resultSizes, tiedOperands);
    if (resultTypes.size() != 1) p << "")"";
  }
  p << "" "";
  p.printRegion(body, /*printEntryBlockArgs=*/false,
                /*printBlockTerminators=*/true);
}

//===----------------------------------------------------------------------===//
// custom<ExplicitResourceRegion>($operands, type($operands), $operand_sizes,
//                                $body)
//===----------------------------------------------------------------------===//

static ParseResult parseExplicitResourceRegion(
    OpAsmParser &parser,
    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operands,
    SmallVectorImpl<Type> &operandTypes,
    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operandSizes,
    Region &body) {
  SmallVector<OpAsmParser::UnresolvedOperand, 16> regionArgs;
  if (failed(parser.parseLParen())) {
    return failure();
  }
  if (failed(parser.parseOptionalRParen())) {
    do {
      // Reserve entries in the lists.
      operands.emplace_back();
      operandTypes.emplace_back();
      operandSizes.emplace_back();
      regionArgs.emplace_back();
      if (failed(parser.parseOperand(operands.back())) ||
          failed(parser.parseKeyword(""as"")) ||
          failed(parser.parseOperand(regionArgs.back(),
                                     /*allowResultNumber=*/false)) ||
          failed(parser.parseColon()) ||
          failed(parseSizeAwareType(parser, operandTypes.back(),
                                    operandSizes.back()))) {
        return failure();
      }
    } while (succeeded(parser.parseOptionalComma()));
    if (failed(parser.parseRParen())) {
      return failure();
    }
  }
  SmallVector<OpAsmParser::Argument> args;
  createArgs(regionArgs, operandTypes, args);
  if (failed(parser.parseRegion(body, args))) {
    return failure();
  }
  // HACK: I can't figure out how to make this work with the default parsing -
  // it doesn't call this like it should.
  IREE::Stream::CmdExecuteOp::ensureTerminator(
      body, parser.getBuilder(),
      parser.getEncodedSourceLoc(parser.getCurrentLocation()));
  return success();
}

static void printExplicitResourceRegion(OpAsmPrinter &p, Operation *op,
                                        ValueRange operands,
                                        TypeRange operandTypes,
                                        ValueRange operandSizes, Region &body) {
  p << ""("";
  llvm::interleaveComma(
      llvm::zip(operands, body.getArguments()), p, [&](auto it) {
        auto operand = std::get<0>(it);
        auto arg = std::get<1>(it);
        p << operand;
        p << "" as "";
        p << arg;
        p << "": "";
        p << arg.getType();
        if (arg.getType().template isa<IREE::Util::SizeAwareTypeInterface>()) {
          p << ""{"" << operandSizes.front() << ""}"";
          operandSizes = operandSizes.drop_front(1);
        }
      });
  p << "") "";
  p.printRegion(body, /*printEntryBlockArgs=*/false,
                /*printBlockTerminators=*/false);
}

//===----------------------------------------------------------------------===//
// custom<PackSliceRanges>($lifetime_intervals,
//                         $dynamic_slice_sizes,
//                         type($packed_offsets))
//===----------------------------------------------------------------------===//

static ParseResult parsePackSliceRanges(
    OpAsmParser &parser, ArrayAttr &lifetimeIntervals,
    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &dynamicSliceSizes,
    SmallVectorImpl<Type> &packedOffsetTypes) {
  auto indexType = parser.getBuilder().getIndexType();
  SmallVector<Attribute> lifetimeRangeValues;
  do {
    if (failed(parser.parseOptionalLSquare())) break;
    IntegerAttr lifetimeStart;
    IntegerAttr lifetimeEnd;
    OpAsmParser::UnresolvedOperand dynamicSliceSize;
    if (failed(parser.parseAttribute(lifetimeStart, indexType)) ||
        failed(parser.parseComma()) ||
        failed(parser.parseAttribute(lifetimeEnd, indexType)) ||
        failed(parser.parseRSquare()) || failed(parser.parseEqual()) ||
        failed(parser.parseOperand(dynamicSliceSize))) {
      return failure();
    }
    lifetimeRangeValues.push_back(lifetimeStart);
    lifetimeRangeValues.push_back(lifetimeEnd);
    dynamicSliceSizes.push_back(dynamicSliceSize);
    packedOffsetTypes.push_back(indexType);
  } while (succeeded(parser.parseOptionalComma()));
  lifetimeIntervals = parser.getBuilder().getArrayAttr(lifetimeRangeValues);
  return success();
}

static void printPackSliceRanges(OpAsmPrinter &p, Operation *op,
                                 ArrayAttr lifetimeIntervals,
                                 ValueRange dynamicSliceSizes,
                                 TypeRange packedOffsetTypes) {
  if (packedOffsetTypes.empty()) return;
  for (unsigned i = 0; i < packedOffsetTypes.size(); ++i) {
    auto lifetimeStart = lifetimeIntervals[i * 2];
    auto lifetimeEnd = lifetimeIntervals[i * 2 + 1];
    auto sliceSize = dynamicSliceSizes[i];
    p.printNewline();
    p << ""  ["";
    p.printAttributeWithoutType(lifetimeStart);
    p << "", "";
    p.printAttributeWithoutType(lifetimeEnd);
    p << ""] = "";
    p.printOperand(sliceSize);
    if (i < packedOffsetTypes.size() - 1) p << "","";
  }
  p.printNewline();
}

//===----------------------------------------------------------------------===//
// custom<ConstantValueList>(type($results),
//                           $result_sizes,
//                           $values)
//===----------------------------------------------------------------------===//
//   !stream.resource<constant>{%sz} = #value,
//   !stream.resource<constant>{%sz} = #value

static ParseResult parseConstantValueList(
    OpAsmParser &parser, SmallVectorImpl<Type> &resultTypes,
    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &resultSizes,
    ArrayAttr &values) {
  SmallVector<Attribute> valueAttrs;
  do {
    Type resultType;
    OpAsmParser::UnresolvedOperand resultSize;
    Attribute valueAttr;
    if (failed(parseSizeAwareType(parser, resultType, resultSize)) ||
        failed(parser.parseEqual()) ||
        failed(parser.parseAttribute(valueAttr))) {
      return failure();
    }
    resultTypes.push_back(resultType);
    resultSizes.push_back(resultSize);
    valueAttrs.push_back(valueAttr);
  } while (succeeded(parser.parseOptionalComma()));
  values = parser.getBuilder().getArrayAttr(valueAttrs);
  return success();
}

static void printConstantValueList(OpAsmPrinter &p, Operation *op,
                                   TypeRange resultTypes,
                                   ValueRange resultSizes, ArrayAttr values) {
  if (resultTypes.empty()) return;
  for (unsigned i = 0; i < resultTypes.size(); ++i) {
    p.printNewline();
    p << ""  "";
    printSizeAwareType(p, op, resultTypes[i], resultSizes[i]);
    p << "" = "";
    p.printAttribute(values[i]);
    if (i < resultTypes.size() - 1) p << "","";
  }
}

//===----------------------------------------------------------------------===//
// custom<SymbolAlias>($sym_name, $alias)
//===----------------------------------------------------------------------===//
//  @foo            sym_name: @foo, alias: @foo
//  @foo as @bar    sym_name: @bar, alias: @foo

static ParseResult parseSymbolAlias(OpAsmParser &parser, StringAttr &sym_name,
                                    FlatSymbolRefAttr &alias) {
  if (failed(parser.parseAttribute(alias))) {
    return failure();
  }
  if (succeeded(parser.parseOptionalKeyword(""as""))) {
    if (failed(parser.parseLParen()) ||
        failed(parser.parseAttribute(sym_name)) ||
        failed(parser.parseRParen())) {
      return failure();
    }
  } else {
    sym_name = StringAttr::get(parser.getContext(), alias.getValue());
  }
  return success();
}

static void printSymbolAlias(OpAsmPrinter &p, Operation *op,
                             StringAttr sym_name, FlatSymbolRefAttr alias) {
  p.printAttributeWithoutType(alias);
  if (sym_name.getValue() != alias.getValue()) {
    p << "" as(\\"""";
    p.printSymbolName(sym_name.getValue());
    p << ""\\"")"";
  }
}

//===----------------------------------------------------------------------===//
// stream.resource.alloc
//===----------------------------------------------------------------------===//

LogicalResult ResourceAllocOp::verify() {
  ResourceAllocOp op = *this;
  if (failed(verifyOpValueSizes(op, op.results(), op.storage_sizes()))) {
    return failure();
  }

  // All allocated resources must have the same lifetime.
  auto anyType = op.results().front().getType();
  for (auto type : op.getResultTypes()) {
    if (type != anyType) {
      return op.emitError()
             << ""all allocated resources must have the same lifetime"";
    }
  }

  return success();
}

//===----------------------------------------------------------------------===//
// stream.resource.map
//===----------------------------------------------------------------------===//

LogicalResult ResourceMapOp::verify() {
  ResourceMapOp op = *this;
  if (failed(verifyOpValueSizes(op, op.result(), op.result_size()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.resource.try_map
//===----------------------------------------------------------------------===//

LogicalResult ResourceTryMapOp::verify() {
  ResourceTryMapOp op = *this;
  if (failed(verifyOpValueSizes(op, op.result(), op.result_size()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.resource.load
//===----------------------------------------------------------------------===//

LogicalResult ResourceLoadOp::verify() {
  ResourceLoadOp op = *this;
  if (failed(verifyOpValueSizes(op, op.source(), op.source_size()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.resource.store
//===----------------------------------------------------------------------===//

LogicalResult ResourceStoreOp::verify() {
  ResourceStoreOp op = *this;
  if (failed(verifyOpValueSizes(op, op.target(), op.target_size()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.resource.pack
//===----------------------------------------------------------------------===//

void ResourcePackOp::getAsmResultNames(
    function_ref<void(Value, StringRef)> setNameFn) {
  // TODO(benvanik): figure out if we can get the names to coalesce when there
  // are multiple results. Ideally we'd have `%total_length, %offsets:123` but
  // unfortunately all get splatted out and create 10k+ char lines that are a
  // pain to read.
  // setNameFn(total_length(), ""total_length"");
  // for (auto packedOffset : llvm::enumerate(packed_offsets())) {
  // setNameFn(packedOffset.value(),
  //           ""offset"" + std::to_string(packedOffset.index()));
  // }
}

LogicalResult ResourcePackOp::verify() {
  ResourcePackOp op = *this;
  size_t sliceCount = op.packed_offsets().size();
  if (op.lifetime_intervals().size() != sliceCount * 2) {
    return op.emitOpError() << ""requires a [start, end] range for each slice"";
  }
  if (op.dynamic_slice_sizes().size() != sliceCount) {
    return op.emitOpError() << ""requires a size for each slice"";
  }
  return success();
}

SmallVector<ResourcePackOp::Slice> ResourcePackOp::getSlices() {
  auto intervalPairs = lifetime_intervals().getValue();
  auto sizes = dynamic_slice_sizes();
  auto offsets = packed_offsets();
  SmallVector<ResourcePackOp::Slice> slices(offsets.size());
  for (size_t i = 0; i < offsets.size(); ++i) {
    int64_t start = intervalPairs[i * 2 + 0].cast<IntegerAttr>().getInt();
    int64_t end = intervalPairs[i * 2 + 1].cast<IntegerAttr>().getInt();
    slices[i] = {start, end, sizes[i], offsets[i]};
  }
  return slices;
}

//===----------------------------------------------------------------------===//
// stream.resource.constants
//===----------------------------------------------------------------------===//

LogicalResult ResourceConstantsOp::verify() {
  ResourceConstantsOp op = *this;
  size_t count = op.results().size();
  if (op.result_sizes().size() != count || op.values().size() != count) {
    return op.emitOpError() << ""mismatched constant/result counts"";
  }

  // All resources must have the same lifetime.
  auto anyType = op.results().front().getType();
  for (auto result : op.results()) {
    if (result.getType() != anyType) {
      return op.emitError()
             << ""all constant resources must have the same lifetime"";
    }
  }

  return success();
}

//===----------------------------------------------------------------------===//
// stream.resource.subview
//===----------------------------------------------------------------------===//

LogicalResult ResourceSubviewOp::verify() {
  ResourceSubviewOp op = *this;
  if (failed(verifyOpValueSizes(op, op.source(), op.source_size())) ||
      failed(verifyOpValueSizes(op, op.result(), op.result_size()))) {
    return failure();
  }
  return success();
}

bool ResourceSubviewOp::isMetadata() { return true; }

Value ResourceSubviewOp::getViewSource() { return source(); }

Value ResourceSubviewOp::getTiedResult(unsigned resultIndex) {
  return IREE::Util::TiedOpInterface::findTiedBaseValue(source());
}

::llvm::Optional<unsigned> ResourceSubviewOp::getTiedResultOperandIndex(
    unsigned resultIndex) {
  return {0};  // source
}

SmallVector<int64_t, 4> ResourceSubviewOp::getTiedResultOperandIndices() {
  return {0};  // source
}

// static
IREE::Stream::ResourceSubviewOp ResourceSubviewOp::findSubviewOp(Value value) {
  while (value) {
    auto *definingOp = value.getDefiningOp();
    if (!definingOp) {
      // Defined as a block argument - stop walk.
      break;
    } else if (auto subviewOp =
                   dyn_cast<IREE::Stream::ResourceSubviewOp>(definingOp)) {
      // Found!
      return subviewOp;
    } else if (auto tiedOp =
                   dyn_cast<IREE::Util::TiedOpInterface>(definingOp)) {
      // Continue walking up through the tied operand.
      value = tiedOp.getTiedResultOperand(value);
    } else {
      break;
    }
  }
  return {};
}

//===----------------------------------------------------------------------===//
// stream.tensor.import
//===----------------------------------------------------------------------===//

LogicalResult TensorImportOp::verify() {
  TensorImportOp op = *this;
  if (failed(verifyOpDynamicDims(op, op.result_encoding(),
                                 op.result_encoding_dims())) ||
      failed(verifyOpValueSizes(op, op.result(), op.result_size()))) {
    return failure();
  }
  return success();
}

Value TensorImportOp::getTiedResult(unsigned resultIndex) {
  return IREE::Util::TiedOpInterface::findTiedBaseValue(source());
}

::llvm::Optional<unsigned> TensorImportOp::getTiedResultOperandIndex(
    unsigned resultIndex) {
  return {0};  // source
}

SmallVector<int64_t, 4> TensorImportOp::getTiedResultOperandIndices() {
  return {0};  // source
}

//===----------------------------------------------------------------------===//
// stream.tensor.export
//===----------------------------------------------------------------------===//

LogicalResult TensorExportOp::verify() {
  TensorExportOp op = *this;
  if (failed(verifyOpDynamicDims(op, op.source_encoding(),
                                 op.source_encoding_dims())) ||
      failed(verifyOpValueSizes(op, op.source(), op.source_size()))) {
    return failure();
  }
  return success();
}

Value TensorExportOp::getTiedResult(unsigned resultIndex) {
  return IREE::Util::TiedOpInterface::findTiedBaseValue(source());
}

::llvm::Optional<unsigned> TensorExportOp::getTiedResultOperandIndex(
    unsigned resultIndex) {
  return {0};  // source
}

SmallVector<int64_t, 4> TensorExportOp::getTiedResultOperandIndices() {
  return {0};  // source
}

//===----------------------------------------------------------------------===//
// stream.tensor.sizeof
//===----------------------------------------------------------------------===//

LogicalResult TensorSizeOfOp::verify() {
  TensorSizeOfOp op = *this;
  if (failed(verifyOpDynamicDims(op, op.encoding(), op.encoding_dims()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.tensor.empty
//===----------------------------------------------------------------------===//

void TensorEmptyOp::getAsmResultNames(mlir::OpAsmSetValueNameFn setNameFn) {
  setNameFn(result(), ""empty"");
}

LogicalResult TensorEmptyOp::verify() {
  TensorEmptyOp op = *this;
  if (failed(verifyOpDynamicDims(op, op.result_encoding(),
                                 op.result_encoding_dims()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.tensor.constant
//===----------------------------------------------------------------------===//

void TensorConstantOp::getAsmResultNames(mlir::OpAsmSetValueNameFn setNameFn) {
  setNameFn(result(), ""cst"");
}

LogicalResult TensorConstantOp::verify() {
  TensorConstantOp op = *this;
  if (failed(verifyOpDynamicDims(op, op.result_encoding(),
                                 op.result_encoding_dims()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.tensor.splat
//===----------------------------------------------------------------------===//

LogicalResult TensorSplatOp::verify() {
  TensorSplatOp op = *this;
  if (failed(verifyOpDynamicDims(op, op.result_encoding(),
                                 op.result_encoding_dims())) ||
      failed(verifyOpValueSizes(op, op.result(), op.result_size()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.tensor.clone
//===----------------------------------------------------------------------===//

LogicalResult TensorCloneOp::verify() {
  TensorCloneOp op = *this;
  // Clones can't change encodings but they can change shape information.
  auto sourceEncoding = op.source_encoding().cast<RankedTensorType>();
  auto resultEncoding = op.result_encoding().cast<RankedTensorType>();
  if (sourceEncoding.getEncoding() != resultEncoding.getEncoding()) {
    return op.emitOpError() << ""clones changing tensor encoding from ""
                            << sourceEncoding.getEncoding() << "" to ""
                            << resultEncoding.getEncoding() << ""; not allowed"";
  }
  if (failed(verifyOpDynamicDims(op, op.source_encoding(),
                                 op.source_encoding_dims())) ||
      failed(verifyOpDynamicDims(op, op.result_encoding(),
                                 op.result_encoding_dims())) ||
      failed(verifyOpValueSizes(op, op.source(), op.source_size())) ||
      failed(verifyOpValueSizes(op, op.result(), op.result_size()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.tensor.slice
//===----------------------------------------------------------------------===//

LogicalResult TensorSliceOp::verify() {
  TensorSliceOp op = *this;
  if (failed(verifyOpDynamicDims(op, op.source_encoding(),
                                 op.source_encoding_dims())) ||
      failed(verifyOpDynamicDims(op, op.result_encoding(),
                                 op.result_encoding_dims())) ||
      failed(verifyOpValueSizes(op, op.source(), op.source_size())) ||
      failed(verifyOpValueSizes(op, op.result(), op.result_size()))) {
    return failure();
  }
  auto sourceType = op.source_encoding().cast<ShapedType>();
  if (op.start_indices().size() != sourceType.getRank() ||
      op.lengths().size() != sourceType.getRank()) {
    return op.emitOpError() << ""start_indices/lengths rank mismatch"";
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.tensor.update
//===----------------------------------------------------------------------===//

LogicalResult TensorUpdateOp::verify() {
  TensorUpdateOp op = *this;
  if (failed(verifyOpDynamicDims(op, op.update_encoding(),
                                 op.update_encoding_dims())) ||
      failed(verifyOpDynamicDims(op, op.target_encoding(),
                                 op.target_encoding_dims())) ||
      failed(verifyOpValueSizes(op, op.update(), op.update_size())) ||
      failed(verifyOpValueSizes(op, op.result(), op.target_size()))) {
    return failure();
  }
  return success();
}

Value TensorUpdateOp::getTiedResult(unsigned resultIndex) {
  return IREE::Util::TiedOpInterface::findTiedBaseValue(target());
}

::llvm::Optional<unsigned> TensorUpdateOp::getTiedResultOperandIndex(
    unsigned resultIndex) {
  return {0};  // target
}

SmallVector<int64_t, 4> TensorUpdateOp::getTiedResultOperandIndices() {
  return {0};  // target
}

//===----------------------------------------------------------------------===//
// stream.tensor.fill
//===----------------------------------------------------------------------===//

LogicalResult TensorFillOp::verify() {
  TensorFillOp op = *this;
  if (failed(verifyOpDynamicDims(op, op.target_encoding(),
                                 op.target_encoding_dims())) ||
      failed(verifyOpValueSizes(op, op.result(), op.target_size()))) {
    return failure();
  }
  return success();
}

Value TensorFillOp::getTiedResult(unsigned resultIndex) {
  return IREE::Util::TiedOpInterface::findTiedBaseValue(target());
}

::llvm::Optional<unsigned> TensorFillOp::getTiedResultOperandIndex(
    unsigned resultIndex) {
  return {0};  // target
}

SmallVector<int64_t, 4> TensorFillOp::getTiedResultOperandIndices() {
  return {0};  // target
}

//===----------------------------------------------------------------------===//
// stream.tensor.load
//===----------------------------------------------------------------------===//

LogicalResult TensorLoadOp::verify() {
  TensorLoadOp op = *this;
  if (failed(verifyOpDynamicDims(op, op.source_encoding(),
                                 op.source_encoding_dims())) ||
      failed(verifyOpValueSizes(op, op.source(), op.source_size()))) {
    return failure();
  }
  auto sourceType = op.source_encoding().cast<ShapedType>();
  if (op.indices().size() != sourceType.getRank()) {
    return op.emitOpError() << ""indices rank mismatch"";
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.tensor.store
//===----------------------------------------------------------------------===//

LogicalResult TensorStoreOp::verify() {
  TensorStoreOp op = *this;
  if (failed(verifyOpDynamicDims(op, op.target_encoding(),
                                 op.target_encoding_dims())) ||
      failed(verifyOpValueSizes(op, op.target(), op.target_size()))) {
    return failure();
  }
  auto targetType = op.target_encoding().cast<ShapedType>();
  if (op.indices().size() != targetType.getRank()) {
    return op.emitOpError() << ""indices rank mismatch"";
  }
  return success();
}

Value TensorStoreOp::getTiedResult(unsigned resultIndex) {
  return IREE::Util::TiedOpInterface::findTiedBaseValue(target());
}

::llvm::Optional<unsigned> TensorStoreOp::getTiedResultOperandIndex(
    unsigned resultIndex) {
  return {0};  // target
}

SmallVector<int64_t, 4> TensorStoreOp::getTiedResultOperandIndices() {
  return {0};  // target
}

//===----------------------------------------------------------------------===//
// stream.builtin.* utilities
//===----------------------------------------------------------------------===//

// Merges a builtin module from iree/compiler/Dialect/Stream/Builtins/*.mlir
// into the user module; this allows for host functions and multiple
// executables.
//
// Fails if there's a name conflict; we have a __ prefix and things outside the
// compiler shouldn't use it.
static LogicalResult mergeBuiltinModuleSource(Location loc, StringRef fileName,
                                              Operation *targetOp,
                                              OpBuilder &targetBuilder) {
  // Find the file in the embedded data.
  const iree_file_toc_t *toc = iree_compiler_Stream_Builtins_create();
  const iree_file_toc_t *file = nullptr;
  for (size_t i = 0; i < iree_compiler_Stream_Builtins_size(); ++i) {
    if (fileName == toc[i].name) {
      file = &toc[i];
      break;
    }
  }
  if (!file) {
    return mlir::emitError(
        loc, ""unable to merge builtin module; file not found "" + fileName);
  }
  SymbolTable targetSymbols(targetOp);
  return mergeSourceModuleInto(loc, StringRef(file->data, file->size), targetOp,
                               targetSymbols, targetBuilder);
}

//===----------------------------------------------------------------------===//
// stream.builtin.splat.i64
//===----------------------------------------------------------------------===//

LogicalResult BuiltinSplatI64Op::verify() {
  BuiltinSplatI64Op op = *this;
  if (failed(verifyOpValueSizes(op, op.result(), op.result_size()))) {
    return failure();
  }
  return success();
}

LogicalResult BuiltinSplatI64Op::mergeBuiltinModule(Operation *targetOp,
                                                    OpBuilder &targetBuilder) {
  return mergeBuiltinModuleSource(getLoc(), ""splat_i64.mlir"", targetOp,
                                  targetBuilder);
}

LogicalResult BuiltinSplatI64Op::convertBuiltinOp(OpBuilder &builder) {
  auto c8 = builder.createOrFold<arith::ConstantIndexOp>(getLoc(), 8);
  auto count =
      builder.createOrFold<arith::DivUIOp>(getLoc(), result_size(), c8);
  auto one = builder.create<arith::ConstantIndexOp>(getLoc(), 1);
  Value workgroupCount[3] = {
      count,
      one,
      one,
  };
  SmallVector<Value> operands = {
      value(),
      count,
  };
  SmallVector<Value> operandSizes = {};
  SmallVector<int64_t> tiedOperands = {
      -1,
  };
  SmallVector<Value> resultSizes = {
      result_size(),
  };
  SmallVector<Type> resultTypes{
      result().getType(),
  };
  auto dispatchOp = builder.create<IREE::Stream::AsyncDispatchOp>(
      getLoc(), resultTypes, workgroupCount,
      SymbolRefAttr::get(
          builder.getStringAttr(""__builtin_splat_i64""),
          FlatSymbolRefAttr::get(builder.getContext(), ""__builtin_splat_i64"")),
      operands, operandSizes, resultSizes,
      builder.getIndexArrayAttr(tiedOperands), affinityAttr());
  result().replaceAllUsesWith(dispatchOp.results().front());
  return success();
}

//===----------------------------------------------------------------------===//
// stream.builtin.fill.i64
//===----------------------------------------------------------------------===//

LogicalResult BuiltinFillI64Op::verify() {
  BuiltinFillI64Op op = *this;
  if (failed(verifyOpValueSizes(op, op.result(), op.target_size()))) {
    return failure();
  }
  return success();
}

Value BuiltinFillI64Op::getTiedResult(unsigned resultIndex) {
  return IREE::Util::TiedOpInterface::findTiedBaseValue(target());
}

::llvm::Optional<unsigned> BuiltinFillI64Op::getTiedResultOperandIndex(
    unsigned resultIndex) {
  return {0};  // target
}

SmallVector<int64_t, 4> BuiltinFillI64Op::getTiedResultOperandIndices() {
  return {0};  // target
}

LogicalResult BuiltinFillI64Op::mergeBuiltinModule(Operation *targetOp,
                                                   OpBuilder &targetBuilder) {
  return mergeBuiltinModuleSource(getLoc(), ""fill_i64.mlir"", targetOp,
                                  targetBuilder);
}

LogicalResult BuiltinFillI64Op::convertBuiltinOp(OpBuilder &builder) {
  auto c8 = builder.createOrFold<arith::ConstantIndexOp>(getLoc(), 8);
  auto count =
      builder.createOrFold<arith::DivUIOp>(getLoc(), target_length(), c8);
  auto one = builder.create<arith::ConstantIndexOp>(getLoc(), 1);
  Value workgroupCount[3] = {
      count,
      one,
      one,
  };
  SmallVector<Value> operands = {
      target(),
      value(),
      target_offset(),
      count,
  };
  SmallVector<Value> operandSizes = {
      target_size(),
  };
  SmallVector<int64_t> tiedOperands = {
      0,
  };
  SmallVector<Value> resultSizes = {
      target_size(),
  };
  SmallVector<Type> resultTypes{
      result().getType(),
  };
  auto dispatchOp = builder.create<IREE::Stream::AsyncDispatchOp>(
      getLoc(), resultTypes, workgroupCount,
      SymbolRefAttr::get(
          builder.getStringAttr(""__builtin_fill_i64""),
          FlatSymbolRefAttr::get(builder.getContext(), ""__builtin_fill_i64"")),
      operands, operandSizes, resultSizes,
      builder.getIndexArrayAttr(tiedOperands), affinityAttr());
  result().replaceAllUsesWith(dispatchOp.results().front());
  return success();
}

//===----------------------------------------------------------------------===//
// stream.async.alloca
//===----------------------------------------------------------------------===//

bool AsyncAllocaOp::isMetadata() { return true; }

bool AsyncAllocaOp::preferCloneToConsumers() { return true; }

//===----------------------------------------------------------------------===//
// stream.async.constant
//===----------------------------------------------------------------------===//

bool AsyncConstantOp::isMetadata() { return true; }

void AsyncConstantOp::getAsmResultNames(mlir::OpAsmSetValueNameFn setNameFn) {
  setNameFn(result(), ""cst"");
}

LogicalResult AsyncConstantOp::verify() {
  AsyncConstantOp op = *this;
  if (failed(verifyOpValueSizes(op, op.result(), op.result_size()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.async.splat
//===----------------------------------------------------------------------===//

LogicalResult AsyncSplatOp::verify() {
  AsyncSplatOp op = *this;
  if (failed(verifyOpValueSizes(op, op.result(), op.result_size()))) {
    return failure();
  }
  return success();
}

bool AsyncSplatOp::preferCloneToConsumers() { return true; }

//===----------------------------------------------------------------------===//
// stream.async.clone
//===----------------------------------------------------------------------===//

LogicalResult AsyncCloneOp::verify() {
  AsyncCloneOp op = *this;
  if (failed(verifyOpValueSizes(op, op.source(), op.source_size())) ||
      failed(verifyOpValueSizes(op, op.result(), op.result_size()))) {
    return failure();
  }
  return success();
}

bool AsyncCloneOp::preferCloneToConsumers() { return true; }

//===----------------------------------------------------------------------===//
// stream.async.slice
//===----------------------------------------------------------------------===//

LogicalResult AsyncSliceOp::verify() {
  AsyncSliceOp op = *this;
  if (failed(verifyOpValueSizes(op, op.source(), op.source_size())) ||
      failed(verifyOpValueSizes(op, op.result(), op.result_size()))) {
    return failure();
  }
  return success();
}

bool AsyncSliceOp::isMetadata() { return true; }

//===----------------------------------------------------------------------===//
// stream.async.fill
//===----------------------------------------------------------------------===//

LogicalResult AsyncFillOp::verify() {
  AsyncFillOp op = *this;
  if (failed(verifyOpValueSizes(op, op.result(), op.target_size()))) {
    return failure();
  }
  return success();
}

Value AsyncFillOp::getTiedResult(unsigned resultIndex) {
  return IREE::Util::TiedOpInterface::findTiedBaseValue(target());
}

::llvm::Optional<unsigned> AsyncFillOp::getTiedResultOperandIndex(
    unsigned resultIndex) {
  return {0};  // target
}

SmallVector<int64_t, 4> AsyncFillOp::getTiedResultOperandIndices() {
  return {0};  // target
}

//===----------------------------------------------------------------------===//
// stream.async.update
//===----------------------------------------------------------------------===//

LogicalResult AsyncUpdateOp::verify() {
  AsyncUpdateOp op = *this;
  if (failed(verifyOpValueSizes(op, op.update(), op.update_size())) ||
      failed(verifyOpValueSizes(op, op.result(), op.target_size()))) {
    return failure();
  }
  return success();
}

bool AsyncUpdateOp::isMetadata() { return true; }

Value AsyncUpdateOp::getTiedResult(unsigned resultIndex) {
  return IREE::Util::TiedOpInterface::findTiedBaseValue(target());
}

::llvm::Optional<unsigned> AsyncUpdateOp::getTiedResultOperandIndex(
    unsigned resultIndex) {
  return {0};  // target
}

SmallVector<int64_t, 4> AsyncUpdateOp::getTiedResultOperandIndices() {
  return {0};  // target
}

//===----------------------------------------------------------------------===//
// stream.async.copy
//===----------------------------------------------------------------------===//

LogicalResult AsyncCopyOp::verify() {
  AsyncCopyOp op = *this;
  if (op.source() == op.target()) {
    // If we want to perform memmove-like operations where it's safe to copy
    // overlapping ranges we'll need to emit some runtime checks. We can in
    // many cases statically detect a lack of overlap just based on symbolic
    // offset equality but that requires some analysis we don't have yet.
    return op.emitOpError() << ""cannot copy within the same resource (yet)"";
  }
  if (failed(verifyOpValueSizes(op, op.source(), op.source_size())) ||
      failed(verifyOpValueSizes(op, op.result(), op.target_size()))) {
    return failure();
  }
  return success();
}

Value AsyncCopyOp::getTiedResult(unsigned resultIndex) {
  return IREE::Util::TiedOpInterface::findTiedBaseValue(target());
}

::llvm::Optional<unsigned> AsyncCopyOp::getTiedResultOperandIndex(
    unsigned resultIndex) {
  return {0};  // target
}

SmallVector<int64_t, 4> AsyncCopyOp::getTiedResultOperandIndices() {
  return {0};  // target
}

//===----------------------------------------------------------------------===//
// stream.async.transfer
//===----------------------------------------------------------------------===//

LogicalResult AsyncTransferOp::verify() {
  AsyncTransferOp op = *this;
  if (failed(verifyOpValueSizes(op, op.source(), op.source_size())) ||
      failed(verifyOpValueSizes(op, op.result(), op.result_size()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.async.load
//===----------------------------------------------------------------------===//

LogicalResult AsyncLoadOp::verify() {
  AsyncLoadOp op = *this;
  if (failed(verifyOpValueSizes(op, op.source(), op.source_size()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.async.store
//===----------------------------------------------------------------------===//

LogicalResult AsyncStoreOp::verify() {
  AsyncStoreOp op = *this;
  if (failed(verifyOpValueSizes(op, op.target(), op.target_size()))) {
    return failure();
  }
  return success();
}

Value AsyncStoreOp::getTiedResult(unsigned resultIndex) {
  return IREE::Util::TiedOpInterface::findTiedBaseValue(target());
}

::llvm::Optional<unsigned> AsyncStoreOp::getTiedResultOperandIndex(
    unsigned resultIndex) {
  return {0};  // target
}

SmallVector<int64_t, 4> AsyncStoreOp::getTiedResultOperandIndices() {
  return {0};  // target
}

//===----------------------------------------------------------------------===//
// stream.async.dispatch
//===----------------------------------------------------------------------===//

LogicalResult AsyncDispatchOp::verify() {
  AsyncDispatchOp op = *this;
  if (failed(verifyOpValueSizes(op, op.operands(), op.operand_sizes())) ||
      failed(verifyOpValueSizes(op, op.results(), op.result_sizes()))) {
    return failure();
  }
  return success();
}

std::pair<unsigned, unsigned> AsyncDispatchOp::getTiedOperandsIndexAndLength() {
  return getODSOperandIndexAndLength(1);  // $operands
}

//===----------------------------------------------------------------------===//
// stream.async.execute
//===----------------------------------------------------------------------===//

void AsyncExecuteOp::build(OpBuilder &builder, OperationState &state,
                           TypeRange resultTypes, ValueRange resultSizes,
                           Value awaitTimepoint, ValueRange operands,
                           ValueRange operandSizes,
                           ArrayRef<int64_t> tiedOperands,
                           ArrayRef<NamedAttribute> attributes) {
  state.addTypes(resultTypes);
  state.addTypes(IREE::Stream::TimepointType::get(builder.getContext()));
  state.addOperands(operands);
  state.addOperands(operandSizes);
  state.addOperands(resultSizes);
  if (awaitTimepoint) state.addOperands(awaitTimepoint);
  state.addAttributes(attributes);
  state.attributes.erase(IREE::Util::TiedOpInterface::getStorageAttrName());
  state.addAttribute(IREE::Util::TiedOpInterface::getStorageAttrName(),
                     builder.getIndexArrayAttr(tiedOperands));
  state.attributes.erase(""operand_segment_sizes"");
  state.addAttribute(""operand_segment_sizes"",
                     builder.getI32VectorAttr({
                         static_cast<int32_t>(operands.size()),
                         static_cast<int32_t>(operandSizes.size()),
                         static_cast<int32_t>(resultSizes.size()),
                         awaitTimepoint ? 1 : 0,
                     }));
  state.addRegion();
}

LogicalResult AsyncExecuteOp::verify() {
  AsyncExecuteOp op = *this;
  if (failed(verifyOpValueSizes(op, op.operands(), op.operand_sizes())) ||
      failed(verifyOpValueSizes(op, op.results(), op.result_sizes()))) {
    return failure();
  }
  if (failed(verifyAllResourcesCaptured(op.body())) ||
      failed(verifyEscapingResources(op.body(), op.results(),
                                     op.result_sizes()))) {
    return failure();
  }
  return success();
}

std::pair<unsigned, unsigned> AsyncExecuteOp::getTiedResultsIndexAndLength() {
  return {0, results().size()};
}

OperandRange AsyncExecuteOp::getSuccessorEntryOperands(unsigned index) {
  assert(index == 0 && ""invalid region index"");
  return operands();
}

void AsyncExecuteOp::getSuccessorRegions(
    Optional<unsigned> index, ArrayRef<Attribute> operands,
    SmallVectorImpl<RegionSuccessor> &regions) {
  // Unconditional control flow into the region and back to the parent, so
  // return the correct RegionSuccessor purely based on the index being None or
  // 0.
  if (index.hasValue()) {
    regions.push_back(RegionSuccessor(results()));
  } else {
    regions.push_back(RegionSuccessor(&body(), body().getArguments()));
  }
}

Operation::operand_range AsyncExecuteOp::getClosureOperands() {
  return operands();
}

Operation::result_range AsyncExecuteOp::getClosureResults() {
  return results();
}

bool AsyncExecuteOp::canClosureContainOp(Operation *op) { return false; }

IREE::Util::ValueAccess AsyncExecuteOp::getOperandAccess(
    unsigned operandIndex) {
  auto arg = body().getArgument(operandIndex);
  return computeValueAccess(arg);
}

IREE::Util::ValueAccess AsyncExecuteOp::getResultAccess(unsigned resultIndex) {
  auto yieldOp = cast<YieldOp>(body().getBlocks().front().getTerminator());
  return computeValueAccess(yieldOp.getOperand(resultIndex));
}

IREE::Util::ClosureOpInterface
AsyncExecuteOp::cloneReplacementExcludingOperandsAndResults(
    ArrayRef<unsigned> excludedOperandIndices,
    ArrayRef<unsigned> excludedResultIndices, PatternRewriter &rewriter) {
  auto newResultTypes = llvm::to_vector<4>(
      llvm::map_range(results(), [](auto value) { return value.getType(); }));
  auto newResultSizes = llvm::to_vector<4>(result_sizes());
  auto newOperandsValues = llvm::to_vector<4>(operands());
  auto newOperandSizes = llvm::to_vector<4>(operand_sizes());
  IREE::Util::excludeClosureOperandsAndResults(
      newOperandsValues, newOperandSizes, excludedOperandIndices,
      newResultTypes, newResultSizes, excludedResultIndices);

  auto newTiedOperandIndices =
      llvm::to_vector<4>(getTiedResultOperandIndices());
  IREE::Util::excludeTiedOperandAndResultIndices(
      excludedOperandIndices, excludedResultIndices, newTiedOperandIndices);
  assert(getTiedOperandsIndexAndLength().first == 0 &&
         ""operands must be the first ODS group"");

  auto newOp = rewriter.create<AsyncExecuteOp>(
      getLoc(), newResultTypes, newResultSizes, await_timepoint(),
      newOperandsValues, newOperandSizes, newTiedOperandIndices,
      getOperation()->getAttrs());
  auto &newBody = newOp.getClosureBodyRegion();
  newBody.takeBody(getClosureBodyRegion());
  eraseStreamRegionResults(newBody, excludedResultIndices);
  newBody.front().eraseArguments(excludedOperandIndices);
  return newOp;
}

//===----------------------------------------------------------------------===//
// stream.async.concurrent
//===----------------------------------------------------------------------===//

void AsyncConcurrentOp::build(OpBuilder &builder, OperationState &state,
                              TypeRange resultTypes, ValueRange resultSizes,
                              ValueRange operands, ValueRange operandSizes,
                              ArrayRef<int64_t> tiedOperands,
                              ArrayRef<NamedAttribute> attributes) {
  state.addTypes(resultTypes);
  state.addOperands(operands);
  state.addOperands(operandSizes);
  state.addOperands(resultSizes);
  state.addAttributes(attributes);
  state.attributes.erase(IREE::Util::TiedOpInterface::getStorageAttrName());
  state.addAttribute(IREE::Util::TiedOpInterface::getStorageAttrName(),
                     builder.getIndexArrayAttr(tiedOperands));
  state.attributes.erase(""operand_segment_sizes"");
  state.addAttribute(""operand_segment_sizes"",
                     builder.getI32VectorAttr({
                         static_cast<int32_t>(operands.size()),
                         static_cast<int32_t>(operandSizes.size()),
                         static_cast<int32_t>(resultSizes.size()),
                     }));
  state.addRegion();
}

LogicalResult AsyncConcurrentOp::verify() {
  AsyncConcurrentOp op = *this;
  if (failed(verifyOpValueSizes(op, op.operands(), op.operand_sizes())) ||
      failed(verifyOpValueSizes(op, op.results(), op.result_sizes()))) {
    return failure();
  }
  if (failed(verifyAllResourcesCaptured(op.body())) ||
      failed(verifyEscapingResources(op.body(), op.results(),
                                     op.result_sizes()))) {
    return failure();
  }
  return success();
}

OperandRange AsyncConcurrentOp::getSuccessorEntryOperands(unsigned index) {
  assert(index == 0 && ""invalid region index"");
  return operands();
}

void AsyncConcurrentOp::getSuccessorRegions(
    Optional<unsigned> index, ArrayRef<Attribute> operands,
    SmallVectorImpl<RegionSuccessor> &regions) {
  // Unconditional control flow into the region and back to the parent, so
  // return the correct RegionSuccessor purely based on the index being None or
  // 0.
  if (index.hasValue()) {
    regions.push_back(RegionSuccessor(results()));
  } else {
    regions.push_back(RegionSuccessor(&body(), body().getArguments()));
  }
}

Operation::operand_range AsyncConcurrentOp::getClosureOperands() {
  return operands();
}

Operation::result_range AsyncConcurrentOp::getClosureResults() {
  return results();
}

bool AsyncConcurrentOp::canClosureContainOp(Operation *op) { return false; }

IREE::Util::ValueAccess AsyncConcurrentOp::getOperandAccess(
    unsigned operandIndex) {
  auto arg = body().getArgument(operandIndex);
  return computeValueAccess(arg);
}

IREE::Util::ValueAccess AsyncConcurrentOp::getResultAccess(
    unsigned resultIndex) {
  auto yieldOp = cast<YieldOp>(body().getBlocks().front().getTerminator());
  return computeValueAccess(yieldOp.getOperand(resultIndex));
}

IREE::Util::ClosureOpInterface
AsyncConcurrentOp::cloneReplacementExcludingOperandsAndResults(
    ArrayRef<unsigned> excludedOperandIndices,
    ArrayRef<unsigned> excludedResultIndices, PatternRewriter &rewriter) {
  auto newResultTypes = llvm::to_vector<4>(getResultTypes());
  auto newResultSizes = llvm::to_vector<4>(result_sizes());
  auto newOperandsValues = llvm::to_vector<4>(operands());
  auto newOperandSizes = llvm::to_vector<4>(operand_sizes());
  IREE::Util::excludeClosureOperandsAndResults(
      newOperandsValues, newOperandSizes, excludedOperandIndices,
      newResultTypes, newResultSizes, excludedResultIndices);

  auto newTiedOperandIndices =
      llvm::to_vector<4>(getTiedResultOperandIndices());
  IREE::Util::excludeTiedOperandAndResultIndices(
      excludedOperandIndices, excludedResultIndices, newTiedOperandIndices);
  assert(getTiedOperandsIndexAndLength().first == 0 &&
         ""operands must be the first ODS group"");

  auto newOp = rewriter.create<AsyncConcurrentOp>(
      getLoc(), newResultTypes, newResultSizes, newOperandsValues,
      newOperandSizes, newTiedOperandIndices, getOperation()->getAttrs());
  auto &newBody = newOp.getClosureBodyRegion();
  newBody.takeBody(getClosureBodyRegion());
  eraseStreamRegionResults(newBody, excludedResultIndices);
  newBody.front().eraseArguments(excludedOperandIndices);
  return newOp;
}

//===----------------------------------------------------------------------===//
// stream.cmd.flush
//===----------------------------------------------------------------------===//

LogicalResult CmdFlushOp::verify() {
  CmdFlushOp op = *this;
  if (failed(verifyOpValueSizes(op, op.target(), op.target_size()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.cmd.invalidate
//===----------------------------------------------------------------------===//

LogicalResult CmdInvalidateOp::verify() {
  CmdInvalidateOp op = *this;
  if (failed(verifyOpValueSizes(op, op.target(), op.target_size()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.cmd.discard
//===----------------------------------------------------------------------===//

LogicalResult CmdDiscardOp::verify() {
  CmdDiscardOp op = *this;
  if (failed(verifyOpValueSizes(op, op.target(), op.target_size()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.cmd.fill
//===----------------------------------------------------------------------===//

LogicalResult CmdFillOp::verify() {
  CmdFillOp op = *this;
  if (failed(verifyOpValueSizes(op, op.target(), op.target_size()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.cmd.copy
//===----------------------------------------------------------------------===//

LogicalResult CmdCopyOp::verify() {
  CmdCopyOp op = *this;
  if (failed(verifyOpValueSizes(op, op.source(), op.source_size())) ||
      failed(verifyOpValueSizes(op, op.target(), op.target_size()))) {
    return failure();
  }
  return success();
}

//===----------------------------------------------------------------------===//
// stream.cmd.dispatch
//===----------------------------------------------------------------------===//

LogicalResult CmdDispatchOp::verify() {
  CmdDispatchOp op = *this;
  size_t resourceCount = op.resources().size();
  if (op.resource_sizes().size() != resourceCount ||
      op.resource_offsets().size() != resourceCount ||
      op.resource_lengths().size() != resourceCount ||
      op.resource_accesses().size() != resourceCount) {
    return op->emitOpError() << ""dispatch with "" << resourceCount
                             << "" resources has mismatched associated ranges"";
  }
  return success();
}

static ParseResult parseDispatchResources(
    OpAsmParser &parser,
    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &resources,
    SmallVectorImpl<Type> &resourceTypes,
    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &resourceSizes,
    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &resourceOffsets,
    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &resourceLengths,
    ArrayAttr &resourceAccesses) {
  SmallVector<Attribute> accessAttrs;
  do {
    // Reserve entries in the lists.
    resources.emplace_back();
    resourceTypes.emplace_back();
    resourceSizes.emplace_back();
    resourceOffsets.emplace_back();
    resourceLengths.emplace_back();
    StringRef accessStr;
    if (failed(parser.parseKeyword(&accessStr)) ||
        failed(parser.parseOperand(resources.back())) ||
        failed(parser.parseLSquare()) ||
        failed(parser.parseOperand(resourceOffsets.back())) ||
        failed(parser.parseKeyword(""for"")) ||
        failed(parser.parseOperand(resourceLengths.back())) ||
        failed(parser.parseRSquare()) || failed(parser.parseColon()) ||
        failed(parseSizeAwareType(parser, resourceTypes.back(),
                                  resourceSizes.back()))) {
      return failure();
    }
    IREE::Stream::ResourceAccessBitfield accessBits =
        IREE::Stream::ResourceAccessBitfield::None;
    if (accessStr == ""ro"") {
      accessBits = IREE::Stream::ResourceAccessBitfield::Read;
    } else if (accessStr == ""wo"") {
      accessBits = IREE::Stream::ResourceAccessBitfield::Write;
    } else if (accessStr == ""rw"") {
      accessBits = IREE::Stream::ResourceAccessBitfield::Read |
                   IREE::Stream::ResourceAccessBitfield::Write;
    }
    accessAttrs.push_back(IREE::Stream::ResourceAccessBitfieldAttr::get(
        parser.getBuilder().getContext(), accessBits));
  } while (succeeded(parser.parseOptionalComma()));
  resourceAccesses = parser.getBuilder().getArrayAttr(accessAttrs);
  return success();
}

static void printDispatchResources(OpAsmPrinter &p, Operation *op,
                                   ValueRange resources,
                                   TypeRange resourceTypes,
                                   ValueRange resourceSizes,
                                   ValueRange resourceOffsets,
                                   ValueRange resourceLengths,
                                   ArrayAttr resourceAccesses) {
  for (size_t i = 0; i < resources.size(); ++i) {
    auto resource = resources[i];
    auto resourceType = resourceTypes[i];
    auto resourceSize = resourceSizes[i];
    auto resourceOffset = resourceOffsets[i];
    auto resourceLength = resourceLengths[i];
    auto resourceAccess = resourceAccesses[i]
                              .cast<IREE::Stream::ResourceAccessBitfieldAttr>()
                              .getValue();
    p.printNewline();
    p << ""  "";
    if (bitEnumContains(resourceAccess,
                        IREE::Stream::ResourceAccessBitfield::Read) &&
        bitEnumContains(resourceAccess,
                        IREE::Stream::ResourceAccessBitfield::Write)) {
      p << ""rw"";
    } else if (bitEnumContains(resourceAccess,
                               IREE::Stream::ResourceAccessBitfield::Read)) {
      p << ""ro"";
    } else if (bitEnumContains(resourceAccess,
                               IREE::Stream::ResourceAccessBitfield::Write)) {
      p << ""wo"";
    }
    p << ' ';
    p.printOperand(resource);
    p << ""["";
    p.printOperand(resourceOffset);
    p << "" for "";
    p.printOperand(resourceLength);
    p << ""] : "";
    printSizeAwareType(p, op, resourceType, resourceSize);
    if (i < resources.size() - 1) p << "","";
  }
}

// This is sloppy because the function has interleaved bindings and operands;
// if we had our own op we could just reuse the map we have for operands.
// static
SmallVector<unsigned> CmdDispatchOp::makeOperandToArgMap(
    mlir::func::FuncOp funcOp) {
  unsigned operandCount = llvm::count_if(
      funcOp.getArgumentTypes(),
      [](Type type) { return !type.isa<IREE::Stream::BindingType>(); });
  SmallVector<unsigned> map(operandCount);
  unsigned operandIdx = 0;
  for (auto it : llvm::enumerate(funcOp.getArgumentTypes())) {
    unsigned argIdx = it.index();
    auto argType = it.value();
    if (!argType.isa<IREE::Stream::BindingType>()) {
      map[operandIdx++] = argIdx;
    }
  }
  return map;
}

// static
SmallVector<unsigned> CmdDispatchOp::makeResourceToArgMap(
    mlir::func::FuncOp funcOp) {
  unsigned operandCount = llvm::count_if(
      funcOp.getArgumentTypes(),
      [](Type type) { return type.isa<IREE::Stream::BindingType>(); });
  SmallVector<unsigned> map(operandCount);
  unsigned operandIdx = 0;
  for (auto it : llvm::enumerate(funcOp.getArgumentTypes())) {
    unsigned argIdx = it.index();
    auto argType = it.value();
    if (argType.isa<IREE::Stream::BindingType>()) {
      map[operandIdx++] = argIdx;
    }
  }
  return map;
}

//===----------------------------------------------------------------------===//
// stream.cmd.execute
//===----------------------------------------------------------------------===//

void CmdExecuteOp::build(OpBuilder &builder, OperationState &state,
                         Value awaitTimepoint, ValueRange operands,
                         ValueRange operandSizes,
                         ArrayRef<NamedAttribute> attributes) {
  state.addTypes(IREE::Stream::TimepointType::get(builder.getContext()));
  state.addOperands(operands);
  state.addOperands(operandSizes);
  if (awaitTimepoint) state.addOperands(awaitTimepoint);
  state.addAttributes(attributes);
  state.attributes.erase(""operand_segment_sizes"");
  state.addAttribute(""operand_segment_sizes"",
                     builder.getI32VectorAttr({
                         static_cast<int32_t>(operands.size()),
                         static_cast<int32_t>(operandSizes.size()),
                         awaitTimepoint ? 1 : 0,
                     }));
  state.addRegion();
}

// Returns success if the given op is a known valid stream.cmd.* op for use
// within an execution region.
static LogicalResult verifyCmdOp(Operation *op) {
  // TODO(benvanik): add a trait that lets us avoid this switch.
  if (!TypeSwitch<Operation *, bool>(op)
           .Case<IREE::Stream::CmdFlushOp, IREE::Stream::CmdInvalidateOp,
                 IREE::Stream::CmdDiscardOp, IREE::Stream::CmdFillOp,
                 IREE::Stream::CmdCopyOp, IREE::Stream::CmdDispatchOp,
                 IREE::Stream::CmdSerialOp, IREE::Stream::CmdConcurrentOp>(
               [](auto op) { return true; })
           .Case<IREE::Stream::YieldOp>([](auto op) { return true; })
           .Default(false)) {
    return op->emitOpError()
           << ""explicit execution regions must only contain explicit ops"";
  }
  return success();
}

LogicalResult CmdExecuteOp::verify() {
  CmdExecuteOp op = *this;
  if (failed(verifyOpValueSizes(op, op.operands(), op.operand_sizes()))) {
    return failure();
  }
  if (failed(verifyAllResourcesCaptured(op.body()))) {
    return failure();
  }
  for (auto &nestedOp : op.body().front()) {
    if (failed(verifyCmdOp(&nestedOp))) return failure();
  }
  return success();
}

OperandRange CmdExecuteOp::getSuccessorEntryOperands(unsigned index) {
  assert(index == 0 && ""invalid region index"");
  return operands();
}

void CmdExecuteOp::getSuccessorRegions(
    Optional<unsigned> index, ArrayRef<Attribute> operands,
    SmallVectorImpl<RegionSuccessor> &regions) {
  // Unconditional control flow into the region and back to the parent, so
  // return the correct RegionSuccessor purely based on the index being None or
  // 0.
  if (index.hasValue()) {
    regions.push_back(RegionSuccessor({}));
  } else {
    regions.push_back(RegionSuccessor(&body(), body().getArguments()));
  }
}

Operation::operand_range CmdExecuteOp::getClosureOperands() {
  return operands();
}

Operation::result_range CmdExecuteOp::getClosureResults() {
  return Operation::result_range(nullptr, 0);
}

bool CmdExecuteOp::canClosureContainOp(Operation *op) { return false; }

IREE::Util::ValueAccess CmdExecuteOp::getOperandAccess(unsigned operandIndex) {
  auto arg = body().getArgument(operandIndex);
  return computeValueAccess(arg);
}

IREE::Util::ValueAccess CmdExecuteOp::getResultAccess(unsigned resultIndex) {
  return IREE::Util::ValueAccess::None();
}

IREE::Util::ClosureOpInterface
CmdExecuteOp::cloneReplacementExcludingOperandsAndResults(
    ArrayRef<unsigned> excludedOperandIndices,
    ArrayRef<unsigned> excludedResultIndices, PatternRewriter &rewriter) {
  SmallVector<Type, 4> newResultTypes;
  SmallVector<Value, 4> newResultSizes;
  auto newOperandsValues = llvm::to_vector<4>(operands());
  auto newOperandSizes = llvm::to_vector<4>(operand_sizes());
  IREE::Util::excludeClosureOperandsAndResults(
      newOperandsValues, newOperandSizes, excludedOperandIndices,
      newResultTypes, newResultSizes, excludedResultIndices);

  auto newOp = rewriter.create<CmdExecuteOp>(getLoc(), await_timepoint(),
                                             newOperandsValues, newOperandSizes,
                                             getOperation()->getAttrs());
  auto &newBody = newOp.getClosureBodyRegion();
  newBody.takeBody(getClosureBodyRegion());
  newBody.front().eraseArguments(excludedOperandIndices);
  return newOp;
}

//===----------------------------------------------------------------------===//
// stream.cmd.serial
//===----------------------------------------------------------------------===//

LogicalResult CmdSerialOp::verify() {
  CmdSerialOp op = *this;
  for (auto &nestedOp : op.body().front()) {
    if (failed(verifyCmdOp(&nestedOp))) return failure();
  }
  return success();
}

void CmdSerialOp::getSuccessorRegions(
    Optional<unsigned> index, ArrayRef<Attribute> operands,
    SmallVectorImpl<RegionSuccessor> &regions) {
  // Unconditional control flow into the region and back to the parent, so
  // return the correct RegionSuccessor purely based on the index being None or
  // 0.
  if (index.hasValue()) {
    regions.push_back(RegionSuccessor({}));
  } else {
    regions.push_back(RegionSuccessor(&body(), {}));
  }
}

//===----------------------------------------------------------------------===//
// stream.cmd.concurrent
//===----------------------------------------------------------------------===//

LogicalResult CmdConcurrentOp::verify() {
  CmdConcurrentOp op = *this;
  for (auto &nestedOp : op.body().front()) {
    if (failed(verifyCmdOp(&nestedOp))) return failure();
  }
  return success();
}

void CmdConcurrentOp::getSuccessorRegions(
    Optional<unsigned> index, ArrayRef<Attribute> operands,
    SmallVectorImpl<RegionSuccessor> &regions) {
  // Unconditional control flow into the region and back to the parent, so
  // return the correct RegionSuccessor purely based on the index being None or
  // 0.
  if (index.hasValue()) {
    regions.push_back(RegionSuccessor({}));
  } else {
    regions.push_back(RegionSuccessor(&body(), {}));
  }
}

//===----------------------------------------------------------------------===//
// stream.timepoint.join
//===----------------------------------------------------------------------===//

LogicalResult TimepointJoinOp::verify() {
  // We could test if timepoints all come from the same place - this is not
  // strictly required but if we could avoid it things will be easier to
  // implement at runtime (won't have to do a cuda<->vulkan sync, etc).
  return success();
}

//===----------------------------------------------------------------------===//
// stream.timepoint.await
//===----------------------------------------------------------------------===//

void TimepointAwaitOp::build(OpBuilder &builder, OperationState &state,
                             ValueRange operands, ValueRange operandSizes,
                             Value timepoint,
                             ArrayRef<NamedAttribute> attributes) {
  state.addTypes(llvm::map_range(
      operands, [&](Value operand) { return operand.getType(); }));
  state.addOperands(operands);
  state.addOperands(operandSizes);
  state.addOperands(timepoint);
  state.addAttributes(attributes);
  state.attributes.erase(""operand_segment_sizes"");
  state.addAttribute(""operand_segment_sizes"",
                     builder.getI32VectorAttr({
                         static_cast<int32_t>(operands.size()),
                         static_cast<int32_t>(operandSizes.size()),
                         static_cast<int32_t>(1),  // timepoint
                     }));
}

LogicalResult TimepointAwaitOp::verify() {
  TimepointAwaitOp op = *this;
  if (failed(verifyOpValueSizes(op, op.operands(), op.operand_sizes())) ||
      failed(verifyOpValueSizes(op, op.results(), op.operand_sizes()))) {
    return failure();
  }
  return success();
}

::llvm::Optional<unsigned> TimepointAwaitOp::getTiedResultOperandIndex(
    unsigned resultIndex) {
  return {resultIndex};
}

SmallVector<int64_t, 4> TimepointAwaitOp::getTiedResultOperandIndices() {
  return llvm::to_vector<4>(llvm::seq<int64_t>(0, operands().size()));
}

//===----------------------------------------------------------------------===//
// stream.executable
//===----------------------------------------------------------------------===//

void ExecutableOp::build(OpBuilder &builder, OperationState &state,
                         StringRef sym_name) {
  ensureTerminator(*state.addRegion(), builder, state.location);
  state.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                     builder.getStringAttr(sym_name));
}

LogicalResult ExecutableOp::verify() {
  // TODO(benvanik): check export name conflicts.
  return success();
}

//===----------------------------------------------------------------------===//
// stream.executable.entry
//===----------------------------------------------------------------------===//

void ExecutableExportOp::build(OpBuilder &builder, OperationState &state,
                               StringRef sym_name,
                               FlatSymbolRefAttr function_ref) {
  build(builder, state, /*sym_visibility=*/nullptr,
        builder.getStringAttr(sym_name), function_ref);
}

::mlir::func::FuncOp ExecutableExportOp::getFunctionRef() {
  auto executableOp =
      this->getOperation()->getParentOfType<IREE::Stream::ExecutableOp>();
  if (!executableOp) return {};
  return executableOp.getInnerModule().lookupSymbol<::mlir::func::FuncOp>(
      function_ref());
}

//===----------------------------------------------------------------------===//
// stream.binding.subspan
//===----------------------------------------------------------------------===//

LogicalResult BindingSubspanOp::verify() {
  BindingSubspanOp op = *this;
  if (auto shapedType = op.getType().dyn_cast<ShapedType>()) {
    if (failed(verifyOpDynamicDims(op, shapedType, op.dynamic_dims()))) {
      return failure();
    }
  }

  return success();
}

//===----------------------------------------------------------------------===//
// stream.yield
//===----------------------------------------------------------------------===//

MutableOperandRange YieldOp::getMutableSuccessorOperands(
    Optional<unsigned> index) {
  return operandsMutable();
}

}  // namespace Stream
}  // namespace IREE
}  // namespace iree_compiler
}  // namespace mlir

//===----------------------------------------------------------------------===//
// TableGen definitions (intentionally last)
//===----------------------------------------------------------------------===//

#define GET_OP_CLASSES
#include ""iree/compiler/Dialect/Stream/IR/StreamOps.cpp.inc""  // IWYU pragma: keep
",16234,True,3193.2614733866285,median