#include "geometry.h"

using namespace Ped;

Geometry::Geometry() {
    this->device = NULL;
    this->start  = 0;
    this->length = 0;
    this->end    = 0;
}

Geometry::Geometry(Device &dev, Sector start, Sector length) {
    this->device = dev;
    this->start  = start;
    this->length = length;
    this->end    = end;
    dev_         = dev.get_c_device();
    ped_geometry_init(this->get_c_geometry(), dev_, start, length);
    ped_geometry_new(dev_, start, length);
}

Geometry& Geometry::duplicate(Geometry &geom) {
    Geometry &geom_dupl = * new Geometry();
    geom_dupl.set_c_geometry(ped_geometry_duplicate(geom.geom_));
    return geom_dupl;
}

Geometry& Geometry::intersect(const Geometry &a, const Geometry &b) {
    Geometry &geom_inter = * new Geometry();
    geom_inter.geom_ = ped_geometry_intersect(a.geom_, b.geom_);
    return geom_inter;
}

void Geometry::set(Sector start, Sector length) {
    ped_geometry_set(geom_, start, length);
}

void Geometry::set_start(Sector start) {
    ped_geometry_set_start(geom_, start);
}

void Geometry::set_end(Sector end) {
    ped_geometry_set_end(geom_, end);
}

bool Geometry::test_overlap(Geometry &a, Geometry &b) {
    return (ped_geometry_test_overlap(a.geom_, b.geom_));
}

bool Geometry::test_inside(Geometry &a, Geometry &b) {
    return (ped_geometry_test_inside(a.geom_, b.geom_));
}

bool Geometry::test_equal(Geometry &a, Geometry &b) {
    return (ped_geometry_test_equal(a.geom_, b.geom_));
}

bool Geometry::test_sector_inside(Sector sect) {
    return (ped_geometry_test_sector_inside(geom_, sect));
}

int Geometry::read(void *buffer, Sector offset, Sector count) {
    return (ped_geometry_read(geom_, buffer, offset, count));
}

int Geometry::write(void *buffer, Sector offset, Sector count) {
    return (ped_geometry_write(geom_, buffer, offset, count));
}

Sector Geometry::check(void *buffer, Sector buffer_size, Sector offset,
                       Sector granularity, Sector count, Timer& timer)
{
    return (ped_geometry_check(geom_, buffer, buffer_size, offset,
                               granularity, count, timer.get_c_timer()));
}

bool Geometry::sync() {
    return (ped_geometry_sync(geom_));
}

Sector Geometry::map(Geometry &dst, Geometry &src, Sector sector) {
    return (ped_geometry_map(dst.geom_, src.geom_, sector));
}

PedGeometry* Geometry::get_c_geometry() {
    return geom_;
}

void Geometry::set_c_geometry(PedGeometry* geom) {
    geom_ = geom;
}

Device& Geometry::get_device() const {
    return device;
}

Geometry::~Geometry() {
    if (geom_)
        ped_geometry_destroy(geom_);
}

/* vim: set tabstop=4 et shiftwidth=4: */