C++ DataSetHeader::SetName方法代码示例

void CHPData::AddExprColumns(DataSetHeader& hdr, bool hasCompData)
{
	hdr.SetName(CHP_EXPR_GROUP);
	//Probeset name - string
	hdr.AddAsciiColumn(ProbeSetNameColName, maxProbeSetName);
	//Detection - unsigned char
	hdr.AddUByteColumn(DetectionColName);
	//Detection p-value - float
	hdr.AddFloatColumn(DetectionPValueColName);
	//Signal - float
	hdr.AddFloatColumn(SignalColName);
	//Number of pairs - unsigned short
	hdr.AddUShortColumn(NumberPairsColName);
	//Number of pairs used - unsigned short
	hdr.AddUShortColumn(NumberPairsUsedColName);

	if (hasCompData == true)
	{
		//Change - unsigned char
		hdr.AddUByteColumn(ChangeColName);
		//Change p-value - float
		hdr.AddFloatColumn(ChangePValueColName);
		//Signal Log Ratio - float
		hdr.AddFloatColumn(SignalLogRatioColName);
		//Signal Log Ratio Low - float
		hdr.AddFloatColumn(SignalLogRatioLowColName);
		//Signal Log Ratio High - float
		hdr.AddFloatColumn(SignalLogRatioHighColName);
		//Common Pairs - unsigned short
		hdr.AddUShortColumn(CommonPairsColName);
	}
}

void CHPData::AddReseqColumns(DataSetHeader& hdr)
{
	hdr.SetName(CHP_RESEQ_GROUP);
	//call - char
	hdr.AddByteColumn(CallColName);
	//Score - float
	hdr.AddFloatColumn(ScoreColName);
}

void TestFileGenerator::WriteOutGenericDATDataFileNoGrid()
{
	GenericDataHeader gdh;
	AddStandardGenericDataHeader(gdh);

	// Fill the DataGroupHeader
	DataGroupHeader dch;
	dch.SetName(L"First Data Cube");

	// Fill the DataSetHeader
	DataSetHeader dph;
	dph.SetName(L"acquired data");
	ParameterNameValueType nvt;
	nvt.SetName(L"Scanner");
	nvt.SetValueText(L"M10");
	dph.AddNameValParam(nvt);
	nvt.SetName(L"Pixel Size");
	nvt.SetValueFloat(0.051f);
	dph.AddNameValParam(nvt);

	dph.AddColumn(UShortColumn(L"Pixel"));

	int32_t rows = 100;
	dph.SetRowCnt(rows);

	dch.AddDataSetHdr(dph);

	// Set the FileHeader
	FileHeader fh;
	fh.SetFilename("test.file.data_dat");
	fh.SetGenericDataHdr(gdh);
	fh.AddDataGroupHdr(dch);

	// Create the generic file writer
	GenericFileWriter gfWriter(&fh);
	gfWriter.WriteHeader();

	DataGroupWriterIt dcwBegin, dcwEnd;
	gfWriter.GetDataGroupWriters(dcwBegin, dcwEnd);

	DataGroupWriter d = *dcwBegin;
	dcwBegin->WriteHeader();

	DataSetWriterIt dpwBegin, dpwEnd;
	dcwBegin->GetDataSetWriters(dpwBegin, dpwEnd);

	dpwBegin->WriteHeader();

	// Write out the data
	for( int32_t i=0; i < rows; ++i )
	{
		u_int16_t value = (u_int16_t)(i*10+i);
		dpwBegin->Write(value);
	}

	dpwBegin->UpdateNextDataSetOffset();
	dcwBegin->Close();
}

void CDFData::CreateContentsGroup(const std::wstring& p, int32_t probesetCnt)
{
	DataGroupHeader c(p);
	DataSetHeader dp;
	dp.SetRowCnt(probesetCnt);
	dp.SetName(p);
	dp.AddUnicodeColumn(L"", MAX_CDF_PROBE_SET_NAME_LENGTH);
	dp.AddIntColumn(L"");
	c.AddDataSetHdr(dp);
	genericData.Header().AddDataGroupHdr(c);
}

void CHPQuantificationData::SetEntryCount(int32_t ln, int32_t maxln)
{
    firstColumnType = ASCIICharColType;
	maxProbeSetName = maxln;
	ParameterNameValueType param;
	DataGroupHeader* dcHdr = &genericData.Header().GetDataGroup(0);
	DataSetHeader dpHdr;
	dpHdr.SetRowCnt(ln);
	dpHdr.SetName(QUANTIFICATION_QUANTIFICATION_NAME);
	AddColumns(dpHdr, false);
	dcHdr->AddDataSetHdr(dpHdr);
}

void CHPData::SetOrigCnt(int32_t ln)
{
	DataSetHeader dpHdr;
	dpHdr.SetRowCnt(ln);
	dpHdr.SetName(CHP_RESEQ_ORIG_CALL_GROUP);

	//position - int
	dpHdr.AddIntColumn(PositionColName);
	//call - byte
	dpHdr.AddByteColumn(OriginalCallColName);

	DataGroupHeader* dcHdr = &genericData.Header().GetDataGroup(3);
	dcHdr->AddDataSetHdr(dpHdr);
}

void CHPData::SetForceCnt(int32_t ln)
{
	DataSetHeader dpHdr;
	dpHdr.SetRowCnt(ln);
	dpHdr.SetName(CHP_RESEQ_FORCE_CALL_GROUP);

	//position - int
	dpHdr.AddIntColumn(PositionColName);
	//call - byte
	dpHdr.AddByteColumn(ForceCallColName);
	//reason - byte
	dpHdr.AddByteColumn(ReasonColName);

	DataGroupHeader* dcHdr = &genericData.Header().GetDataGroup(2);
	dcHdr->AddDataSetHdr(dpHdr);
}

void CHPData::SetBackgroundZoneCnt(int32_t ln)
{
	DataSetHeader dpHdr;
	dpHdr.SetRowCnt(ln);
	dpHdr.SetName(CHP_BG_ZONE_GROUP);

	//center X coord - float
	dpHdr.AddFloatColumn(CenterXColName);
	//center Y coord - float
	dpHdr.AddFloatColumn(CenterYColName);
	//background - float
	dpHdr.AddFloatColumn(BackgroundColName);
	//smoothing factor - float
	dpHdr.AddFloatColumn(SmoothFactorColName);

	DataGroupHeader* dcHdr = &genericData.Header().GetDataGroup(1);
	dcHdr->AddDataSetHdr(dpHdr);
}

void CHPData::AddGenoColumns(DataSetHeader& hdr)
{
	hdr.SetName(CHP_GENO_GROUP);
	//Probeset name - string
	hdr.AddAsciiColumn(ProbeSetNameColName, maxProbeSetName);
	//Call - unsigned char
	hdr.AddUByteColumn(CallColName);
	//Confidence - float
	hdr.AddFloatColumn(ConfidenceColName);
	//RAS1 - float
	hdr.AddFloatColumn(RAS1ColName);
	//RAS2 - float
	hdr.AddFloatColumn(RAS2ColName);
	//AA Call - float
	hdr.AddFloatColumn(AAColName);
	//AB Call - float
	hdr.AddFloatColumn(ABColName);
	//BB Call - float
	hdr.AddFloatColumn(BBColName);
	//No Call - float
	hdr.AddFloatColumn(NoCallColName);
}

void CHPMultiDataData::SetEntryCount(MultiDataType dataType, int32_t ln, int32_t maxln, const std::vector<ColumnInfo> &columns, const std::wstring &groupName)
{
	DataSetInfo info;
	info.maxName = maxln;
	info.metricColumns = columns;
	info.entries = NULL;
	info.dataType = dataType;
	info.dataSetIndex = (int)dataSetInfo.size();
	dataSetInfo[dataType] = info;

	DataSetHeader dsHdr;
	dsHdr.SetRowCnt(ln);
	dsHdr.SetName(MultiDataDataSetNames[(int)dataType]);
	AddColumns(info, dsHdr);

    if (groupName.empty() == true)
        dataTypeGroupNames[dataType] = MULTI_DATA_NAME;
    else
        dataTypeGroupNames[dataType] = groupName;
	DataGroupHeader* dgHdr = GetDataGroupHeader(dataTypeGroupNames[dataType]);
	dgHdr->AddDataSetHdr(dsHdr);
}

void CHPData::AddUnivColumns(DataSetHeader& hdr)
{
	hdr.SetName(CHP_UNIV_GROUP);
	//Background - float
	hdr.AddFloatColumn(BackgroundColName);
}

void TestFileGenerator::WriteOutGenericDataFileWithAllColumnTypes()
{
	GenericDataHeader gdh;
	AddStandardGenericDataHeader(gdh);

	// Fill the DataGroupHeader
	DataGroupHeader dch;
	dch.SetName(L"default");	// default DataGroup

	// Fill the all types DataSetHeader
	DataSetHeader dphAT;
	dphAT.SetName(L"all types");
	ParameterNameValueType nvt;
	nvt.SetName(L"How many types");
	nvt.SetValueText(L"All types");
	dphAT.AddNameValParam(nvt);
	nvt.SetName(L"Powered by");
	nvt.SetValueText(L"Affymetrix");
	dphAT.AddNameValParam(nvt);

	dphAT.AddColumn(ByteColumn(L"Byte type"));
	dphAT.AddColumn(UByteColumn(L"UByte type"));
	dphAT.AddColumn(ASCIIColumn(L"ASCII type", 10));
	dphAT.AddColumn(ShortColumn(L"Short type"));
	dphAT.AddColumn(UShortColumn(L"UShort type"));
	dphAT.AddColumn(IntColumn(L"Int type"));
	dphAT.AddColumn(UIntColumn(L"UInt type"));
	dphAT.AddColumn(UnicodeColumn(L"Unicode type", 15));
	dphAT.AddColumn(FloatColumn(L"Float type"));

	int32_t rows = 2;
	dphAT.SetRowCnt(rows);

	dch.AddDataSetHdr(dphAT);

	// Set the FileHeader
	FileHeader fh;
	fh.SetFilename("test.file.data_all_column_types");
	fh.SetGenericDataHdr(gdh);
	fh.AddDataGroupHdr(dch);

	// Create the generic file writer
	GenericFileWriter gfWriter(&fh);
	gfWriter.WriteHeader();

	DataGroupWriterIt dcwBegin, dcwEnd;
	gfWriter.GetDataGroupWriters(dcwBegin, dcwEnd);

	DataGroupWriter d = *dcwBegin;
	dcwBegin->WriteHeader();

	DataSetWriterIt dpwBegin, dpwEnd;
	dcwBegin->GetDataSetWriters(dpwBegin, dpwEnd);

	// Write out the all types DataSet

	dpwBegin->WriteHeader();

	for( int32_t row = 0; row < rows; ++row )
	{
		char str[10];
		wchar_t wstr[15];
		int8_t b = 1+10*row;
		u_int8_t ub = 2+10*row;
		sprintf(str, "%d", 3+10*row);
		int16_t s = 4+10*row;
		u_int16_t us = 5+10*row;
		int32_t i = 6+10*row;
		u_int32_t ui = 7+10*row;
		FormatString1(wstr, 15, L"%d", 8+10*row);
		float f = 9+10*row;

		dpwBegin->Write(b);	// btye
		dpwBegin->Write(ub);	// unsigned byte
		dpwBegin->Write(str, 10);	// ACSII string
		dpwBegin->Write(s);	// short
		dpwBegin->Write(us);	// unsigned short
		dpwBegin->Write(i);	// int
		dpwBegin->Write(ui);	// unsigned int
		dpwBegin->Write(wstr, 15);	// Unicode string
		dpwBegin->Write(f);	// float
	}

	dpwBegin->UpdateNextDataSetOffset();
	dcwBegin->Close();
}

void TestFileGenerator::WriteOutGenericDATDataFileWithGrid()
{
	GenericDataHeader gdh;
	AddStandardGenericDataHeader(gdh);

	// Fill the DataGroupHeader
	DataGroupHeader dch;
	dch.SetName(L"");	// unnamed DataGroup

	// Fill the pixel intensity DataSetHeader
	DataSetHeader dphPixel;
	dphPixel.SetName(L"acquired data");
	ParameterNameValueType nvt;
	nvt.SetName(L"Scanner");
	nvt.SetValueText(L"M10");
	dphPixel.AddNameValParam(nvt);
	nvt.SetName(L"Pixel Size");
	nvt.SetValueFloat(0.051f);
	dphPixel.AddNameValParam(nvt);

	dphPixel.AddColumn(UShortColumn(L"Pixel"));

	int32_t rows = 1000;
	dphPixel.SetRowCnt(rows);

	dch.AddDataSetHdr(dphPixel);

	// Fill the grid DataSetHeader
	DataSetHeader dphGrid;
	dphGrid.SetName(L"grid position");
	nvt.SetName(L"GhostGrids");
	nvt.SetValueText(L"True");
	dphGrid.AddNameValParam(nvt);
	nvt.SetName(L"Pixel Size");
	nvt.SetValueFloat(0.051f);
	dphGrid.AddNameValParam(nvt);

	dphGrid.AddColumn(FloatColumn(L"Upper left x"));
	dphGrid.AddColumn(FloatColumn(L"Upper left y"));
	dphGrid.AddColumn(FloatColumn(L"Upper right x"));
	dphGrid.AddColumn(FloatColumn(L"Upper right y"));
	dphGrid.AddColumn(FloatColumn(L"Lower right x"));
	dphGrid.AddColumn(FloatColumn(L"Lower right y"));
	dphGrid.AddColumn(FloatColumn(L"Lower left x"));
	dphGrid.AddColumn(FloatColumn(L"Lower left y"));

	int32_t grids = 5;	// first is the global grid with 4 subgrids
	dphGrid.SetRowCnt(grids);

	dch.AddDataSetHdr(dphGrid);

	// Set the FileHeader
	FileHeader fh;
	fh.SetFilename("test.file.data_dat_with_grid");
	fh.SetGenericDataHdr(gdh);
	fh.AddDataGroupHdr(dch);

	// Create the generic file writer
	GenericFileWriter gfWriter(&fh);
	gfWriter.WriteHeader();

	DataGroupWriterIt dcwBegin, dcwEnd;
	gfWriter.GetDataGroupWriters(dcwBegin, dcwEnd);

	DataGroupWriter d = *dcwBegin;
	dcwBegin->WriteHeader();

	DataSetWriterIt dpwBegin, dpwEnd;
	dcwBegin->GetDataSetWriters(dpwBegin, dpwEnd);

	// Write out the pixel DataSet

	dpwBegin->WriteHeader();

	for( int32_t i=0; i < rows; ++i )
	{
		u_int16_t value = (u_int16_t)(i*10+i);
		dpwBegin->Write(value);
	}

	dpwBegin->UpdateNextDataSetOffset();

	++dpwBegin;

	// Write out the grid DataSet

	dpwBegin->WriteHeader();

	for( int32_t i=0; i < grids; ++i )
	{
		for (int32_t corner = 0; corner < 4; ++corner)
		{
			float value = (float)(i*100 + corner);
			dpwBegin->Write(value);
			dpwBegin->Write(value);
		}
	}

	dpwBegin->UpdateNextDataSetOffset();

//.........这里部分代码省略.........

// Uses a mix of the GenericFileWriter and raw commands
void TestFileGenerator::WriteOutGenericDATDataFile1UsingGenericWriter()
{
	GenericDataHeader gdh;
	AddStandardGenericDataHeader(gdh);

	// Fill the DataSetHeader
	DataSetHeader dph;
	dph.SetName(L"acquired data");
	ParameterNameValueType nvt;
	nvt.SetName(L"Scanner");
	nvt.SetValueText(L"M10");
	dph.AddNameValParam(nvt);
	nvt.SetName(L"Pixel Size");
	nvt.SetValueFloat(0.051f);
	dph.AddNameValParam(nvt);
	dph.AddColumn(UShortColumn(L"Pixel"));

	int32_t rows = 100;
	dph.SetRowCnt(rows);

	// Open the file.
	ofstream fileStream;
	fileStream.open( "test.file.data_dat", ios_base::out | ios_base::binary | ios_base::trunc);

	// Write the file header using raw methods until the writer is available.
	// magic number
	FileOutput::WriteUInt8(fileStream, 59);

	// version
	FileOutput::WriteInt8(fileStream, 1);

	// Number of data cubes - confirm this
	FileOutput::WriteUInt32(fileStream, 1);

	// offset to the data cube byte offset array
	int offsetLocation = fileStream.tellp();
	FileOutput::WriteUInt32(fileStream, 1);	//????

	// Write the GenericDataHeader to the file
	GenericDataHeaderWriter gdhWriter;
	gdhWriter.Write(fileStream, gdh);


	//
	// Data Cube
	//

	int offset = fileStream.tellp();

	// Write the DataSetHeader
	DataSetWriter dphWriter(&fileStream, &dph);
	dphWriter.WriteHeader();

	// Write out the data
	for( int32_t i=0; i < rows; ++i )
	{
		u_int16_t value = (u_int16_t)(i*10+i);
		FileOutput::WriteUInt16(fileStream, value);
	}

	// write the offset
	fileStream.seekp(offsetLocation);
	FileOutput::WriteUInt32(fileStream, offset);

	fileStream.close();

}

void DataSetUpdaterTest::CreateReferenceFile()
{
	// Create the data object.
	GenericData data;
	data.Header().SetFilename(TEST_FILE);

	DataGroupHeader dgHdr(L"data");
	DataSetHeader dsHdr;

	dsHdr.SetName(L"test");
	dsHdr.AddAsciiColumn(L"string8", 64);
	dsHdr.AddUnicodeColumn(L"string16", 64);
	dsHdr.AddByteColumn(L"int8");
	dsHdr.AddShortColumn(L"int16");
	dsHdr.AddIntColumn(L"int32");
	dsHdr.AddUByteColumn(L"uint8");
	dsHdr.AddUShortColumn(L"uint16");
	dsHdr.AddUIntColumn(L"uint32");
	dsHdr.AddFloatColumn(L"float");
	dsHdr.SetRowCnt(3);

	dgHdr.AddDataSetHdr(dsHdr);

	data.Header().AddDataGroupHdr(dgHdr);
	data.Header().GetGenericDataHdr()->SetFileTypeId("affymetrix.test.data");



	// Write the data object to the file
	GenericFileWriter writer(&data.Header());
	writer.WriteHeader();

	DataGroupWriter &dataGroupWriter = writer.GetDataGroupWriter(0);
	dataGroupWriter.WriteHeader();

	//int iSet=0;
	DataSetWriterIt beginSet;
	DataSetWriterIt endSet;
	dataGroupWriter.GetDataSetWriters(beginSet, endSet);

	beginSet->WriteHeader();

	int32_t dataSetSz = beginSet->GetDataSetSize();
	int32_t offset = writer.GetFilePos();
	writer.SeekFromCurrentPos(dataSetSz + 1);
	beginSet->UpdateNextDataSetOffset();

	dataGroupWriter.UpdateNextDataGroupPos();
	
	writer.SeekFromBeginPos(offset);


	// Write the data.
	beginSet->Write("first_row", 64);
	beginSet->Write(L"first_row", 64);
	beginSet->Write((int8_t) 1);
	beginSet->Write((int16_t) 1);
	beginSet->Write((int32_t) 1);
	beginSet->Write((u_int8_t) 1);
	beginSet->Write((u_int16_t) 1);
	beginSet->Write((u_int32_t) 1);
	beginSet->Write(1.0f);

	beginSet->Write("second_row", 64);
	beginSet->Write(L"second_row", 64);
	beginSet->Write((int8_t) 2);
	beginSet->Write((int16_t) 2);
	beginSet->Write((int32_t) 2);
	beginSet->Write((u_int8_t) 2);
	beginSet->Write((u_int16_t) 2);
	beginSet->Write((u_int32_t) 2);
	beginSet->Write(2.0f);

	beginSet->Write("third_row", 64);
	beginSet->Write(L"third_row", 64);
	beginSet->Write((int8_t) 3);
	beginSet->Write((int16_t) 3);
	beginSet->Write((int32_t) 3);
	beginSet->Write((u_int8_t) 3);
	beginSet->Write((u_int16_t) 3);
	beginSet->Write((u_int32_t) 3);
	beginSet->Write(3.0f);
}