envi-code/SourceCode/Code2026/tg_shs/shs_pipewire/THVDbSpace.cpp

// THVDbSpace.cpp: implementation of the THVDbSpace class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "THVDbSpace.h"
#include "DbText.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

ACRX_DXF_DEFINE_MEMBERS(ATSHVDbSpace, ATSSpace, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,  
						1, ATS_HVDBSPACE, "ATS_HVDBSPACE, 请下载上华软件|网址: www.shanghuasoft.com");
IMPLEMENT_TENTBASE(THVDbSpace);

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
const Adesk::UInt8 THVDbSpace::g_nVersion = 1; 

THVDbSpace::THVDbSpace()
{
	m_nTextHeight = 3.0;

	m_dAirColdLoad = 0;
	m_dAirHeatLoad = 0;
	m_dColdLoadNoAir = 0;
	m_dHeatLoadNoAir = 0;
	m_dHideColdLoad = 0;
	m_dSummerHumLoad = 0;
	m_dWinterHumLoad = 0;

	int i(0);
	for (i = 0; i < 3; i++)
	{
		m_arrayDim[i] = TRUE;
	}
	for (i = 3; i < /*12*/13; i++)  // change by zh
	{
		m_arrayDim[i] = FALSE;
	}

	m_bExtSpace = FALSE;
}

THVDbSpace::~THVDbSpace()
{

}

// 是否标注某项，0～11见注释
void THVDbSpace::SetDim(BOOL bDim, int nNum)
{
	assertWriteEnabled();
	if ((nNum < 0) || (nNum > /*11*/12))// change by zh
	{
		return;
	}

	m_arrayDim[nNum] = bDim;
	// add by hh 2013-5-9 是否标注新风量 写入到动态数据中
	if(12 == nNum)
	{
		TEntityFields &fd = Fields();
		fd.SFD(_T("THVS_NEWAIRDIM"), bDim);
	}
}

BOOL THVDbSpace::IsDim(int nNum) const
{
	if ((nNum < 0) || (nNum > /*11*/12))// change by zh
	{
		return FALSE;
	}

	return m_arrayDim[nNum];
}

// 获取标注内容
void THVDbSpace::GetDimString(XStringList &lstString) const
{
	// add by hh 2011-04-26 使用上华选项中的房间面积精度
	TDbConfig* pCfg = GetDwgGlobal(AcDb::kForRead);
	CString sAreaFmt;
	if(NULL == pCfg)
		sAreaFmt = _T("%.2f");
	else
	{
		sAreaFmt.Format(_T("%%.%df"), pCfg->GetSpaceAreaPrecision());
		pCfg->close();
	}

	if (m_bExtSpace) // 最后的建筑面积
	{
		XString sDim;
		// sDim << _T("建筑面积:") << XString(_T("%.2f"), m_nUseArea);
		sDim << _T("建筑面积:") << XString(sAreaFmt, m_nUseArea);
		if (m_bDimUnit) // 标注单位
		{
			sDim << _T("m^U2^U");
		}
		lstString.Append(tstrnew(sDim));
		return;
	}

	XString sNum(256), sName(256);
	sNum << _T("房间号:") << XString(_T("%s"), m_sCode);
	lstString.Append(tstrnew(sNum));
	sName << _T("房间名称:") << XString(_T("%s"), m_sName);
	lstString.Append(tstrnew(sName));

	XString sArea(256);
	// sArea << _T("面积:") << XString(_T("%.2f"), m_nUseArea);
	sArea << _T("面积:") << XString(sAreaFmt, m_nUseArea);
	if (m_bDimUnit)
	{
		sArea << _T("m^U2^U");
	}
	lstString.Append(tstrnew(sArea));

	XString sLoad3(256), sLoad4(256), sLoad5(256), sLoad6(256), sLoad7(256),
		sLoad8(256), sLoad9(256), sLoad10(256), sLoad11(256), sLoad12(256);  // add by zh 新风量显示
	sLoad3 << _T("总冷负荷:") << XString(_T("%.0f"), m_dbColdLoad);
	sLoad4 << _T("冷负荷(不含新风):") << XString(_T("%.0f"), m_dColdLoadNoAir);
	sLoad5 << _T("新风冷负荷:") << XString(_T("%.0f"), m_dAirColdLoad);
	sLoad6 << _T("潜热冷负荷:") << XString(_T("%.0f"), m_dHideColdLoad);
	sLoad7 << _T("夏季湿负荷:") << XString(_T("%.2f"), m_dSummerHumLoad);
	sLoad8 << _T("总热负荷:") << XString(_T("%.0f"), m_dbHeatLoad);
	sLoad9 << _T("热负荷(不含新风):") << XString(_T("%.0f"), m_dHeatLoadNoAir);
	sLoad10 << _T("新风热负荷:") << XString(_T("%.0f"), m_dAirHeatLoad);
	sLoad11 << _T("冬季湿负荷:") << XString(_T("%.2f"), m_dWinterHumLoad);
	sLoad12 << _T("新风量:") << XString(_T("%.0f"), GetNewAir());   // add by zh 新风量
	if (m_bDimUnit)
	{
		sLoad3 << _T("W");
		sLoad4 << _T("W");
		sLoad5 << _T("W");
		sLoad6 << _T("W");
		sLoad7 << _T("kg/h");
		sLoad8 << _T("W");
		sLoad9 << _T("W");
		sLoad10 << _T("W");
		sLoad11 << _T("kg/h");
		sLoad12 << _T("m^U3^U/h");  // add by zh 新风量单位
	}
	lstString.Append(tstrnew(sLoad3));
	lstString.Append(tstrnew(sLoad4));
	lstString.Append(tstrnew(sLoad5));
	lstString.Append(tstrnew(sLoad6));
	lstString.Append(tstrnew(sLoad7));
	lstString.Append(tstrnew(sLoad8));
	lstString.Append(tstrnew(sLoad9));
	lstString.Append(tstrnew(sLoad10));
	lstString.Append(tstrnew(sLoad11));
	lstString.Append(tstrnew(sLoad12));// add by zh 新风量
}


//////////////////////////////////////////////////////////////////////
// Override TDbEntity
//////////////////////////////////////////////////////////////////////
Acad::ErrorStatus THVDbSpace::subGetClassID(CLSID* pClsid) const
{
    return Acad::eOk;
}

void THVDbSpace::CopyPropertiesFrom(AcDbEntity* pSrc, unsigned gMatchFlag)
{
    assertWriteEnabled();
	TDbSpace::CopyPropertiesFrom(pSrc, gMatchFlag);
	THVDbSpace *pSpace = THVDbSpace::cast(pSrc);
	if (pSpace != NULL)
	{
		m_dAirColdLoad = pSpace->m_dAirColdLoad;
		m_dAirHeatLoad = pSpace->m_dAirHeatLoad;
		m_dColdLoadNoAir = pSpace->m_dColdLoadNoAir;
		m_dHeatLoadNoAir = pSpace->m_dHeatLoadNoAir;
		m_dHideColdLoad = pSpace->m_dHideColdLoad;
		m_dSummerHumLoad = pSpace->m_dSummerHumLoad;
		m_dWinterHumLoad = pSpace->m_dWinterHumLoad;

		m_bDimUnit = pSpace->m_bDimUnit;
		for (int i = 0; i < /*12*/13; i++)// change by zh 新风量
		{
			m_arrayDim[i] = pSpace->m_arrayDim[i];
		}
	}
}


//////////////////////////////////////////////////////////////////////
// 存储数据
//////////////////////////////////////////////////////////////////////
Acad::ErrorStatus THVDbSpace::dwgInFields(AcDbDwgFiler* pFiler)
{
    assertWriteEnabled();
    Acad::ErrorStatus es = TDbSpace::dwgInFields(pFiler);
    if (es != Acad::eOk)
	{
		return es;
	}
	
    Adesk::UInt8  nVer;
    pFiler->readItem(&nVer);
    if (nVer > g_nVersion) // Version is too new
	{
        return Acad::eMakeMeProxy;
	}

	pFiler->readItem(&m_dAirColdLoad);
	pFiler->readItem(&m_dAirHeatLoad);	
	pFiler->readItem(&m_dColdLoadNoAir);
	pFiler->readItem(&m_dHeatLoadNoAir);
	pFiler->readItem(&m_dHideColdLoad);
	pFiler->readItem(&m_dSummerHumLoad);
	pFiler->readItem(&m_dWinterHumLoad);

	//pFiler->readItem(&m_bExtSpace);
	//pFiler->readItem(&m_bDimUnit);
	FilerRead(pFiler, m_bExtSpace);
	FilerRead(pFiler, m_bDimUnit);

	for (Adesk::UInt8 i = 0; i < 12; i++)
	{
		//pFiler->readItem(&m_arrayDim[i]);
		FilerRead(pFiler, m_arrayDim[i]);
	}
	// add by hh 2013-5-9 从动态数据中读取是否标注新风量
	const TEntityFields &fd = GetFields();
	fd.GFD(_T("THVS_NEWAIRDIM"), m_arrayDim[12]);

    return pFiler->filerStatus();
}

Acad::ErrorStatus THVDbSpace::dwgOutFields(AcDbDwgFiler* pFiler) const
{
    assertReadEnabled();
    Acad::ErrorStatus es = TDbSpace::dwgOutFields(pFiler);
    if (es != Acad::eOk)
	{
		return es;
	}
	
    pFiler->writeItem(g_nVersion);
	pFiler->writeItem(m_dAirColdLoad);
	pFiler->writeItem(m_dAirHeatLoad);
	pFiler->writeItem(m_dColdLoadNoAir);
	pFiler->writeItem(m_dHeatLoadNoAir);
	pFiler->writeItem(m_dHideColdLoad);
	pFiler->writeItem(m_dSummerHumLoad);
	pFiler->writeItem(m_dWinterHumLoad);

	//pFiler->writeItem(m_bExtSpace);
	//pFiler->writeItem(m_bDimUnit);
	FilerWrite(pFiler, m_bExtSpace);
	FilerWrite(pFiler, m_bDimUnit);
	for (Adesk::UInt8 i = 0; i < 12; i++)
	{
		//pFiler->writeItem(m_arrayDim[i]);
		FilerWrite(pFiler, m_arrayDim[i]);
	}
    return pFiler->filerStatus();
}

Acad::ErrorStatus THVDbSpace::dxfInFields(AcDbDxfFiler* pFiler)
{
    assertWriteEnabled();
    Acad::ErrorStatus es =  TDbSpace::dxfInFields(pFiler);
    if (es != Acad::eOk)
	{
        return es;
	}

    if (!pFiler->atSubclassData(_T("THVDbSpace")))
	{
        return Acad::eBadDxfSequence;
    }

	resbuf rb;
    while ((es == Acad::eOk)
        && ((es = pFiler->readResBuf(&rb)) == Acad::eOk))
	{
        switch (rb.restype) {
        case AcDb::kDxfReal:
            m_dAirColdLoad = rb.resval.rreal;
            break;
        case AcDb::kDxfReal+1:
            m_dAirHeatLoad = rb.resval.rreal;
            break;
        case AcDb::kDxfReal+2:
            m_dColdLoadNoAir = rb.resval.rreal;
            break;
        case AcDb::kDxfReal+3:
            m_dHeatLoadNoAir = rb.resval.rreal;
            break;
        case AcDb::kDxfReal+4:
            m_dHideColdLoad = rb.resval.rreal;
            break;
        case AcDb::kDxfReal+5:
            m_dSummerHumLoad = rb.resval.rreal;
            break;
        case AcDb::kDxfReal+6:
            m_dWinterHumLoad = rb.resval.rreal;
            break;
			
//  mcl changed by below. x64位下要求写入类型与参数code一致。否则房间对象设置标注负荷参数后，
// 选中房间会崩溃
// 		case AcDb::kDxfBool:
// 			m_bExtSpace = rb.resval.rint;
// 			break;
// 		case AcDb::kDxfBool+1:
// 			m_bDimUnit = rb.resval.rint;
// 			break;
// 		case AcDb::kDxfBool+2:
// 			m_arrayDim[0] = rb.resval.rint;
// 			break;
// 		case AcDb::kDxfBool+3:
// 			m_arrayDim[1] = rb.resval.rint;
// 			break;
// 		case AcDb::kDxfBool+4:
// 			m_arrayDim[2] = rb.resval.rint;
// 			break;
// 		case AcDb::kDxfBool+5:
// 			m_arrayDim[3] = rb.resval.rint;
// 			break;
// 		case AcDb::kDxfBool+6:
// 			m_arrayDim[4] = rb.resval.rint;
// 			break;
// 		case AcDb::kDxfBool+7:
// 			m_arrayDim[5] = rb.resval.rint;
// 			break;
// 		case AcDb::kDxfBool+8:
// 			m_arrayDim[6] = rb.resval.rint;
// 			break;
// 		case AcDb::kDxfBool+9:
// 			m_arrayDim[7] = rb.resval.rint;
// 			break;
// 		case AcDb::kDxfBool+10:
// 			m_arrayDim[8] = rb.resval.rint;
// 			break;
// 		case AcDb::kDxfBool+11:
// 			m_arrayDim[9] = rb.resval.rint;
// 			break;
// 		case AcDb::kDxfBool+12:
// 			m_arrayDim[10] = rb.resval.rint;
// 			break;
// 		case AcDb::kDxfBool+13:
// 			m_arrayDim[11] = rb.resval.rint;
// 			break;

		case AcDb::kDxfInt8:
			m_bExtSpace = rb.resval.rint;
			break;
		case AcDb::kDxfInt8+1:
			m_bDimUnit = rb.resval.rint;
			break;
		case AcDb::kDxfInt8+2:
			m_arrayDim[0] = rb.resval.rint;
			break;
		case AcDb::kDxfInt8+3:
			m_arrayDim[1] = rb.resval.rint;
			break;
		case AcDb::kDxfInt8+4:
			m_arrayDim[2] = rb.resval.rint;
			break;
		case AcDb::kDxfInt8+5:
			m_arrayDim[3] = rb.resval.rint;
			break;
		case AcDb::kDxfInt8+6:
			m_arrayDim[4] = rb.resval.rint;
			break;
		case AcDb::kDxfInt8+7:
			m_arrayDim[5] = rb.resval.rint;
			break;
		case AcDb::kDxfInt8+8:
			m_arrayDim[6] = rb.resval.rint;
			break;
		case AcDb::kDxfInt8+9:
			m_arrayDim[7] = rb.resval.rint;
			break;
		case AcDb::kDxfInt8+10:
			m_arrayDim[8] = rb.resval.rint;
			break;
		case AcDb::kDxfInt8+11:
			m_arrayDim[9] = rb.resval.rint;
			break;
		case AcDb::kDxfInt8+12:
			m_arrayDim[10] = rb.resval.rint;
			break;
		case AcDb::kDxfInt8+13:
			m_arrayDim[11] = rb.resval.rint;
			break;
		
		default:
            pFiler->pushBackItem();
            es = Acad::eEndOfFile;
            break;
        }
    }

    if (es != Acad::eEndOfFile)
	{
        return Acad::eInvalidResBuf;
	}
    return pFiler->filerStatus();
}

Acad::ErrorStatus THVDbSpace::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	Acad::ErrorStatus es = TDbSpace::dxfOutFields(pFiler);
	assert(es == Acad::eOk);
	
	es = pFiler->writeItem(AcDb::kDxfSubclass, _T("THVDbSpace"));
	assert(es == Acad::eOk);
	
	pFiler->writeDouble(AcDb::kDxfReal, m_dAirColdLoad);
	pFiler->writeDouble(AcDb::kDxfReal+1, m_dAirHeatLoad);
	pFiler->writeDouble(AcDb::kDxfReal+2, m_dColdLoadNoAir);
	pFiler->writeDouble(AcDb::kDxfReal+3, m_dHeatLoadNoAir);
	pFiler->writeDouble(AcDb::kDxfReal+4, m_dHideColdLoad);
	pFiler->writeDouble(AcDb::kDxfReal+5, m_dSummerHumLoad);
	pFiler->writeDouble(AcDb::kDxfReal+6, m_dWinterHumLoad);

//  mcl changed by below. x64位下要求写入类型与参数code一致。否则房间对象设置标注负荷参数后，
// 选中房间会崩溃

// 	pFiler->writeDouble(AcDb::kDxfBool, m_bExtSpace);
// 	pFiler->writeDouble(AcDb::kDxfBool+1, m_bDimUnit);
// 	pFiler->writeDouble(AcDb::kDxfBool+2, m_arrayDim[0]);
// 	pFiler->writeDouble(AcDb::kDxfBool+3, m_arrayDim[1]);
// 	pFiler->writeDouble(AcDb::kDxfBool+4, m_arrayDim[2]);
// 	pFiler->writeDouble(AcDb::kDxfBool+5, m_arrayDim[3]);
// 	pFiler->writeDouble(AcDb::kDxfBool+6, m_arrayDim[4]);
// 	pFiler->writeDouble(AcDb::kDxfBool+7, m_arrayDim[5]);
// 	pFiler->writeDouble(AcDb::kDxfBool+8, m_arrayDim[6]);
// 	pFiler->writeDouble(AcDb::kDxfBool+9, m_arrayDim[7]);
// 	pFiler->writeDouble(AcDb::kDxfBool+10, m_arrayDim[8]);
// 	pFiler->writeDouble(AcDb::kDxfBool+11, m_arrayDim[9]);
// 	pFiler->writeDouble(AcDb::kDxfBool+12, m_arrayDim[10]);
// 	pFiler->writeDouble(AcDb::kDxfBool+13, m_arrayDim[11]);
	
	pFiler->writeUInt8(AcDb::kDxfInt8, m_bExtSpace);
	pFiler->writeUInt8(AcDb::kDxfInt8+1, m_bDimUnit);
	pFiler->writeUInt8(AcDb::kDxfInt8+2, m_arrayDim[0]);
	pFiler->writeUInt8(AcDb::kDxfInt8+3, m_arrayDim[1]);
	pFiler->writeUInt8(AcDb::kDxfInt8+4, m_arrayDim[2]);
	pFiler->writeUInt8(AcDb::kDxfInt8+5, m_arrayDim[3]);
	pFiler->writeUInt8(AcDb::kDxfInt8+6, m_arrayDim[4]);
	pFiler->writeUInt8(AcDb::kDxfInt8+7, m_arrayDim[5]);
	pFiler->writeUInt8(AcDb::kDxfInt8+8, m_arrayDim[6]);
	pFiler->writeUInt8(AcDb::kDxfInt8+9, m_arrayDim[7]);
	pFiler->writeUInt8(AcDb::kDxfInt8+10, m_arrayDim[8]);
	pFiler->writeUInt8(AcDb::kDxfInt8+11, m_arrayDim[9]);
	pFiler->writeUInt8(AcDb::kDxfInt8+12, m_arrayDim[10]);
	pFiler->writeUInt8(AcDb::kDxfInt8+13, m_arrayDim[11]);

	return pFiler->filerStatus();
}


//////////////////////////////////////////////////////////////////////
// 绘制
//////////////////////////////////////////////////////////////////////
Acad::ErrorStatus THVDbSpace::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
	assertReadEnabled();
	// cet 2016.10.17 add 图层关闭时，实体不显示，不进行绘制（打印时，也不会绘制）
	AcDbLayerTableRecordPointer player(this->layerId(), AcDb::kForRead);
	if (player.openStatus() == Acad::eOk && player->isOff())
	{
		return Acad::eOk;
	}
	int i(0),
		nCount(0); // 总共有多少个标注项目
	for (i = 0; i < /*12*/13; i++) // change by zh 新风量
	{
		if (m_arrayDim[i])
		{
			nCount++;
		}
	}
	
    double dSize = m_nTextHeight; // 字体高度：3
	dSize *= GetPScale();
	
	int nTmpNum = nCount/2;
	AcGeDoubleArray aryLocation; // 标注位置偏移数组
	if (nCount%2 == 0) // 偶数
	{
		for (i = 0; i < nTmpNum; i++) // 在m_ptLocation之上的部分
		{
			double dTmp = (nTmpNum-i) * 1.2 * dSize - 0.5 * dSize;
			aryLocation.append(dTmp);
		}
		for (i = 0; i < nTmpNum; i++) // 在m_ptLocation之下的部分
		{
			double dTmp = (i * 1.2 + 0.5) * dSize * (-1);
			aryLocation.append(dTmp);
		}
	}
	else // 奇数
	{
		for (i = 0; i < nTmpNum; i++) // 在m_ptLocation之上的部分
		{
			double dTmp = (nTmpNum - i) * 1.2 * dSize;
			aryLocation.append(dTmp);
		}
		aryLocation.append(0.0);      // 在m_ptLocation
		for (i = 0; i < nTmpNum; i++) // 在m_ptLocation之下的部分
		{
			double dTmp = (1 + i) * 1.2 * dSize * (-1);
			aryLocation.append(dTmp);
		}
	}
	
    TDbText text;
    text.setPropertiesFrom(this);
    text.SetMaskFlag(IsMask()); // 自动屏蔽

    AcDbObjectId idStyle = m_idTextStyle; // 字体样式：_TCH_SPACE
    assert(!!idStyle);
	
	double dTextSize = m_nTextHeight; // 字体高度：3
	text.SetHeight(dTextSize);
	text.SetStyleId(idStyle);
	text.SetAlignment(XExplodeDraw::kMiddleCenter); // 居中对齐
	text.SetRotation(m_nRotation);
	
	ads_matrix matRot;
	m_ptLocation.GetRotationMatrix(Layout2Wcs(m_nRotation), matRot);

	XStringList lstString;
	GetDimString(lstString);
	
	int j(0);
	for (i = 0; i < nCount; i++) // 需要标注的项目
	{
		XPoint ptLoc = m_ptLocation;
		ptLoc.y += aryLocation[i];
		ptLoc.TransformBy(matRot);
		text.SetLocation(ptLoc); // 确定标注位置

		XString sDisp; // 标注内容
		BOOL bFlag(TRUE); // 是否创建TDbText
		if (m_bExtSpace) // 总建筑面积
		{
			sDisp = lstString[0];
		}
		else // 普通房间
		{
			while (j < /*12*/13) // 所有标主的项目  // change by zh 新风量
			{
				if (m_arrayDim[j]) // 需要标注
				{
					sDisp = lstString[j];
					if (((j==0) || (j==1)) && (!g_bExplodeSubText) && (!sDisp))
					{
						j++;
						bFlag = FALSE; // 不标注
						break;
					}
					
					j++;
					break;
				}
				j++;
			}
		}
		
		if (bFlag) // 可以标注
		{
			text.SetText(sDisp);
			if (dc.IsFullExplode())
			{
				text.ExplodeOrDraw2d(dc);
			}
			else
			{
				dc.DrawEntity(text);
			}
		}
	}

	AcDbObjectId idMe = objectId();
	BOOL bHighlight = !idMe;
	if (!bHighlight)
	{
		bHighlight = IsHighlight();
	}

	if (bHighlight || IsShowOutline())
	{
		dc << m_outline;
	}
	return Acad::eOk;
}


// 用于分析房间对象的文字编辑
BOOL StringAnalysis(const CString &src, CString &csName)
{
	int nLen = src.GetLength();
    if (nLen == 0)
	{
        return FALSE;
	}

	for (int i = 0; i < nLen; i++)
	{
		if (src[i] == _T(':'))
		{
			csName = src.Mid(i+1, nLen-1);
			return TRUE;
		}
	}
	return FALSE;
}


void THVDbSpace::SetSubText(long i, CString sText)
{
	assertWriteEnabled();
	if (!m_bExtSpace && (i==0 || i==1)) // 普通房间的名称或编号
	{
		CString csName; // “:”号右面的内容
		BOOL bRet = StringAnalysis(sText, csName);
		if (!bRet)
		{
			return;
		}

		if (i == 0)
		{
			if (m_arrayDim[0]) // 标注的是编号
			{
				SetCode(csName);
			}
			else if (m_arrayDim[1]) // 标注的是名称
			{
				SetName(csName);
			}
		}
		else if (i == 1)
		{
			if (m_arrayDim[1]) // 标注的是名称
			{
				SetName(csName);
			}
		}
	}
}





void InitHVDbSpace(BOOL bTrue)
{
    if (bTrue)
	{
		THVDbSpace::rxInit();
		THVDbSpace::InitMatchProtocol(TRUE);
    }
	else
	{
		THVDbSpace::InitMatchProtocol(FALSE);
		deleteAcRxClass(THVDbSpace::desc());
    }
}