/*
* ALMA - Atacama Large Millimeter Array
* (c) European Southern Observatory, 2002
* (c) Associated Universities Inc., 2002
* Copyright by ESO (in the framework of the ALMA collaboration),
* Copyright by AUI (in the framework of the ALMA collaboration),
* All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY, without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
* Warning!
* --------------------------------------------------------------------
* | This is generated code! Do not modify this file. |
* | If you do, all changes will be lost when the file is re-generated. |
* --------------------------------------------------------------------
*
* File MainTable.cpp
*/
#include <alma/ASDM/ConversionException.h>
#include <alma/ASDM/DuplicateKey.h>
#include <alma/ASDM/OutOfBoundsException.h>
using asdm::ConversionException;
using asdm::DuplicateKey;
using asdm::OutOfBoundsException;
#include <alma/ASDM/ASDM.h>
#include <alma/ASDM/MainTable.h>
#include <alma/ASDM/MainRow.h>
#include <alma/ASDM/Parser.h>
using asdm::ASDM;
using asdm::MainTable;
using asdm::MainRow;
using asdm::Parser;
#include <iostream>
#include <fstream>
#include <iterator>
#include <sstream>
#include <set>
#include <algorithm>
using namespace std;
#include <alma/ASDM/Misc.h>
using namespace asdm;
#include <libxml/parser.h>
#include <libxml/tree.h>
#ifndef WITHOUT_BOOST
#include "boost/filesystem/operations.hpp"
#include <boost/algorithm/string.hpp>
#else
#include <sys/stat.h>
#endif
namespace asdm {
// The name of the entity we will store in this table.
static string entityNameOfMain = "Main";
// An array of string containing the names of the columns of this table.
// The array is filled in the order : key, required value, optional value.
//
static string attributesNamesOfMain_a[] = {
"time"
,
"configDescriptionId"
,
"fieldId"
, "numAntenna"
, "timeSampling"
, "interval"
, "numIntegration"
, "scanNumber"
, "subscanNumber"
, "dataSize"
, "dataUID"
, "stateId"
, "execBlockId"
};
// A vector of string whose content is a copy of the strings in the array above.
//
static vector<string> attributesNamesOfMain_v (attributesNamesOfMain_a, attributesNamesOfMain_a + sizeof(attributesNamesOfMain_a) / sizeof(attributesNamesOfMain_a[0]));
// An array of string containing the names of the columns of this table.
// The array is filled in the order where the names would be read by default in the XML header of a file containing
// the table exported in binary mode.
//
static string attributesNamesInBinOfMain_a[] = {
"time" , "configDescriptionId" , "fieldId" , "numAntenna" , "timeSampling" , "interval" , "numIntegration" , "scanNumber" , "subscanNumber" , "dataSize" , "dataUID" , "stateId" , "execBlockId"
,
};
// A vector of string whose content is a copy of the strings in the array above.
//
static vector<string> attributesNamesInBinOfMain_v(attributesNamesInBinOfMain_a, attributesNamesInBinOfMain_a + sizeof(attributesNamesInBinOfMain_a) / sizeof(attributesNamesInBinOfMain_a[0]));
// The array of attributes (or column) names that make up key key.
//
string keyOfMain_a[] = {
"time"
,
"configDescriptionId"
,
"fieldId"
};
// A vector of strings which are copies of those stored in the array above.
vector<string> keyOfMain_v(keyOfMain_a, keyOfMain_a + sizeof(keyOfMain_a) / sizeof(keyOfMain_a[0]));
/**
* Return the list of field names that make up key key
* as a const reference to a vector of strings.
*/
const vector<string>& MainTable::getKeyName() {
return keyOfMain_v;
}
MainTable::MainTable(ASDM &c) : container(c) {
// Define a default entity.
entity.setEntityId(EntityId("uid://X0/X0/X0"));
entity.setEntityIdEncrypted("na");
entity.setEntityTypeName("MainTable");
entity.setEntityVersion("1");
entity.setInstanceVersion("1");
// Archive XML
archiveAsBin = false;
// File XML
fileAsBin = false;
// By default the table is considered as present in memory
presentInMemory = true;
// By default there is no load in progress
loadInProgress = false;
}
/**
* A destructor for MainTable.
*/
MainTable::~MainTable() {
for (unsigned int i = 0; i < privateRows.size(); i++)
delete(privateRows.at(i));
}
/**
* Container to which this table belongs.
*/
ASDM &MainTable::getContainer() const {
return container;
}
/**
* Return the number of rows in the table.
*/
unsigned int MainTable::size() const {
if (presentInMemory)
return privateRows.size();
else
return declaredSize;
}
/**
* Return the name of this table.
*/
string MainTable::getName() const {
return entityNameOfMain;
}
/**
* Return the name of this table.
*/
string MainTable::name() {
return entityNameOfMain;
}
/**
* Return the the names of the attributes (or columns) of this table.
*/
const vector<string>& MainTable::getAttributesNames() { return attributesNamesOfMain_v; }
/**
* Return the the names of the attributes (or columns) of this table as they appear by default
* in an binary export of this table.
*/
const vector<string>& MainTable::defaultAttributesNamesInBin() { return attributesNamesInBinOfMain_v; }
/**
* Return this table's Entity.
*/
Entity MainTable::getEntity() const {
return entity;
}
/**
* Set this table's Entity.
*/
void MainTable::setEntity(Entity e) {
this->entity = e;
}
//
// ====> Row creation.
//
/**
* Create a new row.
*/
MainRow *MainTable::newRow() {
return new MainRow (*this);
}
/**
* Create a new row initialized to the specified values.
* @return a pointer on the created and initialized row.
* @param time
* @param configDescriptionId
* @param fieldId
* @param numAntenna
* @param timeSampling
* @param interval
* @param numIntegration
* @param scanNumber
* @param subscanNumber
* @param dataSize
* @param dataUID
* @param stateId
* @param execBlockId
*/
MainRow* MainTable::newRow(ArrayTime time, Tag configDescriptionId, Tag fieldId, int numAntenna, TimeSamplingMod::TimeSampling timeSampling, Interval interval, int numIntegration, int scanNumber, int subscanNumber, int64_t dataSize, EntityRef dataUID, std::vector<Tag> stateId, Tag execBlockId){
MainRow *row = new MainRow(*this);
row->setTime(time);
row->setConfigDescriptionId(configDescriptionId);
row->setFieldId(fieldId);
row->setNumAntenna(numAntenna);
row->setTimeSampling(timeSampling);
row->setInterval(interval);
row->setNumIntegration(numIntegration);
row->setScanNumber(scanNumber);
row->setSubscanNumber(subscanNumber);
row->setDataSize(dataSize);
row->setDataUID(dataUID);
row->setStateId(stateId);
row->setExecBlockId(execBlockId);
return row;
}
MainRow* MainTable::newRow(MainRow* row) {
return new MainRow(*this, row);
}
//
// Append a row to its table.
//
/**
* Returns a string built by concatenating the ascii representation of the
* parameters values suffixed with a "_" character.
*/
string MainTable::Key(Tag configDescriptionId, Tag fieldId) {
ostringstream ostrstr;
ostrstr
<< configDescriptionId.toString() << "_"
<< fieldId.toString() << "_"
;
return ostrstr.str();
}
MainRow* MainTable::add(MainRow* x) {
string keystr = Key(
x->getConfigDescriptionId()
,
x->getFieldId()
);
if (context.find(keystr) == context.end()) {
vector<MainRow *> v;
context[keystr] = v;
}
return insertByTime(x, context[keystr]);
}
void MainTable::addWithoutCheckingUnique(MainRow * x) {
MainRow * dummy = checkAndAdd(x, true); // We require the check for uniqueness to be skipped.
// by passing true in the second parameter
// whose value by default is false.
// this statement is never executed, but it hides the unused return value from the compiler to silence that warning.
if (false) cout << (unsigned long long) dummy;
}
//
// A private method to append a row to its table, used by input conversion
// methods, with row uniqueness.
//
MainRow* MainTable::checkAndAdd(MainRow* x, bool /* skipCheckUniqueness */ ) {
string keystr = Key(
x->getConfigDescriptionId()
,
x->getFieldId()
);
if (context.find(keystr) == context.end()) {
vector<MainRow *> v;
context[keystr] = v;
}
vector<MainRow*>& found = context.find(keystr)->second;
return insertByTime(x, found);
}
//
// A private method to brutally append a row to its table, without checking for row uniqueness.
//
void MainTable::append(MainRow *x) {
privateRows.push_back(x);
x->isAdded(true);
}
vector<MainRow *> MainTable::get() {
checkPresenceInMemory();
return privateRows;
}
const vector<MainRow *>& MainTable::get() const {
const_cast<MainTable&>(*this).checkPresenceInMemory();
return privateRows;
}
vector<MainRow *> *MainTable::getByContext(Tag configDescriptionId, Tag fieldId) {
//if (getContainer().checkRowUniqueness() == false)
//throw IllegalAccessException ("The method 'getByContext' can't be called because the dataset has been built without checking the row uniqueness.", "MainTable");
checkPresenceInMemory();
string k = Key(configDescriptionId, fieldId);
if (context.find(k) == context.end()) return 0;
else return &(context[k]);
}
/*
** Returns a MainRow* given a key.
** @return a pointer to the row having the key whose values are passed as parameters, or 0 if
** no row exists for that key.
**
*/
MainRow* MainTable::getRowByKey(ArrayTime time, Tag configDescriptionId, Tag fieldId) {
checkPresenceInMemory();
string keystr = Key(configDescriptionId, fieldId);
if (context.find(keystr) == context.end()) return 0;
vector<MainRow* > row = context[keystr];
// Is the vector empty...impossible in principle !
if (row.size() == 0) return 0;
// Only one element in the vector
if (row.size() == 1) {
if (time.get() == row.at(0)->getTime().get())
return row.at(0);
else
return 0;
}
// Optimizations
MainRow* last = row.at(row.size()-1);
if (time.get() > last->getTime().get()) return 0;
MainRow* first = row.at(0);
if (time.get() < first->getTime().get()) return 0;
// More than one row
// let's use a dichotomy method for the general case..
int k0 = 0;
int k1 = row.size() - 1;
while (k0 != k1 ) {
if (time.get() == row.at(k0)->getTime().get()) {
return row.at(k0);
}
else if (time.get() == row.at(k1)->getTime().get()) {
return row.at(k1);
}
else {
if (time.get() <= row.at((k0+k1)/2)->getTime().get())
k1 = (k0 + k1) / 2;
else
k0 = (k0 + k1) / 2;
}
}
return 0;
}
#ifndef WITHOUT_ACS
using asdmIDL::MainTableIDL;
#endif
#ifndef WITHOUT_ACS
// Conversion Methods
MainTableIDL *MainTable::toIDL() {
MainTableIDL *x = new MainTableIDL ();
unsigned int nrow = size();
x->row.length(nrow);
vector<MainRow*> v = get();
for (unsigned int i = 0; i < nrow; ++i) {
//x->row[i] = *(v[i]->toIDL());
v[i]->toIDL(x->row[i]);
}
return x;
}
void MainTable::toIDL(asdmIDL::MainTableIDL& x) const {
unsigned int nrow = size();
x.row.length(nrow);
vector<MainRow*> v = get();
for (unsigned int i = 0; i < nrow; ++i) {
v[i]->toIDL(x.row[i]);
}
}
#endif
#ifndef WITHOUT_ACS
void MainTable::fromIDL(MainTableIDL x) {
unsigned int nrow = x.row.length();
for (unsigned int i = 0; i < nrow; ++i) {
MainRow *tmp = newRow();
tmp->setFromIDL(x.row[i]);
// checkAndAdd(tmp);
add(tmp);
}
}
#endif
string MainTable::toXML() {
string buf;
buf.append("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?> ");
buf.append("<MainTable xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:main=\"http://Alma/XASDM/MainTable\" xsi:schemaLocation=\"http://Alma/XASDM/MainTable http://almaobservatory.org/XML/XASDM/4/MainTable.xsd\" schemaVersion=\"4\" schemaRevision=\"-1\">\n");
buf.append(entity.toXML());
string s = container.getEntity().toXML();
// Change the "Entity" tag to "ContainerEntity".
buf.append("<Container" + s.substr(1,s.length() - 1)+" ");
vector<MainRow*> v = get();
for (unsigned int i = 0; i < v.size(); ++i) {
try {
buf.append(v[i]->toXML());
} catch (const NoSuchRow &e) {
}
buf.append(" ");
}
buf.append("</MainTable> ");
return buf;
}
string MainTable::getVersion() const {
return version;
}
void MainTable::fromXML(string& tableInXML) {
//
// Look for a version information in the schemaVersion of the XML
//
xmlDoc *doc;
#if LIBXML_VERSION >= 20703
doc = xmlReadMemory(tableInXML.data(), tableInXML.size(), "XMLTableHeader.xml", NULL, XML_PARSE_NOBLANKS|XML_PARSE_HUGE);
#else
doc = xmlReadMemory(tableInXML.data(), tableInXML.size(), "XMLTableHeader.xml", NULL, XML_PARSE_NOBLANKS);
#endif
if ( doc == NULL )
throw ConversionException("Failed to parse the xmlHeader into a DOM structure.", "Main");
xmlNode* root_element = xmlDocGetRootElement(doc);
if ( root_element == NULL || root_element->type != XML_ELEMENT_NODE )
throw ConversionException("Failed to retrieve the root element in the DOM structure.", "Main");
xmlChar * propValue = xmlGetProp(root_element, (const xmlChar *) "schemaVersion");
if ( propValue != 0 ) {
version = string( (const char*) propValue);
xmlFree(propValue);
}
Parser xml(tableInXML);
if (!xml.isStr("<MainTable"))
error();
// cout << "Parsing a MainTable" << endl;
string s = xml.getElement("<Entity","/>");
if (s.length() == 0)
error();
Entity e;
e.setFromXML(s);
if (e.getEntityTypeName() != "MainTable")
error();
setEntity(e);
// Skip the container's entity; but, it has to be there.
s = xml.getElement("<ContainerEntity","/>");
if (s.length() == 0)
error();
// Get each row in the table.
s = xml.getElementContent("<row>","</row>");
MainRow *row;
if (getContainer().checkRowUniqueness()) {
try {
while (s.length() != 0) {
row = newRow();
row->setFromXML(s);
checkAndAdd(row);
s = xml.getElementContent("<row>","</row>");
}
}
catch (const DuplicateKey &e1) {
throw ConversionException(e1.getMessage(),"MainTable");
}
catch (const UniquenessViolationException &e1) {
throw ConversionException(e1.getMessage(),"MainTable");
}
catch (...) {
// cout << "Unexpected error in MainTable::checkAndAdd called from MainTable::fromXML " << endl;
}
}
else {
try {
while (s.length() != 0) {
row = newRow();
row->setFromXML(s);
addWithoutCheckingUnique(row);
s = xml.getElementContent("<row>","</row>");
}
}
catch (const DuplicateKey &e1) {
throw ConversionException(e1.getMessage(),"MainTable");
}
catch (...) {
// cout << "Unexpected error in MainTable::addWithoutCheckingUnique called from MainTable::fromXML " << endl;
}
}
if (!xml.isStr("</MainTable>"))
error();
//Does not change the convention defined in the model.
//archiveAsBin = false;
//fileAsBin = false;
// clean up the xmlDoc pointer
if ( doc != NULL ) xmlFreeDoc(doc);
}
void MainTable::error() {
throw ConversionException("Invalid xml document","Main");
}
string MainTable::MIMEXMLPart(const asdm::ByteOrder* byteOrder) {
string UID = getEntity().getEntityId().toString();
string withoutUID = UID.substr(6);
string containerUID = getContainer().getEntity().getEntityId().toString();
ostringstream oss;
oss << "<?xml version='1.0' encoding='ISO-8859-1'?>";
oss << "\n";
oss << "<MainTable xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:main=\"http://Alma/XASDM/MainTable\" xsi:schemaLocation=\"http://Alma/XASDM/MainTable http://almaobservatory.org/XML/XASDM/4/MainTable.xsd\" schemaVersion=\"4\" schemaRevision=\"-1\">\n";
oss<< "<Entity entityId='"<<UID<<"' entityIdEncrypted='na' entityTypeName='MainTable' schemaVersion='1' documentVersion='1'/>\n";
oss<< "<ContainerEntity entityId='"<<containerUID<<"' entityIdEncrypted='na' entityTypeName='ASDM' schemaVersion='1' documentVersion='1'/>\n";
oss << "<BulkStoreRef file_id='"<<withoutUID<<"' byteOrder='"<<byteOrder->toString()<<"' />\n";
oss << "<Attributes>\n";
oss << "<time/>\n";
oss << "<configDescriptionId/>\n";
oss << "<fieldId/>\n";
oss << "<numAntenna/>\n";
oss << "<timeSampling/>\n";
oss << "<interval/>\n";
oss << "<numIntegration/>\n";
oss << "<scanNumber/>\n";
oss << "<subscanNumber/>\n";
oss << "<dataSize/>\n";
oss << "<dataUID/>\n";
oss << "<stateId/>\n";
oss << "<execBlockId/>\n";
oss << "</Attributes>\n";
oss << "</MainTable>\n";
return oss.str();
}
string MainTable::toMIME(const asdm::ByteOrder* byteOrder) {
EndianOSStream eoss(byteOrder);
string UID = getEntity().getEntityId().toString();
// The MIME Header
eoss <<"MIME-Version: 1.0";
eoss << "\n";
eoss << "Content-Type: Multipart/Related; boundary='MIME_boundary'; type='text/xml'; start= '<header.xml>'";
eoss <<"\n";
eoss <<"Content-Description: Correlator";
eoss <<"\n";
eoss <<"alma-uid:" << UID;
eoss <<"\n";
eoss <<"\n";
// The MIME XML part header.
eoss <<"--MIME_boundary";
eoss <<"\n";
eoss <<"Content-Type: text/xml; charset='ISO-8859-1'";
eoss <<"\n";
eoss <<"Content-Transfer-Encoding: 8bit";
eoss <<"\n";
eoss <<"Content-ID: <header.xml>";
eoss <<"\n";
eoss <<"\n";
// The MIME XML part content.
eoss << MIMEXMLPart(byteOrder);
// The MIME binary part header
eoss <<"--MIME_boundary";
eoss <<"\n";
eoss <<"Content-Type: binary/octet-stream";
eoss <<"\n";
eoss <<"Content-ID: <content.bin>";
eoss <<"\n";
eoss <<"\n";
// The MIME binary content
entity.toBin(eoss);
container.getEntity().toBin(eoss);
eoss.writeInt((int) privateRows.size());
for (unsigned int i = 0; i < privateRows.size(); i++) {
privateRows.at(i)->toBin(eoss);
}
// The closing MIME boundary
eoss << "\n--MIME_boundary--";
eoss << "\n";
return eoss.str();
}
void MainTable::setFromMIME(const string & mimeMsg) {
string xmlPartMIMEHeader = "Content-ID: <header.xml>\n\n";
string binPartMIMEHeader = "--MIME_boundary\nContent-Type: binary/octet-stream\nContent-ID: <content.bin>\n\n";
// Detect the XML header.
string::size_type loc0 = mimeMsg.find(xmlPartMIMEHeader, 0);
if ( loc0 == string::npos) {
// let's try with CRLFs
xmlPartMIMEHeader = "Content-ID: <header.xml>\r\n\r\n";
loc0 = mimeMsg.find(xmlPartMIMEHeader, 0);
if ( loc0 == string::npos )
throw ConversionException("Failed to detect the beginning of the XML header", "Main");
}
loc0 += xmlPartMIMEHeader.size();
// Look for the string announcing the binary part.
string::size_type loc1 = mimeMsg.find( binPartMIMEHeader, loc0 );
if ( loc1 == string::npos ) {
throw ConversionException("Failed to detect the beginning of the binary part", "Main");
}
//
// Extract the xmlHeader and analyze it to find out what is the byte order and the sequence
// of attribute names.
//
string xmlHeader = mimeMsg.substr(loc0, loc1-loc0);
xmlDoc *doc;
doc = xmlReadMemory(xmlHeader.data(), xmlHeader.size(), "BinaryTableHeader.xml", NULL, XML_PARSE_NOBLANKS);
if ( doc == NULL )
throw ConversionException("Failed to parse the xmlHeader into a DOM structure.", "Main");
// This vector will be filled by the names of all the attributes of the table
// in the order in which they are expected to be found in the binary representation.
//
vector<string> attributesSeq;
xmlNode* root_element = xmlDocGetRootElement(doc);
if ( root_element == NULL || root_element->type != XML_ELEMENT_NODE )
throw ConversionException("Failed to parse the xmlHeader into a DOM structure.", "Main");
const ByteOrder* byteOrder=0;
if ( string("ASDMBinaryTable").compare((const char*) root_element->name) == 0) {
// Then it's an "old fashioned" MIME file for tables.
// Just try to deserialize it with Big_Endian for the bytes ordering.
byteOrder = asdm::ByteOrder::Big_Endian;
//
// Let's consider a default order for the sequence of attributes.
//
attributesSeq.push_back("time") ;
attributesSeq.push_back("configDescriptionId") ;
attributesSeq.push_back("fieldId") ;
attributesSeq.push_back("numAntenna") ;
attributesSeq.push_back("timeSampling") ;
attributesSeq.push_back("interval") ;
attributesSeq.push_back("numIntegration") ;
attributesSeq.push_back("scanNumber") ;
attributesSeq.push_back("subscanNumber") ;
attributesSeq.push_back("dataSize") ;
attributesSeq.push_back("dataUID") ;
attributesSeq.push_back("stateId") ;
attributesSeq.push_back("execBlockId") ;
// And decide that it has version == "2"
version = "2";
}
else if (string("MainTable").compare((const char*) root_element->name) == 0) {
// It's a new (and correct) MIME file for tables.
//
// 1st ) Look for a BulkStoreRef element with an attribute byteOrder.
//
xmlNode* bulkStoreRef = 0;
xmlNode* child = root_element->children;
if (xmlHasProp(root_element, (const xmlChar*) "schemaVersion")) {
xmlChar * value = xmlGetProp(root_element, (const xmlChar *) "schemaVersion");
version = string ((const char *) value);
xmlFree(value);
}
// Skip the two first children (Entity and ContainerEntity).
bulkStoreRef = (child == 0) ? 0 : ( (child->next) == 0 ? 0 : child->next->next );
if ( bulkStoreRef == 0 || (bulkStoreRef->type != XML_ELEMENT_NODE) || (string("BulkStoreRef").compare((const char*) bulkStoreRef->name) != 0))
throw ConversionException ("Could not find the element '/MainTable/BulkStoreRef'. Invalid XML header '"+ xmlHeader + "'.", "Main");
// We found BulkStoreRef, now look for its attribute byteOrder.
_xmlAttr* byteOrderAttr = 0;
for (struct _xmlAttr* attr = bulkStoreRef->properties; attr; attr = attr->next)
if (string("byteOrder").compare((const char*) attr->name) == 0) {
byteOrderAttr = attr;
break;
}
if (byteOrderAttr == 0)
throw ConversionException("Could not find the element '/MainTable/BulkStoreRef/@byteOrder'. Invalid XML header '" + xmlHeader +"'.", "Main");
string byteOrderValue = string((const char*) byteOrderAttr->children->content);
if (!(byteOrder = asdm::ByteOrder::fromString(byteOrderValue)))
throw ConversionException("No valid value retrieved for the element '/MainTable/BulkStoreRef/@byteOrder'. Invalid XML header '" + xmlHeader + "'.", "Main");
//
// 2nd) Look for the Attributes element and grab the names of the elements it contains.
//
xmlNode* attributes = bulkStoreRef->next;
if ( attributes == 0 || (attributes->type != XML_ELEMENT_NODE) || (string("Attributes").compare((const char*) attributes->name) != 0))
throw ConversionException ("Could not find the element '/MainTable/Attributes'. Invalid XML header '"+ xmlHeader + "'.", "Main");
xmlNode* childOfAttributes = attributes->children;
while ( childOfAttributes != 0 && (childOfAttributes->type == XML_ELEMENT_NODE) ) {
attributesSeq.push_back(string((const char*) childOfAttributes->name));
childOfAttributes = childOfAttributes->next;
}
}
// Create an EndianISStream from the substring containing the binary part.
EndianISStream eiss(mimeMsg.substr(loc1+binPartMIMEHeader.size()), byteOrder);
entity = Entity::fromBin((EndianIStream&) eiss);
// We do nothing with that but we have to read it.
Entity containerEntity = Entity::fromBin((EndianIStream&) eiss);
// Let's read numRows but ignore it and rely on the value specified in the ASDM.xml file.
int numRows = ((EndianIStream&) eiss).readInt();
if ((numRows != -1) // Then these are *not* data produced at the EVLA.
&& ((unsigned int) numRows != this->declaredSize )) { // Then the declared size (in ASDM.xml) is not equal to the one
// written into the binary representation of the table.
cout << "The a number of rows ('"
<< numRows
<< "') declared in the binary representation of the table is different from the one declared in ASDM.xml ('"
<< this->declaredSize
<< "'). I'll proceed with the value declared in ASDM.xml"
<< endl;
}
if (getContainer().checkRowUniqueness()) {
try {
for (uint32_t i = 0; i < this->declaredSize; i++) {
MainRow* aRow = MainRow::fromBin((EndianIStream&) eiss, *this, attributesSeq);
checkAndAdd(aRow);
}
}
catch (const DuplicateKey &e) {
throw ConversionException("Error while writing binary data , the message was "
+ e.getMessage(), "Main");
}
catch (const TagFormatException &e) {
throw ConversionException("Error while reading binary data , the message was "
+ e.getMessage(), "Main");
}
}
else {
for (uint32_t i = 0; i < this->declaredSize; i++) {
MainRow* aRow = MainRow::fromBin((EndianIStream&) eiss, *this, attributesSeq);
append(aRow);
}
}
//Does not change the convention defined in the model.
//archiveAsBin = true;
//fileAsBin = true;
if ( doc != NULL ) xmlFreeDoc(doc);
}
void MainTable::setUnknownAttributeBinaryReader(const string& attributeName, BinaryAttributeReaderFunctor* barFctr) {
//
// Is this attribute really unknown ?
//
for (vector<string>::const_iterator iter = attributesNamesOfMain_v.begin(); iter != attributesNamesOfMain_v.end(); iter++) {
if ((*iter).compare(attributeName) == 0)
throw ConversionException("the attribute '"+attributeName+"' is known you can't override the way it's read in the MIME binary file containing the table.", "Main");
}
// Ok then register the functor to activate when an unknown attribute is met during the reading of a binary table?
unknownAttributes2Functors[attributeName] = barFctr;
}
BinaryAttributeReaderFunctor* MainTable::getUnknownAttributeBinaryReader(const string& attributeName) const {
map<string, BinaryAttributeReaderFunctor*>::const_iterator iter = unknownAttributes2Functors.find(attributeName);
return (iter == unknownAttributes2Functors.end()) ? 0 : iter->second;
}
void MainTable::toFile(string directory) {
if (!directoryExists(directory.c_str()) &&
!createPath(directory.c_str())) {
throw ConversionException("Could not create directory " , directory);
}
string fileName = directory + "/Main.xml";
ofstream tableout(fileName.c_str(),ios::out|ios::trunc);
if (tableout.rdstate() == ostream::failbit)
throw ConversionException("Could not open file " + fileName + " to write ", "Main");
if (fileAsBin)
tableout << MIMEXMLPart();
else
tableout << toXML() << endl;
tableout.close();
if (tableout.rdstate() == ostream::failbit)
throw ConversionException("Could not close file " + fileName, "Main");
if (fileAsBin) {
// write the bin serialized
string fileName = directory + "/Main.bin";
ofstream tableout(fileName.c_str(),ios::out|ios::trunc);
if (tableout.rdstate() == ostream::failbit)
throw ConversionException("Could not open file " + fileName + " to write ", "Main");
tableout << toMIME() << endl;
tableout.close();
if (tableout.rdstate() == ostream::failbit)
throw ConversionException("Could not close file " + fileName, "Main");
}
}
void MainTable::setFromFile(const string& directory) {
#ifndef WITHOUT_BOOST
if (boost::filesystem::exists(boost::filesystem::path(uniqSlashes(directory + "/Main.xml"))))
setFromXMLFile(directory);
else if (boost::filesystem::exists(boost::filesystem::path(uniqSlashes(directory + "/Main.bin"))))
setFromMIMEFile(directory);
#else
// alternative in Misc.h
if (file_exists(uniqSlashes(directory + "/Main.xml")))
setFromXMLFile(directory);
else if (file_exists(uniqSlashes(directory + "/Main.bin")))
setFromMIMEFile(directory);
#endif
else
throw ConversionException("No file found for the Main table", "Main");
}
void MainTable::setFromMIMEFile(const string& directory) {
string tablePath ;
tablePath = directory + "/Main.bin";
ifstream tablefile(tablePath.c_str(), ios::in|ios::binary);
if (!tablefile.is_open()) {
throw ConversionException("Could not open file " + tablePath, "Main");
}
// Read in a stringstream.
stringstream ss; ss << tablefile.rdbuf();
if (tablefile.rdstate() == istream::failbit || tablefile.rdstate() == istream::badbit) {
throw ConversionException("Error reading file " + tablePath,"Main");
}
// And close.
tablefile.close();
if (tablefile.rdstate() == istream::failbit)
throw ConversionException("Could not close file " + tablePath,"Main");
setFromMIME(ss.str());
}
/*
void MainTable::openMIMEFile (const string& directory) {
// Open the file.
string tablePath ;
tablePath = directory + "/Main.bin";
ifstream tablefile(tablePath.c_str(), ios::in|ios::binary);
if (!tablefile.is_open())
throw ConversionException("Could not open file " + tablePath, "Main");
// Locate the xmlPartMIMEHeader.
string xmlPartMIMEHeader = "CONTENT-ID: <HEADER.XML>\n\n";
CharComparator comparator;
istreambuf_iterator<char> BEGIN(tablefile.rdbuf());
istreambuf_iterator<char> END;
istreambuf_iterator<char> it = search(BEGIN, END, xmlPartMIMEHeader.begin(), xmlPartMIMEHeader.end(), comparator);
if (it == END)
throw ConversionException("failed to detect the beginning of the XML header", "Main");
// Locate the binaryPartMIMEHeader while accumulating the characters of the xml header.
string binPartMIMEHeader = "--MIME_BOUNDARY\nCONTENT-TYPE: BINARY/OCTET-STREAM\nCONTENT-ID: <CONTENT.BIN>\n\n";
string xmlHeader;
CharCompAccumulator compaccumulator(&xmlHeader, 100000);
++it;
it = search(it, END, binPartMIMEHeader.begin(), binPartMIMEHeader.end(), compaccumulator);
if (it == END)
throw ConversionException("failed to detect the beginning of the binary part", "Main");
cout << xmlHeader << endl;
//
// We have the xmlHeader , let's parse it.
//
xmlDoc *doc;
doc = xmlReadMemory(xmlHeader.data(), xmlHeader.size(), "BinaryTableHeader.xml", NULL, XML_PARSE_NOBLANKS);
if ( doc == NULL )
throw ConversionException("Failed to parse the xmlHeader into a DOM structure.", "Main");
// This vector will be filled by the names of all the attributes of the table
// in the order in which they are expected to be found in the binary representation.
//
vector<string> attributesSeq(attributesNamesInBinOfMain_v);
xmlNode* root_element = xmlDocGetRootElement(doc);
if ( root_element == NULL || root_element->type != XML_ELEMENT_NODE )
throw ConversionException("Failed to parse the xmlHeader into a DOM structure.", "Main");
const ByteOrder* byteOrder=0;
if ( string("ASDMBinaryTable").compare((const char*) root_element->name) == 0) {
// Then it's an "old fashioned" MIME file for tables.
// Just try to deserialize it with Big_Endian for the bytes ordering.
byteOrder = asdm::ByteOrder::Big_Endian;
// And decide that it has version == "2"
version = "2";
}
else if (string("MainTable").compare((const char*) root_element->name) == 0) {
// It's a new (and correct) MIME file for tables.
//
// 1st ) Look for a BulkStoreRef element with an attribute byteOrder.
//
xmlNode* bulkStoreRef = 0;
xmlNode* child = root_element->children;
if (xmlHasProp(root_element, (const xmlChar*) "schemaVersion")) {
xmlChar * value = xmlGetProp(root_element, (const xmlChar *) "schemaVersion");
version = string ((const char *) value);
xmlFree(value);
}
// Skip the two first children (Entity and ContainerEntity).
bulkStoreRef = (child == 0) ? 0 : ( (child->next) == 0 ? 0 : child->next->next );
if ( bulkStoreRef == 0 || (bulkStoreRef->type != XML_ELEMENT_NODE) || (string("BulkStoreRef").compare((const char*) bulkStoreRef->name) != 0))
throw ConversionException ("Could not find the element '/MainTable/BulkStoreRef'. Invalid XML header '"+ xmlHeader + "'.", "Main");
// We found BulkStoreRef, now look for its attribute byteOrder.
_xmlAttr* byteOrderAttr = 0;
for (struct _xmlAttr* attr = bulkStoreRef->properties; attr; attr = attr->next)
if (string("byteOrder").compare((const char*) attr->name) == 0) {
byteOrderAttr = attr;
break;
}
if (byteOrderAttr == 0)
throw ConversionException("Could not find the element '/MainTable/BulkStoreRef/@byteOrder'. Invalid XML header '" + xmlHeader +"'.", "Main");
string byteOrderValue = string((const char*) byteOrderAttr->children->content);
if (!(byteOrder = asdm::ByteOrder::fromString(byteOrderValue)))
throw ConversionException("No valid value retrieved for the element '/MainTable/BulkStoreRef/@byteOrder'. Invalid XML header '" + xmlHeader + "'.", "Main");
//
// 2nd) Look for the Attributes element and grab the names of the elements it contains.
//
xmlNode* attributes = bulkStoreRef->next;
if ( attributes == 0 || (attributes->type != XML_ELEMENT_NODE) || (string("Attributes").compare((const char*) attributes->name) != 0))
throw ConversionException ("Could not find the element '/MainTable/Attributes'. Invalid XML header '"+ xmlHeader + "'.", "Main");
xmlNode* childOfAttributes = attributes->children;
while ( childOfAttributes != 0 && (childOfAttributes->type == XML_ELEMENT_NODE) ) {
attributesSeq.push_back(string((const char*) childOfAttributes->name));
childOfAttributes = childOfAttributes->next;
}
}
// Create an EndianISStream from the substring containing the binary part.
EndianIFStream eifs(&tablefile, byteOrder);
entity = Entity::fromBin((EndianIStream &) eifs);
// We do nothing with that but we have to read it.
Entity containerEntity = Entity::fromBin((EndianIStream &) eifs);
// Let's read numRows but ignore it and rely on the value specified in the ASDM.xml file.
int numRows = eifs.readInt();
if ((numRows != -1) // Then these are *not* data produced at the EVLA.
&& ((unsigned int) numRows != this->declaredSize )) { // Then the declared size (in ASDM.xml) is not equal to the one
// written into the binary representation of the table.
cout << "The a number of rows ('"
<< numRows
<< "') declared in the binary representation of the table is different from the one declared in ASDM.xml ('"
<< this->declaredSize
<< "'). I'll proceed with the value declared in ASDM.xml"
<< endl;
}
// clean up xmlDoc pointer
if ( doc != NULL ) xmlFreeDoc(doc);
}
*/
void MainTable::setFromXMLFile(const string& directory) {
string tablePath ;
tablePath = directory + "/Main.xml";
/*
ifstream tablefile(tablePath.c_str(), ios::in|ios::binary);
if (!tablefile.is_open()) {
throw ConversionException("Could not open file " + tablePath, "Main");
}
// Read in a stringstream.
stringstream ss;
ss << tablefile.rdbuf();
if (tablefile.rdstate() == istream::failbit || tablefile.rdstate() == istream::badbit) {
throw ConversionException("Error reading file '" + tablePath + "'", "Main");
}
// And close
tablefile.close();
if (tablefile.rdstate() == istream::failbit)
throw ConversionException("Could not close file '" + tablePath + "'", "Main");
// Let's make a string out of the stringstream content and empty the stringstream.
string xmlDocument = ss.str(); ss.str("");
// Let's make a very primitive check to decide
// whether the XML content represents the table
// or refers to it via a <BulkStoreRef element.
*/
string xmlDocument;
try {
xmlDocument = getContainer().getXSLTransformer()(tablePath);
if (getenv("ASDM_DEBUG")) cout << "About to read " << tablePath << endl;
}
catch (const XSLTransformerException &e) {
throw ConversionException("Caugth an exception whose message is '" + e.getMessage() + "'.", "Main");
}
if (xmlDocument.find("<BulkStoreRef") != string::npos)
setFromMIMEFile(directory);
else
fromXML(xmlDocument);
}
MainRow * MainTable::insertByTime(MainRow* x, vector<MainRow *>&row ) {
ArrayTime start = x->getTime();
// Is the vector empty ?
if (row.size() == 0) {
row.push_back(x);
privateRows.push_back(x);
x->isAdded(true);
return x;
}
// Optimization for the case of insertion by ascending time.
MainRow* last = row.at(row.size()-1);
if (start.get() > last->getTime().get()) {
row.push_back(x);
privateRows.push_back(x);
x->isAdded(true);
return x;
}
// Optimization for the case of insertion by descending time.
MainRow* first = row.at(0);
if (start.get() < first->getTime().get()) {
row.insert(row.begin(), x);
privateRows.push_back(x);
x->isAdded(true);
return x;
}
// Case where x has to be inserted inside row; let's use a dichotomy
// method to find the insertion index.
int k0 = 0;
int k1 = row.size() - 1;
while (k0 != (k1 - 1)) {
if (start.get() == row.at(k0)->getTime().get()) {
if (row.at(k0)->equalByRequiredValue(x))
return row.at(k0);
else
throw DuplicateKey("DuplicateKey exception in ", "MainTable");
}
else if (start.get() == row.at(k1)->getTime().get()) {
if (row.at(k1)->equalByRequiredValue(x))
return row.at(k1);
else
throw DuplicateKey("DuplicateKey exception in ", "MainTable");
}
else {
if (start.get() <= row.at((k0+k1)/2)->getTime().get())
k1 = (k0 + k1) / 2;
else
k0 = (k0 + k1) / 2;
}
}
if (start.get() == row.at(k0)->getTime().get()) {
if (row.at(k0)->equalByRequiredValue(x))
return row.at(k0);
else
throw DuplicateKey("DuplicateKey exception in ", "MainTable");
}
else if (start.get() == row.at(k1)->getTime().get()) {
if (row.at(k1)->equalByRequiredValue(x))
return row.at(k1);
else
throw DuplicateKey("DuplicateKey exception in ", "MainTable");
}
row.insert(row.begin()+(k0+1), x);
privateRows.push_back(x);
x->isAdded(true);
return x;
}
} // End namespace asdm