bool
Reader::accessObject(ObjectInfo& o)
{
Request r = object(stringFromId(o.name),
stringFromId(o.protocolName),
o.protocolVersion,
o);
o.requested = r.m_want;
o.objectData = r.m_data;
if (o.requested)
{
for (uint32 q=0; q < o.numComponents; q++)
{
assert( (o.coffset+q) < m_components.size() );
ComponentInfo& c = m_components[o.coffset + q];
bool success = accessComponent(c);
if (!success) return false;
}
}
return true;
}
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);
}
}
}
bool
Reader::accessProperty(PropertyInfo& p)
{
Request r = property(stringFromId(p.name), stringFromId(p.interpretation), p);
p.requested = r.m_want;
p.propertyData = r.m_data;
if (p.requested)
{
seekTo(p);
readProperty(p);
}
return true;
}
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);
}
}
bool
Reader::readBinaryGTO()
{
readIndexTable(); // OK to continue if this fails
readHeader(); if (m_error) return false;
readStringTable(); if (m_error) return false;
readObjects(); if (m_error) return false;
readComponents(); if (m_error) return false;
readProperties(); if (m_error) return false;
descriptionComplete();
if (m_mode & HeaderOnly)
{
return true;
}
Properties::iterator p = m_properties.begin();
for (Components::iterator i = m_components.begin();
i != m_components.end();
++i)
{
ComponentInfo &comp = *i;
if (comp.flags & Gto::Transposed)
{
cerr << "ERROR: Transposed data for '"
<< stringFromId( comp.object->name ) << "."
<< stringFromId( comp.name )
<< "' is currently unsupported." << endl;
abort();
}
else
{
for (Properties::iterator e = p + comp.numProperties; p != e; ++p)
{
if (!readProperty(*p))
{
return false;
}
}
}
}
return true;
}
//-*****************************************************************************
void
Reader::dataRead( const PropertyInfo &info )
{
Property *p = reinterpret_cast<Property*>( info.propertyData );
if ( StringProperty *sp = dynamic_cast<StringProperty*>( p ) )
{
for ( int i = 0; i < m_tempstrings.size(); ++i )
{
(*sp)[i] = stringFromId( m_tempstrings[i] );
}
m_tempstrings.clear();
}
}
bool
Reader::accessComponent(ComponentInfo& c)
{
const std::string &nme = stringFromId(c.name);
Request r = component(nme, c);
c.requested = r.m_want;
c.componentData = r.m_data;
if (c.requested)
{
for (uint32 j=0; j < c.numProperties; j++)
{
PropertyInfo& p = m_properties[c.poffset + j];
bool success = accessProperty(p);
if (!success) return false;
}
}
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);
}
}
}
