void parseStructure(TDirectory* td1, TDirectory* td2) {
string dir_name = td1->GetTitle();
string dir_path = td1->GetPath();
// cout << "ParseStructure: dir_name=" << dir_name << ", dir_path=" << dir_path << endl;
dir_path = dir_path.substr(dir_path.find("DQMData")+8);
setPath(dir_path, td2);
TIter next(td1->GetListOfKeys());
TKey *key;
while ( (key = dynamic_cast<TKey*>(next())) )
{
string clName(key->GetClassName());
if (clName == "TDirectoryFile") {
string name(key->GetName());
if (name.find("forward_") == string::npos &&
name.find("backward_") == string::npos &&
name.find("ring_") == string::npos) {
td1->cd(name.c_str());
TDirectory *curr_dir = gDirectory; // dynamic_cast<TDirectory*>(obj);
parseStructure(curr_dir, td2);
} else return;
} else if (clName == "TObjString") {
// cout << clName << " " << key->GetName() << endl;
key->Write();
} else {
key->ReadObj();
}
}
}
void sistrip_reduce_file(string fname1, string fname2)
{
TFile* file1 = new TFile(fname1.c_str());
if (!file1 || !file1->IsOpen()) return;
TDirectory* topDir1 = dynamic_cast<TDirectory*>( file1->Get("DQMData"));
goToDir(topDir1, "SiStrip");
TDirectory* stripDir = gDirectory;
TFile* file2 = new TFile(fname2.c_str(), "RECREATE");
if (!file2 || !file2->IsOpen()) return;
TDirectory* topDir2 = file2->mkdir("DQMData");
if (!topDir2) {
cout << " Can not create directory structure in " << fname2 << endl;
return;
}
parseStructure(stripDir, topDir2);
file1->Close();
file2->Write();
file2->Close();
}
static int parseStructure(KSI_TLV *tlv, int indent) {
int res;
KSI_TLV *nested = NULL;
KSI_LIST(KSI_TLV) *list = NULL;
size_t i;
KSI_Utf8String *utf = NULL;
KSI_Integer *integer = NULL;
KSI_OctetString *octet = NULL;
switch (KSI_TLV_getTag(tlv)) {
case 0x01:
/* Cast as numeric TLV */
/* Parse number */
res = KSI_Integer_fromTlv(tlv, &integer);
if (res != KSI_OK) goto cleanup;
break;
case 0x02:
/* Cast as string TLV */
res = KSI_Utf8String_fromTlv(tlv, &utf);
if (res != KSI_OK) goto cleanup;
break;
case 0x03:
case 0x1003:
res = KSI_TLV_getNestedList(tlv, &list);
if (res != KSI_OK) goto cleanup;
/* Parse nested */
for (i = 0; i < KSI_TLVList_length(list); i++) {
res = KSI_TLVList_elementAt(list, i, &nested);
if (res != KSI_OK) goto cleanup;
if (nested == NULL) break;
res = parseStructure(nested, indent);
if (res != KSI_OK) goto cleanup;
}
break;
case 0x04:
/* Cast as octet string*/
res = KSI_OctetString_fromTlv(tlv, &octet);
if (res != KSI_OK) goto cleanup;
break;
default:
res = KSI_INVALID_FORMAT;
goto cleanup;
}
cleanup:
KSI_OctetString_free(octet);
KSI_Utf8String_free(utf);
KSI_Integer_free(integer);
return res;
}
static void TestClone(CuTest *tc) {
int res;
KSI_TLV *tlv = NULL;
KSI_TLV *clone = NULL;
unsigned char in[0xffff + 4];
unsigned char out1[0xffff + 4];
char errstr[1024];
size_t out_len;
size_t in_len;
FILE *f = NULL;
int i = 0;
KSI_ERR_clearErrors(ctx);
while (ok_sample[i] != NULL) {
f = fopen(getFullResourcePath(ok_sample[i]), "rb");
CuAssert(tc, "Unable to open test file.", f != NULL);
in_len = (unsigned) fread(in, 1, sizeof(in), f);
fclose(f);
f = NULL;
res = KSI_TLV_parseBlob2(ctx, in, in_len, 0, &tlv);
CuAssert(tc, "Unable to parse TLV.", res == KSI_OK);
res = parseStructure(tlv, 0);
CuAssert(tc, "Unable to parse TLV structure.", res == KSI_OK);
res = KSI_TLV_clone(tlv, &clone);
CuAssert(tc, "Unsable to clone TLV.", res == KSI_OK && clone != NULL);
/* Re assemble TLV */
res = KSI_TLV_serialize_ex(clone, out1, sizeof(out1), &out_len);
CuAssert(tc, "Unable to serialize TLV.", res == KSI_OK);
CuAssert(tc, "Serialized TLV size mismatch.", in_len == out_len);
sprintf(errstr, "Serialised TLV content does not match original: '%s'.", ok_sample[i]);
CuAssert(tc, errstr, !memcmp(in, out1, in_len));
KSI_TLV_free(clone);
clone = NULL;
KSI_TLV_free(tlv);
tlv = NULL;
i++;
}
}
static void TestNokFiles(CuTest* tc) {
int res;
int i = 0;
KSI_TLV *tlv = NULL;
KSI_ERR_clearErrors(ctx);
while (nok_sample[i] != NULL) {
res = KSITest_tlvFromFile(getFullResourcePath(nok_sample[i++]), &tlv);
if (res == KSI_OK) {
res = parseStructure(tlv, 0);
}
CuAssert(tc, "Parser did not fail with invalid TLV.", res != KSI_OK);
KSI_TLV_free(tlv);
tlv = NULL;
}
}
static void TestOkFiles(CuTest* tc) {
int res;
int i = 0;
KSI_TLV *tlv = NULL;
KSI_ERR_clearErrors(ctx);
while (ok_sample[i] != NULL) {
CuAssert(tc, "Unable to read valid TLV.", KSITest_tlvFromFile(getFullResourcePath(ok_sample[i++]), &tlv) == KSI_OK);
res = parseStructure(tlv, 0);
CuAssert(tc, "Unable to parse valid TLV.", res == KSI_OK);
KSI_TLV_free(tlv);
tlv = NULL;
break;
}
}
char *OpenDDLParser::parseNextNode( char *in, char *end ) {
in = parseHeader( in, end );
in = parseStructure( in, end );
return in;
}
bool readValue(VLXValue& val)
{
unsigned char chunk = 0;
if (!readChunk(chunk))
return false;
std::string str;
switch(chunk)
{
case VLB_ChunkStructure:
val.setStructure( new VLXStructure );
return parseStructure( val.getStructure() );
case VLB_ChunkList:
val.setList( new VLXList );
return parseList( val.getList() );
case VLB_ChunkArrayInteger:
{
// tag
if (!readString(str))
return false;
else
val.setArrayInteger( new VLXArrayInteger( str.c_str() ) );
// count
long long count = 0;
if (!readInteger(count))
return false;
// values
VLXArrayInteger& arr = *val.getArrayInteger();
if (count)
{
long long encode_count = 0;
if (!readInteger(encode_count))
return false;
VL_CHECK(encode_count >= 0)
if (encode_count)
{
std::vector<unsigned char> encoded;
encoded.resize((size_t)encode_count);
inputFile()->readUInt8(&encoded[0], encode_count);
decodeIntegers(encoded, arr.value());
}
}
VL_CHECK((size_t)count == arr.value().size())
return (size_t)count == arr.value().size();
}
case VLB_ChunkArrayRealDouble:
{
// tag
if (!readString(str))
return false;
else
val.setArrayReal( new VLXArrayReal( str.c_str() ) );
// count
long long count = 0;
if (!readInteger(count))
return false;
// values
VLXArrayReal& arr = *val.getArrayReal();
arr.value().resize( (size_t)count );
if (count)
{
#if 1
long long c = inputFile()->readDouble( &arr.value()[0], count );
VL_CHECK(c == count * (int)sizeof(double))
return c == count * (int)sizeof(double);
#elif 0
long long zsize = 0;
readInteger(zsize);
std::vector<unsigned char> zipped;
zipped.resize((size_t)zsize);
inputFile()->read(&zipped[0], zipped.size());
bool ok = decompress(&zipped[0], (size_t)zsize, &arr.value()[0]);
VL_CHECK(ok);
return ok;
#endif
}
else
return true;
}
case VLB_ChunkArrayRealFloat:
{
// tag
if (!readString(str))
return false;
else
val.setArrayReal( new VLXArrayReal( str.c_str() ) );
// count
long long count = 0;
if (!readInteger(count))
return false;
// values
VLXArrayReal& arr = *val.getArrayReal();
arr.value().resize( (size_t)count );
if (count)
{
#if 1
std::vector<float> floats;
floats.resize( (size_t)count );
long long c = inputFile()->readFloat( &floats[0], count );
// copy over floats to doubles
for(size_t i=0; i<floats.size(); ++i)
arr.value()[i] = floats[i];
VL_CHECK(c == count * (int)sizeof(float))
return c == count * (int)sizeof(float);
#elif 0
long long zsize = 0;
readInteger(zsize);
std::vector<unsigned char> zipped;
zipped.resize((size_t)zsize);
inputFile()->read(&zipped[0], zipped.size());
bool ok = decompress(&zipped[0], (size_t)zsize, &arr.value()[0]);
VL_CHECK(ok);
return ok;
#endif
}
else
return true;
}
bool parse()
{
class CloseFileClass
{
public:
CloseFileClass(VirtualFile* f): mFile(f) {}
~CloseFileClass()
{
if (mFile)
mFile->close();
}
private:
ref<VirtualFile> mFile;
} CloseFile(inputFile());
inputFile()->close();
inputFile()->open(OM_ReadOnly);
// clear metadata
mMetadata.clear();
// read version and encoding
mVersion = 0;
mEncoding.clear();
if (!parseHeader())
{
Log::error("VLXParserVLB : error parsing VLB header.\n");
return false;
}
if (mVersion != 100)
{
Log::error("VLX version not supported.\n");
return false;
}
if (mEncoding != "ascii")
{
Log::error("Encoding not supported.\n");
return false;
}
unsigned char chunk;
std::string str;
while(readChunk(chunk))
{
if(chunk == VLB_ChunkStructure)
{
ref<VLXStructure> st = new VLXStructure;
if (!parseStructure(st.get()))
{
Log::error( Say("Error parsing binary file at offset %n.\n") << inputFile()->position() );
return false;
}
mStructures.push_back(st);
}
else
{
Log::error( Say("Error parsing binary file at offset %n. Expected chunk structure.\n") << inputFile()->position() );
return false;
}
}
parseMetadata();
return true;
}
