inline void serialize(
Archive & ar,
Eigen::Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> & t,
const unsigned int file_version
){
split_free(ar, t, file_version);
}
inline void serialize(
Archive & ar,
boost::unordered_map<T,U> & t,
const unsigned int file_version
){
split_free(ar, t, file_version);
}
inline void serialize( Archive& ar
, nt2::container::expression<E,R,D>& e
, unsigned int const& file_version
)
{
split_free(ar, e, file_version);
}
void serialize(Archive &ar, std::auto_ptr<T> &apt, const unsigned int version)
{
split_free(ar, apt, version);
}
inline void serialize(
Archive & ar,
Eigen::Matrix<S, Rows_, Cols_, Ops_, MaxRows_, MaxCols_> & g,
const unsigned int version)
{
split_free(ar, g, version);
}
typename boost::enable_if<typename Archive::is_saving, void>::type
operator () (Archive& ar,
const std::map<Key, T, Compare, Allocator>& data,
const unsigned int version)
{
split_free(ar, data, version);
}
inline void serialize(
Archive & ar,
boost::filesystem::path& p,
const unsigned int file_version)
{
split_free(ar, p, file_version);
}
void serialize(
Archive & ar,
boost::fusion::map<boost::fusion::pair<K1,D1> >& t,
const unsigned int file_version
)
{
split_free(ar, t, file_version);
}
void serialize(Archive & ar, ::fwData::DictionaryOrgan & _study, const unsigned int version)
{
// inform for serializer that this class is a subclass of a polymorphic one. Hence ptr serialisation of the base one
// can be well casted to the derivated one during the deserialisation
::boost::serialization::void_cast_register< ::fwData::DictionaryOrgan, fwTools::Object>(NULL,NULL);
split_free(ar,_study,version); // call load or save depending of archive type
}
inline void serialize(
Archive & ar,
gen_prog::ref_ptr< T > &t,
const unsigned int file_version
){
// correct ref_ptr serialization depends upon object tracking
// being used.
BOOST_STATIC_ASSERT(
boost::serialization::tracking_level< T >::value
!= boost::serialization::track_never
);
split_free(ar, t, file_version);
}
u32int *malloc_above(u32int size, u32int align, u32int above)
{
list_node_type *malloc_node = search_free((size + align), above);
vmm_data_type *malloc_data = malloc_node->data;
u32int start_addr = malloc_data->virt_addr;
u32int split_size = 0;
while (start_addr < above)
{
start_addr++;
split_size++;
}
while (start_addr % align != 0)
{
start_addr++;
split_size++;
}
if (split_size > 0)
{
malloc_node = split_free(malloc_node, size);
malloc_node = malloc_node->next;
}
list_node_type *split_node = split_free(malloc_node, size);
remove(vmm_free, split_node);
insert_last(vmm_used, split_node);
vmm_data_type *malloc_node_data = (vmm_data_type *) malloc_node->data;
u32int *malloc_ptr = (u32int *) malloc_node_data->virt_addr;
return malloc_ptr;
}
void serialize(
Archive & ar,
boost::fusion::map<
boost::fusion::pair<K1,D1>,
boost::fusion::pair<K2,D2>,
boost::fusion::pair<K3,D3>,
boost::fusion::pair<K4,D4>,
boost::fusion::pair<K5,D5>
>& t,
const unsigned int file_version
)
{
split_free(ar, t, file_version);
}
PGconn *pgdb_connect (char *host_name, char *user_name, char *password, char *db_name,
unsigned int port_num) {
char msg[1024];
char host[256];
int iDot, isIP = 0;
char **get = NULL;
PGconn *myconn = NULL;
memset(&msg, '\0', sizeof(msg));
memset(&host, '\0', sizeof(host));
strcpy(host, host_name);
get = split(host_name, ".");
if(get != NULL) {
iDot=0;
while(get[iDot] != NULL && strlen(get[iDot]) > 0) {
iDot++;
}
}
// printf("dot num %d\n", iDot);
split_free(get);
if(isdigit(host[0]) && iDot == 4) {
isIP = 1;
}
if(isIP) {
sprintf(msg, "hostaddr=%s user=%s password=%s dbname=%s port=%d ", host_name, user_name, password, db_name, port_num);
} else {
sprintf(msg, "host=%s user=%s password=%s dbname=%s port=%d ", host_name, user_name, password, db_name, port_num);
}
// printf("pq param : %s\n", msg);
myconn = PQconnectdb(msg);
if (PQstatus(myconn) == CONNECTION_BAD) {
Error("Koneksi ke PostgreSql salah, periksa database server !");
}
return myconn;
}
inline void serialize(Archive& ar,
odf::Graph<T>& graph,
const unsigned int file_version)
{
split_free(ar, graph, file_version);
}
template<class Archive> inline void serialize(Archive& ar, Swift::JID& t, const unsigned int file_version){
split_free(ar, t, file_version);
}
void serialize(Archive& ar, ptr_unordered_multiset<T, Hash, Pred, CloneAllocator, Allocator>& c, const unsigned int version)
{
split_free(ar, c, version);
}
void serialize(Archive& ar, ptr_array<T, N, CloneAllocator>& c, const unsigned int version)
{
split_free(ar, c, version);
}
void serialize( archive_type& archive, black_label::container::darray<T>& darray, unsigned int version )
{
split_free(archive, darray, version);
}
void serialize( Archive & ar,
boost::multi_array<double,2>& t,
const unsigned int file_version )
{
split_free( ar, t, file_version );
}
void
serialize(Archive & ar, arma::Mat<T>& mat, const unsigned int version) {
split_free(ar, mat, version);
}
void serialize( Archive & ar,
Eigen::Tensor<T,N>& t,
const unsigned int file_version )
{
split_free( ar, t, file_version );
}
inline void serialize(Archive & ar,
::boost::gregorian::date & d,
const unsigned int file_version)
{
split_free(ar, d, file_version);
}
void serialize( Archive & ar,
Eigen::Matrix<T,N,M>& t,
const unsigned int file_version )
{
split_free( ar, t, file_version );
}
void serialize( Archive & ar,
Eigen::VectorXd& t,
const unsigned int file_version )
{
split_free( ar, t, file_version );
}
template <class Archive> inline void serialize(Archive& ar, TruncatedBinomialDistribution::mpfr_class& number, const unsigned int version)
{
split_free(ar, number, version);
}
void mesh_refine(mesh* m, mflag* f)
{
the_split = split_new(m);
cavity_exec_flagged(m, f, refine_op, mesh_elem(m));
split_free(the_split);
}
inline void serialize(
Archive& ar,::boost::flyweights::flyweight<T,Arg1,Arg2,Arg3>& f,
const unsigned int version)
{
split_free(ar,f,version);
}
inline void serialize( Archive & ar, ::boost::intrusive_ptr<T> & t, const uint32_t file_version ) {
split_free(ar, t, file_version);
}
void serialize( Archive & ar,
Eigen::Matrix<T,RowsAtCompileTime,ColsAtCompileTime,Options,MaxRowsAtCompileTime,MaxColsAtCompileTime>& t,
const unsigned int file_version )
{
split_free( ar, t, file_version );
}
void serialize( Archive & ar,
boost::multi_array<Eigen::VectorXd,2>& t,
const unsigned int file_version )
{
split_free( ar, t, file_version );
}