C++ ParameterNameValueType::SetValueText方法代码示例

void CHPQuantificationDataTest::test_AlgParams()
{
	ParameterNameValueTypeList params;
	ParameterNameValueType param;
	CHPQuantificationData data;

	param.SetName(L"n1");
	param.SetValueText(L"v1");
	params.push_back(param);

	param.SetName(L"n2");
	param.SetValueText(L"v2");
	params.push_back(param);

	data.AddAlgParams(params);

	ParameterNameValueTypeList params_out = data.GetAlgParams();
	CPPUNIT_ASSERT(params_out.size() == 2);
	ParameterNameValueTypeList::iterator it = params_out.begin();
	param = *it;
	CPPUNIT_ASSERT(param.GetName() == L"n1");
	CPPUNIT_ASSERT(param.GetValueText() == L"v1");
	++it;
	param = *it;
	CPPUNIT_ASSERT(param.GetName() == L"n2");
	CPPUNIT_ASSERT(param.GetValueText() == L"v2");

}

void TestFileGenerator::AddStandardGenericDataHeader(GenericDataHeader& gdh)
{
	// Fill the GenericDataHeader.
	gdh.SetFileTypeId(SCAN_ACQUISITION_DATA_TYPE);
	gdh.SetFileId("test-dat-guid");
	gdh.SetFileCreationTime(L"2004-07-04T11:12:13Z");
	gdh.SetLocale(L"en-US");
	ParameterNameValueType nvt;
	nvt.SetName(ARRAY_TYPE_PARAM_NAME);
	nvt.SetValueText(L"Hg-U133A");
	gdh.AddNameValParam(nvt);
	nvt.SetName(ARRAY_BARCODE_PARAM_NAME);
	nvt.SetValueText(L"Barcode");
	gdh.AddNameValParam(nvt);
	nvt.SetName(L"Parameter1");
	nvt.SetValueText(L"Value1");
	gdh.AddNameValParam(nvt);

	GenericDataHeader gdhParent;
	gdhParent.SetFileTypeId(ARRAY_TYPE_IDENTIFIER);
	gdhParent.SetFileId("test-array-guid");
	gdhParent.SetFileCreationTime(L"2004-07-01T13:14:15Z");
	gdhParent.SetLocale(L"en-US");
	nvt.SetName(ARRAY_TYPE_PARAM_NAME);
	nvt.SetValueText(L"Hg-U133A");
	gdhParent.AddNameValParam(nvt);
	nvt.SetName(ARRAY_LOT_PARAM_NAME);
	nvt.SetValueText(L"Thanks alot");
	gdhParent.AddNameValParam(nvt);

	gdh.AddParent(gdhParent);
}

void CHPMultiDataDataTest::test_SumParams()
{
	ParameterNameValueTypeList params;
	ParameterNameValueType param;
	CHPMultiDataData data;

	param.SetName(L"n1");
	param.SetValueText(L"v1");
	params.push_back(param);

	param.SetName(L"n2");
	param.SetValueText(L"v2");
	params.push_back(param);

	data.AddSummaryParams(params);

	ParameterNameValueTypeList params_out = data.GetSummaryParams();
	CPPUNIT_ASSERT(params_out.size() == 2);
	ParameterNameValueTypeList::iterator it = params_out.begin();
	param = *it;
	CPPUNIT_ASSERT(param.GetName() == L"n1");
	CPPUNIT_ASSERT(param.GetValueText() == L"v1");
	++it;
	param = *it;
	CPPUNIT_ASSERT(param.GetName() == L"n2");
	CPPUNIT_ASSERT(param.GetValueText() == L"v2");

}

/*
 * Save the program information to the AGCC file.
 */
void MAS5CHPUtils::StoreProgramInfo()
{
    ParameterNameValueType p;
    p.SetName(PROGRAM_NAME);
    p.SetValueText(programName);
    cc_data->GetGenericData().Header().GetGenericDataHdr()->AddNameValParam(p);
    p.SetName(PROGRAM_ID);
    p.SetValueText(programId);
    cc_data->GetGenericData().Header().GetGenericDataHdr()->AddNameValParam(p);
    p.SetName(PROGRAM_COMPANY);
    p.SetValueText(programCompany);
    cc_data->GetGenericData().Header().GetGenericDataHdr()->AddNameValParam(p);
}

void DataGroupHeaderTest::FindDataSetHeaderTest()
{
	// Create DataSetHeaders
	DataSetHeader dph1;
	dph1.SetName(L"pixel intensity");
	ParameterNameValueType param;
	param.SetName(L"Scanner");
	param.SetValueText(L"M10");
	dph1.AddNameValParam(param);
	dph1.AddUShortColumn(L"");
	dph1.SetRowCnt(1);

	DataSetHeader dph2;
	dph2.SetName(L"grid coordinates");
	param.SetName(L"Corner Pattern");
	param.SetValueText(L"Checkerboard");
	dph2.AddNameValParam(param);
	dph2.AddUShortColumn(L"");
	dph2.AddUShortColumn(L"");
	dph2.AddUShortColumn(L"");
	dph2.AddUShortColumn(L"");

	dph2.AddUShortColumn(L"");
	dph2.AddUShortColumn(L"");
	dph2.AddUShortColumn(L"");
	dph2.AddUShortColumn(L"");

	dph2.AddUShortColumn(L"");
	dph2.AddUShortColumn(L"");
	dph2.AddUShortColumn(L"");
	dph2.AddUShortColumn(L"");

	dph2.AddUShortColumn(L"");
	dph2.AddUShortColumn(L"");
	dph2.AddUShortColumn(L"");
	dph2.AddUShortColumn(L"");
	dph2.SetRowCnt(1);

	header->AddDataSetHdr(dph1);
	header->AddDataSetHdr(dph2);

	const DataSetHeader* dph = header->FindDataSetHeader(L"none");
	CPPUNIT_ASSERT(0 == dph);
	dph = header->FindDataSetHeader(dph1.GetName());
	CPPUNIT_ASSERT(0 != dph);
	CPPUNIT_ASSERT(dph->GetName() == dph1.GetName());
	dph = header->FindDataSetHeader(dph2.GetName());
	CPPUNIT_ASSERT(0 != dph);
	CPPUNIT_ASSERT(dph->GetName() == dph2.GetName());
}

void TestFileGenerator::WriteSmallCelFileWithAPartialDatHeaderTest()
{
	CelFileData data("small_cel_file_partial_datheader");

	// Write 
	ParameterNameValueType nvt;
	GenericDataHeader datHdr;
	datHdr.SetFileId(AffymetrixGuid::GenerateNewGuid());
	datHdr.SetFileTypeId("affymetrix-calvin-scan-acquisition");
	datHdr.SetFileCreationTime(L"2004-07-01T13:14:15Z");
	nvt.SetName(L"affymetrix-partial-dat-header");
	std::wstring datHeaderString = L"  small_cel_file_partial_datheader:CLS=25   RWS=25   XIN=1  YIN=1  VE=0         0   05/19/05 02:45:59 ScannerID:  ScannerTyp   \x14  \x14 Hg-Small.1sq \x14  \x14  \x14  \x14  \x14 570 \x14 45.200001 \x14 0.340000 \x14 1.0900 \x14 3";
	nvt.SetValueText(datHeaderString);
	datHdr.AddNameValParam(nvt);
	nvt.SetName(L"affymetrix-max-pixel-intensity");
	nvt.SetValueUInt16(46001);
	datHdr.AddNameValParam(nvt);
	nvt.SetName(L"affymetrix-min-pixel-intensity");
	nvt.SetValueUInt16(1);
	datHdr.AddNameValParam(nvt);

	// Add DAT GenericDataHeader as parent.
	data.GetFileHeader()->GetGenericDataHdr()->AddParent(datHdr);

	WriteRemaingSmallCelFileWithGridParameters(data);
}

void CHPQuantificationData::SetWStringToGenericHdr(const std::wstring& name, const std::wstring value, int32_t reserve)
{
	ParameterNameValueType paramType;
	paramType.SetName(name);
	paramType.SetValueText(value, reserve);
	GenericDataHeader* hdr = genericData.Header().GetGenericDataHdr();
	hdr->AddNameValParam(paramType);
}

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();
}

bool DataSetHeader::FindNameValParam(const std::wstring& name, ParameterNameValueType& result) const
{
	ParameterNameValueType t;
	t.SetName(name);
	t.SetValueText(L"");
	ParameterNameValueTypeConstIt found = FindNameValParam(t);
	if (found != nameValParams.end())
	{
		result = *found;
		return true;
	}
	return false;
}

void TestFileGenerator::WriteSmallDatFileWithReservedStringParameters()
{
	int32_t rows = 4;
	int32_t cols = 5;
	int32_t pixelCount = rows*cols;
	DATData data("small_dat_file_with_reserved_string_parameters");
	data.SetPixelCount(pixelCount);
	data.SetStatsCount(1);
	data.SetArrayType(L"Hg_small");
	data.SetPixelSize(0.71f);
	data.SetScannerType(L"M10");
	data.SetScannerID(L"main");
	DateTime dt = DateTime::Parse(L"2005-12-25T11:12:13Z");
	data.SetScanDate(dt);
	data.SetRows(rows);
	data.SetCols(cols);
	std::string arrayId = "smellsliketeenspirit";
	data.SetArrayId(arrayId);
	
	ParameterNameValueType nvt;
	nvt.SetName(L"fixedlen");
	nvt.SetValueText(L"twenty-five", 25);
	data.GetFileHeader()->GetGenericDataHdr()->AddNameValParam(nvt);

	DATFileWriter writer(data);

	Uint16Vector pixels;
	pixels.reserve(pixelCount);

	u_int16_t inten = 10;
	for (int32_t i=0; i<pixelCount; ++i, ++inten)
	{
		if (inten > 46000)
		{
			inten = 0;
		}
		pixels.push_back(inten);
	}

	Uint16Vector stats;
	stats.push_back(pixels[0]);	// min
	stats.push_back(pixels[19]);	// max

	writer.WriteStats(stats);
	writer.WritePixels(pixels);
}

void TestFileGenerator::WriteSmallDatFileWithGridAndSubgridsAndParameters()
{
	std::string filename = "small_DAT_file_with_subgrids_and_parameters";
	WriteDatFile(filename, L"Hg-small", 4, 5, true);

	DATData data(filename);
	AddGridAndSubgrids(data, 2.5, 10);

	ParameterNameValueType nvt;
	nvt.SetName(L"Zip Code");
	nvt.SetValueInt32(95051);
	data.AddGridAlignmentAlgorithmParameter(nvt);
	nvt.SetName(L"County");
	nvt.SetValueText(L"Santa Clara");
	data.AddGridAlignmentAlgorithmParameter(nvt);

	DATFileUpdater update(data);
	update.Update();
}

void TestFileGenerator::WriteSmallCelFileWithAFullDatHeaderTest()	// Files converted from GCOS will have a full DatHeader
{
	CelFileData data("small_cel_file_full_datheader");

	// Write 
	ParameterNameValueType nvt;
	GenericDataHeader datHdr;
	datHdr.SetFileId(AffymetrixGuid::GenerateNewGuid());
	datHdr.SetFileTypeId("affymetrix-calvin-scan-acquisition");
	datHdr.SetFileCreationTime(L"2004-07-01T13:14:15Z");
	nvt.SetName(L"affymetrix-dat-header");
	std::wstring datHeaderString = L"[45..56789]  small_cel_file_full_datheader:CLS=25   RWS=25   XIN=1  YIN=1  VE=0         0   05/19/05 02:45:59 ScannerID:  ScannerTyp   \x14  \x14 Hg-Small.1sq \x14  \x14  \x14  \x14  \x14 570 \x14 45.200001 \x14 0.340000 \x14 1.0900 \x14 3";
	nvt.SetValueText(datHeaderString);
	datHdr.AddNameValParam(nvt);

	// Add DAT GenericDataHeader as parent.
	data.GetFileHeader()->GetGenericDataHdr()->AddParent(datHdr);

	WriteRemaingSmallCelFileWithGridParameters(data);
}

/** 
 * Get set up for a run of reporting probesets. Often used to open file
 * streams and print headers to files etc.
 * 
 * @param qMethod - Quantification method to be used.
 * @param layout - Where the probesets, probes, etc are on the chip.
 * 
 * @return true if success, false otherwise.
 */
bool QuantMethodExprCCCHPReport::prepare(QuantMethod &qMethod, const IntensityMart &iMart) 
{
    QuantExprMethod *eMethod = dynamic_cast<QuantExprMethod *>(&qMethod);
    if (eMethod == NULL) { Err::errAbort("Can only use a QuantMethodExprReport with a QuantExprMethod."); }
    
    setupFileNames(iMart);
    int nfiles = m_CHPFileNames.size();
    
    // Make sure our output directory exists.
    if (!Fs::isWriteableDir(m_Prefix.c_str()) &&
        (Fs::mkdirPath(m_Prefix, false) != APT_OK)) {
        APT_ERR_ABORT("Can't make or write to directory: " + m_Prefix);
    }
    
    removeAllChps();
    
    // Get CEL file GUIDs
    ///@todo This be computed by the engine and passed in via AnalysisInfo
    m_celGuids.resize(nfiles);
    std::string tmp_unc_name;
    for (int chip=0; chip<nfiles; chip++) {
        FusionCELData cel;
        try {
            tmp_unc_name=Fs::convertToUncPath(m_CELFileNames[chip]);
            cel.SetFileName(tmp_unc_name.c_str());
            if (!cel.ReadHeader()) {
                Err::errAbort("Unable to read CEL file: "+FS_QUOTE_PATH(tmp_unc_name));
            }
            GenericData *gdata = cel.GetGenericData();
            if (gdata != NULL) {
                m_celGuids[chip] = gdata->Header().GetGenericDataHdr()->GetFileId();
            }
            cel.Close();
        }
        catch (...) {
            Err::errAbort("Unable to read CEL file " + tmp_unc_name);
        }
    }

    int maxProbeSetNameLength = 0;
    for (int i=0; i<m_Info.m_ProbesetNames.size(); i++) {
        int len = (int)strlen(m_Info.m_ProbesetNames.at(i));
        if (m_Info.m_ProbesetDisplayNames.size() > 0 && m_Info.m_ProbesetDisplayNames.at(i) != NULL)
            len = (int)strlen(m_Info.m_ProbesetDisplayNames.at(i));
        maxProbeSetNameLength = Max(maxProbeSetNameLength, len);
    }

    // Prepare headers for all CHP files.
    wstring algName = StringUtils::ConvertMBSToWCS(m_Info.m_AlgName);
    wstring algVersion = StringUtils::ConvertMBSToWCS(m_Info.m_AlgVersion);
    wstring chipType = StringUtils::ConvertMBSToWCS(m_Info.m_ChipType);

    // For each chip, precreate all probeset signal entries (default to 0.0).
    Verbose::out(1,"QuantMethodExprCCCHPReport: Creating temporary files for CHP output");
    for (int chip=0; chip<nfiles; chip++) {
        try {
            ParameterNameValueType param;

            // Create tmp chp file
            std::string tmp_chp_name=m_CHPFileNames[chip] + ".tmp";
            CHPQuantificationData *data = new CHPQuantificationData(tmp_chp_name);
            m_TmpChpFiles.push_back(tmp_chp_name);

            // set parent header
            FusionCELData cel;
            try {
                tmp_unc_name=Fs::convertToUncPath(m_CELFileNames[chip]);
                cel.SetFileName(tmp_unc_name.c_str());
                if (!cel.ReadHeader()) {
                  Err::errAbort("Unable to read CEL file: "+FS_QUOTE_PATH(tmp_unc_name));
                }
                GenericData *gdata = cel.GetGenericData();
                if (gdata != NULL) {
                    data->GetFileHeader()->GetGenericDataHdr()->AddParent(*gdata->Header().GetGenericDataHdr());
                }
                cel.Close();
            }
            catch (...) {
              Err::errAbort("Unable to read CEL file: "+FS_QUOTE_PATH(tmp_unc_name));
            }

            data->SetEntryCount(m_Info.m_NumProbeSets, maxProbeSetNameLength); 
            data->SetAlgName(algName);
            data->SetAlgVersion(algVersion);
            data->SetArrayType(chipType);

            param.SetName(L"program-name");
            param.SetValueText(StringUtils::ConvertMBSToWCS(m_Info.m_ProgramName));
            data->GetGenericData().Header().GetGenericDataHdr()->AddNameValParam(param);
            param.SetName(L"program-version");
            param.SetValueText(StringUtils::ConvertMBSToWCS(m_Info.m_ProgramVersion));
//.........这里部分代码省略.........

void CalvinCHPMultiDataFileUpdaterTest::CreateReferenceFile2()
{
	CHPMultiDataData data(TEST2_FILE);
    vector<ColumnInfo> cols;
    ParameterNameValueType nv;

    ByteColumn bcol(L"byte");
    cols.push_back(bcol);

    UByteColumn ubcol(L"ubyte");
    cols.push_back(ubcol);

    ShortColumn scol(L"short");
    cols.push_back(scol);

    UShortColumn uscol(L"ushort");
    cols.push_back(uscol);

    IntColumn icol(L"int");
    cols.push_back(icol);

    UIntColumn uicol(L"uint");
    cols.push_back(uicol);

    FloatColumn fcol(L"float");
    cols.push_back(fcol);

    ASCIIColumn acol(L"ascii", 7);
    cols.push_back(acol);

    UnicodeColumn tcol(L"text", 10);
    cols.push_back(tcol);


	ProbeSetMultiDataGenotypeData e;
	data.SetEntryCount(GenotypeMultiDataType, 4, 10, cols);
	CHPMultiDataFileWriter *writer = new CHPMultiDataFileWriter(data);

    nv.SetName(L"byte");
    nv.SetValueInt8(8);
    e.metrics.push_back(nv);
    nv.SetName(L"ubyte");
    nv.SetValueUInt8(8);
    e.metrics.push_back(nv);

    nv.SetName(L"short");
    nv.SetValueInt16(16);
    e.metrics.push_back(nv);
    nv.SetName(L"ushort");
    nv.SetValueUInt16(16);
    e.metrics.push_back(nv);

    nv.SetName(L"int");
    nv.SetValueInt32(32);
    e.metrics.push_back(nv);
    nv.SetName(L"uint");
    nv.SetValueUInt32(32);
    e.metrics.push_back(nv);

    nv.SetName(L"float");
    nv.SetValueFloat(44.0f);
    e.metrics.push_back(nv);

    nv.SetName(L"ascii");
    nv.SetValueAscii("ascii");
    e.metrics.push_back(nv);

    nv.SetName(L"text");
    nv.SetValueText(L"text");
    e.metrics.push_back(nv);


	writer->SeekToDataSet(GenotypeMultiDataType);
	e.name = "1";
    e.call = 1;
    e.confidence = 10.0f;
	writer->WriteEntry(e);
	e.name = "2";
    e.call = 2;
    e.confidence = 20.0f;
	writer->WriteEntry(e);
	e.name = "3";
    e.call = 3;
    e.confidence = 30.0f;
	writer->WriteEntry(e);
	e.name = "4";
    e.call = 4;
    e.confidence = 40.0f;
	writer->WriteEntry(e);

	delete writer;
}

/*! Create a "quantification" CHP file with just the header information. The remainder of the file
 * will be created at a later time using the buffer writer technique.
 * The CHP file will contain only "quantification" results from an expression analysis.
 * @param execId The execution identifier. This identifier is used to identify the batch run that created the CHP files.
 * @param celFile The full path to the parent CEL file. The header of the CEL file is copied to the CHP file.
 * @param outFile The name of the output CHP file.
 * @param probeSetNames The probe set names.
 * @param algName The name of the algorithm used to create the results.
 * @param algVersion The algorithm version.
 * @param chipType the chip type, also known as the probe array type.
 * @param programName The name of the program used to create the CHP file.
 * @param programVersion The version of the program.
 * @param programCompany The company or institution who developed the CHP creating software.
 * @param paramNames A list of parameter names to store in the CHP file header.
 * @param paramValues A list of parameter values to store in the CHP file header.
 * @param sumNames A list of summary statistic names to store in the CHP file header.
 * @param sumValues A list of summary statistic values to store in the CHP file header.
*/
static void CreateFileWithHeader
(
	const string &execId,
	const string &celFile,
	const string &outFile,
	const list<string> &probeSetNames,
	const string &algName,
	const string &algVersion,
	const string &chipType,
	const string &programName,
	const string &programVersion,
	const string &programCompany,
	const vector<string>& paramNames,
	const vector<string>& paramValues,
	const vector<string>& sumNames,
	const vector<string>& sumValues
)
{
	// Determine the max probe set name.
	int numEntries = (int) probeSetNames.size();
	int maxProbeSetNameLength = 0;
	for (list<string>::const_iterator it=probeSetNames.begin(); it!=probeSetNames.end(); it++)
	{
		maxProbeSetNameLength = max(maxProbeSetNameLength, (int) it->length());
	}

	// Create the data object
	CHPQuantificationData *data = new CHPQuantificationData(outFile);
    data->SetEntryCount(numEntries, maxProbeSetNameLength);
	data->SetAlgName(StringUtils::ConvertMBSToWCS(algName));
	data->SetAlgVersion(StringUtils::ConvertMBSToWCS(algVersion));
	data->SetArrayType(StringUtils::ConvertMBSToWCS(chipType));

	// Store the CEL header
	if (celFile.length() > 0 && FileUtils::Exists(celFile.c_str()) == true)
	{
		FusionCELData cel;
		cel.SetFileName(celFile.c_str());
        cel.ReadHeader();
	    GenericData *gdata = cel.GetGenericData();
	    if (gdata != NULL)
			data->GetFileHeader()->GetGenericDataHdr()->AddParent(*gdata->Header().GetGenericDataHdr()); 
	    cel.Close();
	}

	// Add algorithm parameters to list.
    ParameterNameValueTypeList params;
    ParameterNameValueType param;
    
	if (programName.empty() == false)
	{
		param.SetName(L"program-name");
		param.SetValueText(StringUtils::ConvertMBSToWCS(programName));
		data->GetGenericData().Header().GetGenericDataHdr()->AddNameValParam(param);
	}

	if (programVersion.empty() == false)
	{
		param.SetName(L"program-version");
		param.SetValueText(StringUtils::ConvertMBSToWCS(programVersion));
		data->GetGenericData().Header().GetGenericDataHdr()->AddNameValParam(param);
	}

	if (programCompany.empty() == false)
	{
		param.SetName(L"program-company");
		param.SetValueText(StringUtils::ConvertMBSToWCS(programCompany));
		data->GetGenericData().Header().GetGenericDataHdr()->AddNameValParam(param);
	}

	int nparams = (int) paramNames.size();
	param.SetName(L"exec-guid");
	param.SetValueAscii(execId);
	params.push_back(param);
	for(int iparam=0; iparam<nparams; iparam++)
	{
		param.SetName(StringUtils::ConvertMBSToWCS(paramNames[iparam]));
        param.SetValueAscii(paramValues[iparam]);
        params.push_back(param);
	}
	if (params.empty() == false)
		data->AddAlgParams(params);
//.........这里部分代码省略.........