// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*-
// jedit: :folding=explicit:
//
// Module.cpp: Rcpp R/C++ interface class library -- module unit tests
//
// Copyright (C) 2013 - 2014  Dirk Eddelbuettel and Romain Francois
//
// This file is part of Rcpp.
//
// Rcpp 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.
//
// Rcpp 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 Rcpp.  If not, see <http://www.gnu.org/licenses/>.

#include <Rcpp.h>

using namespace Rcpp ;

std::string hello() {
    return "hello" ;
}

int bar(int x) {
    return x*2 ;
}

double foo(int x, double y) {
    return x * y ;
}

void bla() {
    Rprintf("hello\\n") ;
}

void bla1(int x) {
    Rprintf("hello (x = %d)\\n", x) ;
}

void bla2(int x, double y) {
    Rprintf("hello (x = %d, y = %5.2f)\\n", x, y) ;
}

int test_reference(std::vector<double>& ref) {
    return ref.size() ;
}
int test_const_reference(const std::vector<double>& ref) {
    return ref.size() ;
}
int test_const(const std::vector<double> ref) {
    return ref.size() ;
}

class World {
public:
    World() : msg("hello") {}
    void set(std::string msg_) { this->msg = msg_; }
    void set_ref(std::string& msg_) { this->msg = msg_; }
    void set_const_ref(const std::string& msg_) { this->msg = msg_; }
    std::string greet() { return msg; }

private:
    std::string msg;
};

void clearWorld(World* w) {
    w->set("");
}

class Num{
public:
    Num() : x(0.0), y(0) {} ;

    double getX() const { return x ; }
    void setX(double value) { x = value ; }

    int getY() { return y ; }

private:
    double x ;
    int y ;
};

class Number{
public:
    Number() : x(0.0), y(0) {} ;

    double x ;
    int y ;
};

class Randomizer {
public:

    // Randomizer() : min(0), max(1) {}
    Randomizer(double min_, double max_) : min(min_), max(max_) {}

    NumericVector get(int n) {
        RNGScope scope ;
        return runif(n, min, max);
    }

private:
    double min, max ;
} ;

RCPP_EXPOSED_CLASS(Test)
class Test{
public:
    double value ;
    Test(double v) : value(v) {}
private:
    // hiding those on purpose
    // we work by reference or pointers here. Not by copy.
    Test(const Test& other) ;
    Test& operator=(const Test&) ;
} ;

double Test_get_x_const_ref(const Test& x) {
    return x.value ;
}
double Test_get_x_ref(Test& x) {
    return x.value;
}
double Test_get_x_const_pointer(const Test* x) {
    return x->value ;
}
double Test_get_x_pointer(Test* x) {
    return x->value ;
}

RCPP_MODULE(yada) {
    function("hello", &hello);
    function("bar"  , &bar  );
    function("foo"  , &foo  );
    function("bla"  , &bla  );
    function("bla1" , &bla1 );
    function("bla2" , &bla2 );

    function("test_reference", test_reference);
    function("test_const_reference", test_const_reference) ;
    function("test_const", test_const) ;

    class_<Test>("Test")
        .constructor<double>()
        ;

    class_<World>("World")

        .constructor()

        .method("greet", &World::greet)
        .method("set", &World::set)
        .method("set_ref", &World::set_ref)
        .method("set_const_ref", &World::set_const_ref)
        .method("clear", &clearWorld)
	;

    class_<Num>("Num")
        .constructor()

        // read and write property
        .property("x", &Num::getX, &Num::setX)

        // read-only property
        .property("y", &Num::getY)
        ;

    class_<Number>("Number")

        .constructor()

        // read and write data member
        .field("x", &Number::x)

        // read only data member
        .field_readonly("y", &Number::y)
        ;

    function("Test_get_x_const_ref", Test_get_x_const_ref);
    function("Test_get_x_ref", Test_get_x_ref);
    function("Test_get_x_const_pointer", Test_get_x_const_pointer);
    function("Test_get_x_pointer", Test_get_x_pointer);


    class_<Randomizer>("Randomizer")
        // No default: .default_constructor()
        .constructor<double,double>()

        .method("get" , &Randomizer::get)
        ;
}

// [[Rcpp::export]]
double attr_Test_get_x_const_ref(const Test& x) {
    return x.value ;
}

// [[Rcpp::export]]
double attr_Test_get_x_ref(Test& x) {
    return x.value;
}

// [[Rcpp::export]]
double attr_Test_get_x_const_pointer(const Test* x) {
    return x->value ;
}

// [[Rcpp::export]]
double attr_Test_get_x_pointer(Test* x) {
    return x->value ;
}