//////////////////////////////////////////////////////////////////////////

//

// Copyright (c) 2009-2012, Image Engine Design 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 Image Engine Design nor the names of any

// other contributors to this software 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.

//

//////////////////////////////////////////////////////////////////////////

#include "boost/python.hpp"

#include "IECorePython/DateTimeDataBinding.h"

#include "IECorePython/IECoreBinding.h"

#include "IECorePython/RunTimeTypedBinding.h"

#include "IECorePython/SimpleTypedDataBinding.h"

#include "IECore/DateTimeData.h"

#include "IECore/Export.h"

IECORE_PUSH_DEFAULT_VISIBILITY

#include "boost/date_time/posix_time/posix_time.hpp"

IECORE_POP_DEFAULT_VISIBILITY

#include "boost/date_time/posix_time/time_parsers.hpp"

#include "boost/python/make_constructor.hpp"

#include <sstream>

#include <datetime.h>

using namespace boost;

using namespace boost::python;

using namespace IECore;

namespace IECorePython

{

static int getMicroseconds( const posix_time::time_duration &dur )

{

static long ticksPerSecond = posix_time::time_duration::ticks_per_second();

long fractionalSeconds = dur.fractional_seconds();

static const int oneMillion = 1000000;

/// Prevent over/underflow

if ( ticksPerSecond > oneMillion )

{

return fractionalSeconds / ( ticksPerSecond / oneMillion );

}

else

{

return fractionalSeconds * ( oneMillion / ticksPerSecond );

}

}

struct ptime_from_python_datetime

{

ptime_from_python_datetime()

{

converter::registry::push_back(

&convertible,

&construct,

type_id<posix_time::ptime> ()

);

}

static void *convertible( PyObject *obj_ptr )

{

if ( !PyDateTime_Check( obj_ptr ) )

{

return nullptr;

}

return obj_ptr;

}

static void construct(

PyObject *obj_ptr,

converter::rvalue_from_python_stage1_data *data )

{

assert( obj_ptr );

assert( PyDateTime_Check( obj_ptr ) );

PyDateTime_DateTime const* datetime = reinterpret_cast<PyDateTime_DateTime*>( obj_ptr );

const posix_time::ptime t(

gregorian::date(

PyDateTime_GET_YEAR( datetime ),

PyDateTime_GET_MONTH( datetime ),

PyDateTime_GET_DAY( datetime )

),

posix_time::time_duration(

PyDateTime_DATE_GET_HOUR( datetime ),

PyDateTime_DATE_GET_MINUTE( datetime ),

PyDateTime_DATE_GET_SECOND( datetime ),

0

) + posix_time::microseconds( PyDateTime_DATE_GET_MICROSECOND( datetime ) )

);

void* storage = (( converter::rvalue_from_python_storage<posix_time::ptime>* ) data )->storage.bytes;

new( storage ) posix_time::ptime( t );

data->convertible = storage;

}

};

struct ptime_to_python

{

static PyObject *convert( const posix_time::ptime &t )

{

if ( t.is_special() )

{

PyErr_SetString(PyExc_ValueError, "Cannot convert out-of-range ptime to datetime");

throw_error_already_set();

}

gregorian::date date = t.date();

posix_time::time_duration dur = t.time_of_day();

return PyDateTime_FromDateAndTime(

static_cast<int>( date.year() ),

static_cast<int>( date.month() ),

static_cast<int>( date.day() ),

static_cast<int>( dur.hours() ),

static_cast<int>( dur.minutes() ),

static_cast<int>( dur.seconds() ),

getMicroseconds( dur )

);

}

};

template<>

std::string repr<DateTimeData>( DateTimeData &x )

{

object item( x.readable() );

assert( item.attr( "__repr__" ) != object() );

std::stringstream s;

s << "IECore.DateTimeData( ";

s << call_method< std::string >( item.ptr(), "__repr__" );

s << " )";

return s.str();

}

template<>

std::string str<DateTimeData>( DateTimeData &x )

{

return posix_time::to_simple_string( x.readable() );

}

static void setValue( DateTimeDataPtr data, const posix_time::ptime &v )

{

assert( data );

data->writable() = v;

}

static const posix_time::ptime &getValue( DateTimeDataPtr data )

{

assert( data );

return data->readable();

}

void bindDateTimeData()

{

PyDateTime_IMPORT;

ptime_from_python_datetime();

to_python_converter<posix_time::ptime, ptime_to_python > ();

TypedDataFromType<DateTimeData>();

RunTimeTypedClass<DateTimeData>()

.def( init<>() )

.def( init<const DateTimeData::ValueType &>() )

.add_property( "value", make_function( &getValue, return_value_policy<copy_const_reference>() ), &setValue )

.def( "__repr__", &repr<DateTimeData> )

.def( "__str__", &str<DateTimeData> )

.def( "hasBase", &DateTimeData::hasBase ).staticmethod( "hasBase" )

;

}

} // namespace IECorePython