#include "host.hpp"

#include "row.hpp"

#include "value.hpp"

#include "collection_iterator.hpp"

namespace cass {

void add_host(CopyOnWriteHostVec& hosts, const Host::Ptr& host) {

}

void remove_host(CopyOnWriteHostVec& hosts, const Host::Ptr& host) {

remove_host(hosts, host->address());

}

bool remove_host(CopyOnWriteHostVec& hosts, const Address& address) {

}

void Host::LatencyTracker::update(uint64_t latency_ns) {

uint64_t now = uv_hrtime();

ScopedSpinlock l(SpinlockPool<LatencyTracker>::get_spinlock(this));

TimestampedAverage previous = current_;

if (previous.num_measured < threshold_to_account_) {

current_.average = -1;

} else if (previous.average < 0) {

current_.average = latency_ns;

} else {

int64_t delay = now - previous.timestamp;

if (delay <= 0) {

return;

}

double scaled_delay = static_cast<double>(delay) / scale_ns_;

double weight = log(scaled_delay + 1) / scaled_delay;

current_.average = static_cast<int64_t>((1.0 - weight) * latency_ns + weight * previous.average);

}

current_.num_measured = previous.num_measured + 1;

current_.timestamp = now;

}

bool VersionNumber::parse(const String& version) {

return sscanf(version.c_str(), "%d.%d.%d", &major_version_, &minor_version_, &patch_version_) >= 2;

}

void Host::set(const Row* row, bool use_tokens) {

}

ExternalHostListener::ExternalHostListener(const CassHostListenerCallback callback,

void *data)

: callback_(callback)

, data_(data) { }

void ExternalHostListener::on_host_up(const Host::Ptr& host) {

}

void ExternalHostListener::on_host_down(const Host::Ptr& host) {

}

void ExternalHostListener::on_host_added(const Host::Ptr& host) {

}

void ExternalHostListener::on_host_removed(const Host::Ptr& host) {

}

} // namespace cass