void Foam::writeFuns::write
(
std::ostream& os,
const bool binary,
List<floatScalar>& fField
)
{
if (binary)
{
#ifdef LITTLEENDIAN
swapWords(fField.size(), reinterpret_cast<int32_t*>(fField.begin()));
#endif
os.write
(
reinterpret_cast<char*>(fField.begin()),
fField.size()*sizeof(float)
);
os << std::endl;
}
else
{
forAll(fField, i)
{
os << fField[i] << ' ';
if (i > 0 && (i % 10) == 0)
{
os << std::endl;
}
}
os << std::endl;
}
void
Reader::readHeader()
{
read((char*)&m_header + sizeof(uint32),
sizeof(Header) - sizeof(uint32));
if (m_error) return;
m_swapped = false;
if (m_header.magic == Header::Cigam)
{
m_swapped = true;
swapWords(&m_header, sizeof(m_header) / sizeof(int));
}
else if (m_header.magic != Header::Magic)
{
ostringstream str;
str << "bad magic number (" << hex << m_header.magic << ")";
fail( str.str() );
return;
}
if (m_header.version != GTO_VERSION && m_header.version != 2)
{
fail( "version mismatch" );
cerr << "ERROR: Gto::Reader: gto file version == "
<< m_header.version << ", which is not readable by this version (v"
<< GTO_VERSION << ")\n";
return;
}
header(m_header);
}
void
Reader::readProperties()
{
size_t index = 0;
for (Components::iterator i = m_components.begin();
i != m_components.end();
++i)
{
const ComponentInfo &c = *i;
for (uint32 q=0; q < c.numProperties; q++)
{
PropertyInfo p;
p.index = index++;
if (m_header.version == 2)
{
read((char*)&p, sizeof(PropertyHeader_v2));
p.pad = 0;
p.interpretation = 0;
}
else
{
read((char*)&p, sizeof(PropertyHeader));
}
if (m_error) return;
if (m_swapped)
{
swapWords(&p, sizeof(PropertyHeader) / sizeof(int));
}
p.component = &c;
if (c.requested && !(m_mode & RandomAccess))
{
stringFromId(p.name);
stringFromId(p.interpretation);
if (m_error) return;
Request r = property(stringFromId(p.name),
stringFromId(p.interpretation),
p);
p.requested = r.m_want;
p.propertyData = r.m_data;
}
else
{
p.requested = false;
}
m_properties.push_back(p);
}
}
}
void
Reader::readComponents()
{
int poffset = 0;
for (Objects::iterator i = m_objects.begin();
i != m_objects.end();
++i)
{
const ObjectInfo &o = *i;
for (uint32 q=0; q < o.numComponents; q++)
{
ComponentInfo c;
if (m_header.version == 2)
{
read((char*)&c, sizeof(ComponentHeader_v2));
c.pad = 0;
c.interpretation = 0;
}
else
{
read((char*)&c, sizeof(ComponentHeader));
}
if (m_error) return;
if (m_swapped) swapWords(&c, sizeof(ComponentHeader) / sizeof(int));
c.object = &o;
c.poffset = poffset;
poffset += c.numProperties;
if (o.requested && !(m_mode & RandomAccess))
{
stringFromId(c.name); // sanity checks
stringFromId(c.interpretation);
if (m_error) return;
Request r = component(stringFromId(c.name),
stringFromId(c.interpretation),
c);
c.requested = r.m_want;
c.componentData = r.m_data;
}
else
{
c.requested = false;
}
m_components.push_back(c);
}
}
}
void
Reader::readObjects()
{
int coffset = 0;
for (uint32 i=0; i < m_header.numObjects; i++)
{
ObjectInfo o;
if (m_header.version == 2)
{
read((char*)&o, sizeof(ObjectHeader_v2));
o.pad = 0;
}
else
{
read((char*)&o, sizeof(ObjectHeader));
}
if (m_error) return;
if (m_swapped) swapWords(&o, sizeof(ObjectHeader) / sizeof(int));
stringFromId(o.name);
stringFromId(o.protocolName);
o.coffset = coffset;
coffset += o.numComponents;
if (m_error)
{
o.requested = false;
return;
}
else if (!(m_mode & RandomAccess))
{
Request r = object( stringFromId(o.name),
stringFromId(o.protocolName),
o.protocolVersion,
o);
o.requested = r.m_want;
o.objectData = r.m_data;
}
m_objects.push_back(o);
}
}
/*
* Sorts words based on greatest frequency of word count.
*/
void sortWords(wordData* firstWord) {
int firstCount, nextCount, swapped;
wordData* i = firstWord;
do {
swapped = 0;
i = firstWord;
while (i->next != NULL) {
firstCount = getWordCount(i);
nextCount = getWordCount(i->next);
if (firstCount < nextCount) {
swapWords(i, i->next);
swapped = 1;
}
i = i->next;
}
} while(swapped);
}
bool
Reader::readProperty(PropertyInfo& prop)
{
size_t num = prop.size * prop.width;
size_t bytes = num * dataSize(prop.type);
char* buffer = 0;
//
// Cache the offset pointer
//
if( m_currentReadOffset == 0 )
{
// Offset can never be zero here, so it must be
// uninitialized. Set it to the real file position.
m_currentReadOffset = tell();
}
prop.offset = m_currentReadOffset;
bool readok = false;
if (prop.requested)
{
if ((buffer = (char*)data(prop, bytes)))
{
if(prop.index < m_dataOffsets.size())
{
seekTo(prop);
}
else
{
// Do we need to be somewhere else?
if(m_currentReadOffset != tell())
{
// If so, move the actual file pointer there.
seekForward(m_currentReadOffset - tell());
}
}
read(buffer, bytes);
readok = true;
}
}
// Move the 'virtual' file offset forward by the data
// size of this property, whether we read it or not.
m_currentReadOffset += bytes;
if (m_error) return false;
if (readok)
{
if (m_swapped)
{
switch (prop.type)
{
case Gto::Int:
case Gto::String:
case Gto::Float:
swapWords(buffer, num);
break;
case Gto::Short:
case Gto::Half:
swapShorts(buffer, num);
break;
case Gto::Double:
swapWords(buffer, num * 2);
break;
case Gto::Byte:
case Gto::Boolean:
break;
}
}
dataRead(prop);
}
return true;
}
bool
Reader::readProperty(PropertyInfo& prop)
{
size_t num = prop.size * elementSize(prop.dims);
size_t bytes = dataSizeInBytes(prop.type) * num;
char* buffer = 0;
//
// Cache the offset pointer
//
prop.offset = tell();
bool readok = false;
if (prop.requested)
{
if ((buffer = (char*)data(prop, bytes)))
{
read(buffer, bytes);
if (!m_error) readok = true;
}
else
{
seekForward(bytes);
}
}
else
{
seekForward(bytes);
}
if (m_error) return false;
if (readok)
{
if (m_swapped)
{
switch (prop.type)
{
case Gto::Int:
case Gto::String:
case Gto::Float:
swapWords(buffer, num);
break;
case Gto::Short:
case Gto::Half:
swapShorts(buffer, num);
break;
case Gto::Double:
swapWords(buffer, num * 2);
break;
case Gto::Byte:
case Gto::Boolean:
break;
}
}
dataRead(prop);
}
return true;
}
void
Reader::readProperties()
{
for (Components::iterator i = m_components.begin();
i != m_components.end();
++i)
{
const ComponentInfo &c = *i;
for (uint32 q=0; q < c.numProperties; q++)
{
PropertyInfo p;
if (m_header.version == 2)
{
PropertyHeader_v2 pv2;
read((char*)&pv2, sizeof(PropertyHeader_v2));
if (m_swapped) swapWords(&pv2, sizeof(PropertyHeader_v2) / sizeof(uint32));
p.name = pv2.name;
p.size = pv2.size;
p.type = pv2.type;
p.dims.x = pv2.width;
p.dims.y = 0;
p.dims.z = 0;
p.dims.w = 0;
p.interpretation = 0;
}
else if (m_header.version == 3)
{
PropertyHeader_v3 pv3;
read((char*)&pv3, sizeof(PropertyHeader_v3));
if (m_swapped) swapWords(&pv3, sizeof(PropertyHeader_v3) / sizeof(uint32));
p.name = pv3.name;
p.size = pv3.size;
p.type = pv3.type;
p.dims.x = pv3.width;
p.dims.y = 0;
p.dims.z = 0;
p.dims.w = 0;
p.interpretation = pv3.interpretation;
}
else
{
read((char*)&p, sizeof(PropertyHeader));
if (m_swapped) swapWords(&p, sizeof(PropertyHeader) / sizeof(uint32));
}
if (m_error) return;
p.component = &c;
p.fullName = c.fullName;
p.fullName += ".";
p.fullName += stringFromId(p.name);
if (c.requested && !(m_mode & RandomAccess))
{
stringFromId(p.name);
stringFromId(p.interpretation);
if (m_error) return;
Request r = property(stringFromId(p.name),
stringFromId(p.interpretation),
p);
p.requested = r.m_want;
p.propertyData = r.m_data;
}
else
{
p.requested = false;
}
m_properties.push_back(p);
}
}
}
void
Reader::readComponents()
{
int poffset = 0;
for (Objects::iterator i = m_objects.begin();
i != m_objects.end();
++i)
{
const ObjectInfo &o = *i;
for (uint32 q = 0; q < o.numComponents; q++)
{
ComponentInfo c;
if (m_header.version == 2)
{
read((char*)&c, sizeof(ComponentHeader_v2));
c.childLevel = 0;
c.interpretation = 0;
}
else
{
read((char*)&c, sizeof(ComponentHeader));
}
if (m_error) return;
if (m_swapped) swapWords(&c, sizeof(ComponentHeader) / sizeof(int));
c.object = &o;
c.poffset = poffset;
c.parent = NULL;
poffset += c.numProperties;
for (size_t ioffset = 1; c.parent == 0 && ioffset <= q; ioffset++)
{
const size_t index = m_components.size() - ioffset;
if (m_components[index].childLevel < c.childLevel)
{
c.parent = &m_components[index];
break;
}
}
if (c.parent)
{
ostringstream str;
str << c.parent->fullName << "." << stringFromId(c.name);
c.fullName = str.str();
}
else
{
c.fullName = stringFromId(c.name);
}
if (o.requested && !(m_mode & RandomAccess))
{
stringFromId(c.name); // sanity checks
stringFromId(c.interpretation);
if (m_error) return;
Request r = component(stringFromId(c.name),
stringFromId(c.interpretation),
c);
c.requested = r.m_want;
c.componentData = r.m_data;
}
else
{
c.requested = false;
}
m_components.push_back(c);
}
}
}
