I am tearing my hair out over this, partly because I believe the code used
to compile. I just can't see what the problem is. I enclose all the
pertinent code as I cannot say which bits are irrelevant.
There are two classes:
ManagedArray which is an array of data without size or capacity data
(this is stored elsewhere).
PersistentManagedArray which I wrote to enable ManagedArrays to be
serialized.
The error message is produced in 'main':
error: no match for 'operator<<' in 'oa << PersistentManagedArray<int>((*
& size), (* & capacity), (* & ints))'
It seems to me that I have defined the necessary serialize member function
with the right signature. Commented out is code I
wrote some time ago which used separate load and save functions. This, I
believe, used to work.
#include <fstream>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <string>
using namespace std;
//****************************************************************************************************************************
template<class T>
class ManagedArray {
public:
T *values;
ManagedArray() {
values = NULL;
}
~ManagedArray() {
if (values) {
delete [] values;
}
}
//Changes array size. If array grows, the new values are unintialized.
void resize(unsigned oldSize, unsigned newSize) {
if (oldSize==newSize) return;
T *newValues = (newSize==0) ? NULL : new T[newSize];
if (oldSize!=0) {
T *oldValue, *newValue;
T *end = values + (oldSize<newSize ? oldSize : newSize);
for(oldValue=values, newValue=newValues; oldValue<end;
oldValue++, newValue++) {
*newValue = *oldValue;
}
}
if (values) {
delete [] values;
}
values = newValues;
}
//Changes array size. If array grows, the new values are
initialised to copies of a prototype, initValue.
void resize(unsigned oldSize, unsigned newSize, T &initValue) {
if (oldSize==newSize) return;
T *newValues = (newSize==0) ? NULL : new T[newSize];
T *oldValue = values;
T *newValue = newValues;
if (oldSize!=0) {
T *oldEnd = values + (oldSize<newSize ? oldSize : newSize);
for(; oldValue<oldEnd; oldValue++, newValue++) {
*newValue = *oldValue;
}
}
T *newEnd = newValues + newSize;
for(; newValue<newEnd; newValue++) {
*newValue = initValue;
}
delete [] values;
values = newValues;
}
inline T &operator[](unsigned index) {
return values[index];
}
inline const T &operator[](unsigned index) const {
return values[index];
}
};
//****************************************************************************************************************************
//This class helps to save a ManagedArray in a Boost archive
// Usage:
// ar & PersistentManagedArray(size, capacity, array);
template<class T>
class PersistentManagedArray {
public:
PersistentManagedArray(unsigned &size, unsigned &capacity,
ManagedArray<T> &managedArray) :
_size(size),
_capacity(capacity),
_managedArray(managedArray) {valueArrayExists =
(_managedArray.values!=NULL);}
private:
unsigned &_size;
unsigned &_capacity;
ManagedArray<T> &_managedArray;
bool valueArrayExists;
friend class boost::serialization::access;
// template<class Archive>
// void save(Archive & ar, const unsigned int version) const {
// ar & valueArrayExists;
// if (valueArrayExists) {
// for(unsigned i=0; i<_size; i++) {
// ar & _managedArray.values[i];
// }
// }
// }
// template<class Archive>
// void load(Archive & ar, const unsigned int version) {
// _managedArray.values = NULL;
// ar & valueArrayExists;
// if (valueArrayExists) {
// _managedArray.resize(0, _capacity);
// for(unsigned i=0; i<_size; i++) {
// ar & _managedArray.values[i];
// }
// }
// }
// BOOST_SERIALIZATION_SPLIT_MEMBER()
template<class Archive>
void serialize(Archive & ar, const unsigned int version) {
ar & valueArrayExists;
ar & _size;
ar & _capacity;
if (Archive::is_loading::value) {
delete _managedArray.values;
_managedArray.values = new T[_capacity];
}
for(unsigned i=0; i<_size; i++) {
ar & _managedArray.values[i];
}
}
};
int main(int argc, char *argv[]) {
ManagedArray<int> ints;
unsigned size;
unsigned capacity;
string fileName = "data.xxx";
ofstream file(fileName.c_str(), ios::out|ios::binary);
if (file.good()) {
boost::archive::binary_oarchive oa(file);
oa << PersistentManagedArray<int>(size, capacity, ints); //This
line does not compile !
}
}
