const void* FdoRdbmsSQLDataReader::GetGeometry(FdoInt32 index, FdoInt32* len, bool noExcOnInvalid)
{
ValidateIndex(index);
if( ! mHasMoreRows )
throw FdoCommandException::Create(NlsMsgGet(FDORDBMS_62, noMoreRows));
if (mGeomIdx != index)
{
FdoIGeometry* geom = NULL;
bool isSupportedType = false;
bool isNull = false;
mGeomIdx = index;
if (mWkbBuffer)
*mWkbBuffer = 0;
mQueryResult->GetBinaryValue (index+1, sizeof(FdoIGeometry *), (char*)&geom, &isNull, NULL);
if ( !isNull && geom && geom->GetDerivedType() != FdoGeometryType_None )
isSupportedType = true;
if ( !isNull && geom != NULL )
{
if ( isSupportedType )
{
FdoPtr<FdoFgfGeometryFactory> gf = FdoFgfGeometryFactory::GetInstance();
FdoPtr<FdoByteArray> fgf = gf->GetFgf(geom);
if (fgf != NULL && fgf->GetCount() != 0)
{
mWkbGeomLen = fgf->GetCount();
if (mWkbBufferLen < mWkbGeomLen)
{
delete[] mWkbBuffer;
mWkbBufferLen = mWkbGeomLen;
mWkbBuffer = new unsigned char[mWkbGeomLen];
}
memcpy(mWkbBuffer, fgf->GetData(), mWkbGeomLen);
}
else
mWkbGeomLen = 0;
}
else
mWkbGeomLen = -1;
}
else // isNull indicator is not set by dbi_get_val_b for geometry columns
mWkbGeomLen = 0;
}
*len = mWkbGeomLen;
if (*len <= 0)
{
if (noExcOnInvalid)
return NULL;
else if (*len == 0)
throw FdoCommandException::Create(NlsMsgGet1( FDORDBMS_385, "Property '%1$ls' value is NULL; use IsNull method before trying to access the property value", mColList[index].column ));
else
throw FdoCommandException::Create( NlsMsgGet(FDORDBMS_116, "Unsupported geometry type" ) );
}
return mWkbBuffer;
}
MgByteReader* MgdSqlDataReader::GetCLOB(CREFSTRING propertyName)
{
Ptr<MgByteReader> clob;
MG_FEATURE_SERVICE_TRY()
FdoPtr<FdoLOBValue> fdoVal = m_reader->GetLOB(propertyName.c_str());
if (fdoVal != NULL)
{
FdoPtr<FdoByteArray> byteArray = fdoVal->GetData();
if (byteArray != NULL)
{
FdoByte* bytes = byteArray->GetData();
FdoInt32 len = byteArray->GetCount();
Ptr<MgByteSource> byteSource = new MgByteSource((BYTE_ARRAY_IN)bytes,(INT32)len);
clob = byteSource->GetReader();
}
}
MG_FEATURE_SERVICE_CATCH_AND_THROW(L"MgdSqlDataReader::GetCLOB")
return clob.Detach();
}
const FdoByte * FdoXmlFeatureReaderImpl::GetGeometry(FdoString* propertyName, FdoInt32 * count)
{
FdoByte* data = NULL;
FdoPtr<FdoByteArray> ba = this->GetGeometry(propertyName);
if (NULL != ba.p)
{
data = ba->GetData();
*count = ba->GetCount();
}
return data;
}
/// <summary>Gets the geometry value of the specified property as a byte array in
/// FGF format. Because no conversion is performed, the property must be
/// of Geometric type; otherwise, an exception is thrown.
/// This method is a language-specific performance optimization that returns a
/// pointer to the array data, rather than to an object that encapsulates
/// the array. The array's memory area is only guaranteed to be valid
/// until a call to ReadNext() or Close(), or the disposal of this reader
/// object.</summary>
/// <param name="identifier">Input the property name.</param>
/// <param name="count">Output the number of bytes in the array.</param>
/// <returns>Returns a pointer to the byte array in FGF format.</returns>
const FdoByte* SuperMapFeatureReader::GetGeometry (FdoString* identifier, FdoInt32 * count)
{
FdoPtr<FdoByteArray> byteArray = GetGeometry (identifier);
if(NULL == byteArray)
{
return NULL;
}
FdoByte *ret = byteArray->GetData();
*count = byteArray->GetCount();
return ret;
}
FdoBoolean FdoXmlFeatureReaderImpl::FeatureEndLobProperty(FdoXmlFeatureContext*)
{
m_blobBuffer->Reset();
FdoPtr<FdoByteArray> data = FdoByteArray::Create((FdoInt32)m_blobBuffer->GetLength());
FdoSize szRead = m_blobBuffer->Read(data->GetData(), (FdoInt32)m_blobBuffer->GetLength());
FdoByteArray::SetSize(data.p, (FdoInt32)szRead);
FdoPtr<FdoBLOBValue> blobValue = FdoBLOBValue::Create(data);
FdoPtr<FdoXmlBLOBProperty> blobProp = FdoXmlBLOBProperty::Create(m_blobPropertyName, blobValue);
m_blobProperties->Add(blobProp);
m_blobBuffer = NULL;
m_blobPropertyName = L"";
return false;
}
MgByteReader* MgdSqlDataReader::GetLOB(CREFSTRING propertyName)
{
Ptr<MgByteReader> byteReader;
try
{
// TODO: We need to switch to FdoIStreamReader when we have streaming capability in MgByteReader
FdoPtr<FdoLOBValue> fdoVal = m_reader->GetLOB(propertyName.c_str());
if (fdoVal != NULL)
{
FdoPtr<FdoByteArray> byteArray = fdoVal->GetData();
if (byteArray != NULL)
{
FdoByte* bytes = byteArray->GetData();
FdoInt32 len = byteArray->GetCount();
Ptr<MgByteSource> byteSource = new MgByteSource((BYTE_ARRAY_IN)bytes,(INT32)len);
// TODO: We need to differentiate between CLOB and BLOB
// TODO: How do we fine the MimeType of data for CLOB
byteSource->SetMimeType(MgMimeType::Binary);
byteReader = byteSource->GetReader();
}
}
}
catch(...)
{
if(m_reader->IsNull(propertyName.c_str()))
{
MgStringCollection arguments;
arguments.Add(propertyName);
throw new MgNullPropertyValueException(L"MgdSqlDataReader::GetLOB",
__LINE__, __WFILE__, &arguments, L"", NULL);
}
else
throw;
}
return byteReader.Detach();
}
MgByteReader* MgdSqlDataReader::GetGeometry(CREFSTRING propertyName)
{
Ptr<MgByteReader> geom;
MG_FEATURE_SERVICE_TRY()
FdoPtr<FdoByteArray> byteArray = m_reader->GetGeometry(propertyName.c_str());
INT32 len = (INT32)byteArray->GetCount();
const FdoByte* data = byteArray->GetData();
if (data != NULL)
{
Ptr<MgByte> mgBytes = new MgByte((BYTE_ARRAY_IN)data, len);
Ptr<MgByteSource> bSource = new MgByteSource(mgBytes);
bSource->SetMimeType(MgMimeType::Agf);
geom = bSource->GetReader();
}
MG_FEATURE_SERVICE_CATCH_AND_THROW(L"MgdSqlDataReader::GetGeometry")
return geom.Detach();
}
void SuperMapSelectTest::select_sdb_date()
{
CPPUNIT_ASSERT_MESSAGE("FDO连接未打开!", m_connection != NULL);
CPPUNIT_ASSERT_MESSAGE("FDO连接引用次数不为1!", m_connection->GetRefCount() == 1);
FdoPtr<FdoISelect> Select;
Select = (FdoISelect *)m_connection->CreateCommand(FdoCommandType_Select);
if(Select)
{
Select->SetFeatureClassName(L"面");
FdoString *strFilter = L"TestDate <= TIMESTAMP '2007-12-12 00:00:00'";
Select->SetFilter( strFilter );
FdoPtr<FdoIFeatureReader> ret;
try
{
ret = Select->Execute();
}
catch (FdoException* ex)
{
FdoException* nex = ex;
while (nex)
{
AfxMessageBox(ex->GetExceptionMessage());
nex = nex->GetCause();
}
ex->Release();
}
catch(...)
{
CPPUNIT_FAIL("unresolved exception");
}
CPPUNIT_ASSERT_MESSAGE("返回的要素集合为空!", ret != NULL);
int count = 0;
int SmID;
int UserID;
FdoDateTime Date;
FdoPtr<FdoByteArray> geometry;
try
{
while (ret->ReadNext ())
{
count++;
if(!ret->IsNull(L"SmID"))
{
SmID = ret->GetInt32 (L"SmID");
}
if(!ret->IsNull(L"SmUserID"))
{
UserID = ret->GetInt32 (L"SmUserID");
}
if(!ret->IsNull(L"TestDate"))
{
Date = ret->GetDateTime (L"TestDate");
}
if(!ret->IsNull(L"Geometry"))
{
geometry = ret->GetGeometry (L"Geometry");
}
CPPUNIT_ASSERT_MESSAGE ("几何对象类型不正确", FdoGeometryType_Polygon == *(int*)geometry->GetData());
}
CPPUNIT_ASSERT_MESSAGE ("未查出面数据集中的要素", 0 != count);
}
catch (FdoException* ex)
{
FdoException* nex = ex;
while (nex)
{
AfxMessageBox(ex->GetExceptionMessage());
nex = nex->GetCause();
}
ex->Release();
}
}
}
void SuperMapSelectTest::select_region()
{
CPPUNIT_ASSERT_MESSAGE("FDO连接未打开!", m_connection != NULL);
CPPUNIT_ASSERT_MESSAGE("FDO连接引用次数不为1!", m_connection->GetRefCount() == 1);
FdoPtr<FdoISelect> Select;
Select = (FdoISelect *)m_connection->CreateCommand(FdoCommandType_Select);
Select->SetFeatureClassName(L"面");
FdoPtr<FdoIFeatureReader> ret;
try
{
ret = Select->Execute();
}
catch (FdoException* ex)
{
FdoException* nex = ex;
while (nex)
{
AfxMessageBox(ex->GetExceptionMessage());
nex = nex->GetCause();
}
ex->Release();
}
catch(...)
{
CPPUNIT_FAIL("unresolved exception");
}
CPPUNIT_ASSERT_MESSAGE("返回的要素集合为空!", ret != NULL);
int count = 0;
int SmID;
int UserID;
double SmArea;
double SmPerimeter;
bool TestBoolen;
short TestShort;
float TestFloat;
FdoString *str;
FdoDateTime date;
int length;
FdoPtr<FdoByteArray> geometry;
try
{
while (ret->ReadNext ())
{
count++;
if(!ret->IsNull(L"SmID"))
{
SmID = ret->GetInt32 (L"SmID");
}
if(!ret->IsNull(L"SmUserID"))
{
UserID = ret->GetInt32 (L"SmUserID");
}
if(!ret->IsNull(L"SmArea"))
{
SmArea = ret->GetDouble (L"SmArea");
}
if(!ret->IsNull(L"SmPerimeter"))
{
SmPerimeter = ret->GetDouble (L"SmPerimeter");
}
if(!ret->IsNull(L"TestBoolen"))
{
TestBoolen = ret->GetBoolean (L"TestBoolen");
}
if(!ret->IsNull(L"TestShort"))
{
TestShort = ret->GetInt16(L"TestShort");
}
if(!ret->IsNull(L"TestFloat"))
{
TestFloat = ret->GetSingle(L"TestFloat");
}
if(!ret->IsNull(L"TestString"))
{
str = ret->GetString(L"TestString");
}
if(!ret->IsNull(L"TestDate"))
{
date = ret->GetDateTime(L"TestDate");
}
if(!ret->IsNull(L"长度"))
{
length = ret->GetInt32(L"长度");
}
if(!ret->IsNull(L"Geometry"))
{
geometry = ret->GetGeometry (L"Geometry");
}
CPPUNIT_ASSERT_MESSAGE ("几何对象类型不正确", FdoGeometryType_Polygon == *(int*)geometry->GetData());
}
CPPUNIT_ASSERT_MESSAGE ("未查出面数据集中的要素", 0 != count);
}
catch (FdoException* ex)
{
FdoException* nex = ex;
while (nex)
{
AfxMessageBox(ex->GetExceptionMessage());
nex = nex->GetCause();
}
ex->Release();
}
catch(...)
{
CPPUNIT_FAIL("unresolved exception");
}
}
void SuperMapSelectTest::select_line()
{
CPPUNIT_ASSERT_MESSAGE("FDO连接未打开!", m_connection != NULL);
CPPUNIT_ASSERT_MESSAGE("FDO连接引用次数不为1!", m_connection->GetRefCount() == 1);
FdoPtr<FdoISelect> Select;
Select = (FdoISelect *)m_connection->CreateCommand(FdoCommandType_Select);
Select->SetFeatureClassName(L"线");
FdoPtr<FdoIFeatureReader> ret;
try
{
ret = Select->Execute();
}
catch (FdoException* ex)
{
FdoException* nex = ex;
while (nex)
{
AfxMessageBox(ex->GetExceptionMessage());
nex = nex->GetCause();
}
ex->Release();
}
catch(...)
{
CPPUNIT_FAIL("unresolved exception");
}
CPPUNIT_ASSERT_MESSAGE("返回的要素集合为空!", ret != NULL);
int count = 0;
int SmID;
int UserID;
double Length;
int ToPoError;
FdoPtr<FdoByteArray> geometry;
try
{
while (ret->ReadNext ())
{
count++;
if(!ret->IsNull(L"SmID"))
{
SmID = ret->GetInt32 (L"SmID");
}
if(!ret->IsNull(L"SmUserID"))
{
UserID = ret->GetInt32 (L"SmUserID");
}
if(!ret->IsNull(L"SmLength"))
{
Length = ret->GetDouble (L"SmLength");
}
if(!ret->IsNull(L"SmTopoError"))
{
ToPoError = ret->GetInt32 (L"SmTopoError");
}
if(!ret->IsNull(L"Geometry"))
{
geometry = ret->GetGeometry (L"Geometry");
}
CPPUNIT_ASSERT_MESSAGE ("几何对象类型不正确", FdoGeometryType_MultiLineString == *(int*)geometry->GetData());
}
CPPUNIT_ASSERT_MESSAGE ("未查出点数据集中的要素", 0 != count);
}
catch (FdoException* ex)
{
FdoException* nex = ex;
while (nex)
{
AfxMessageBox(ex->GetExceptionMessage());
nex = nex->GetCause();
}
ex->Release();
}
catch(...)
{
CPPUNIT_FAIL("unresolved exception");
}
}
void SQLTests::query ()
{
if (CreateSchemaOnly()) return;
try
{
FdoPtr<FdoISQLCommand> sqlCmd = (FdoISQLCommand*)mConnection->CreateCommand (FdoCommandType_SQLCommand);
// Clean up previous tests (ignore exceptions, we'll get one if the table doesn't actually exist):
try
{
sqlCmd->SetSQLStatement (L"drop table bar");
sqlCmd->ExecuteNonQuery ();
}
catch (FdoException *e)
{
e->Release();
}
// Execute various tests:
sqlCmd->SetSQLStatement (ArcSDETestConfig::SqlStmtCreateTable());
sqlCmd->ExecuteNonQuery ();
sqlCmd->SetSQLStatement (ArcSDETestConfig::SqlStmtInsert1());
sqlCmd->ExecuteNonQuery ();
sqlCmd->SetSQLStatement (L"select * from bar");
{
FdoPtr<FdoISQLDataReader> reader = sqlCmd->ExecuteReader ();
// Test accessing SQLDataReader's metadata BEFORE calling ReadNext():
IterateSQLDataReaderProperties(reader);
reader->ReadNext ();
CPPUNIT_ASSERT_MESSAGE ("int16 wrong", 42 == reader->GetInt16 (L"ID"));
CPPUNIT_ASSERT_MESSAGE ("int32 wrong", 8272772 == reader->GetInt32 (L"COUNT"));
float x = (float)reader->GetSingle (L"SCALE");
float diff = x - 1e-2f;
if (0 > diff)
diff = -diff;
CPPUNIT_ASSERT_MESSAGE ("float wrong", 1e-9 > diff);
double y = reader->GetDouble (L"LENGTH");
double difference = y - 10280288.29929;
if (0 > difference)
difference = -difference;
CPPUNIT_ASSERT_MESSAGE ("double wrong", 1e-4 > difference);
CPPUNIT_ASSERT_MESSAGE ("string wrong", 0 == wcscmp (L"the quick brown fox jumps over a lazy dog", reader->GetString(L"DESCRIPTION")));
FdoPtr<FdoBLOBValue> blobValue = static_cast<FdoBLOBValue*>(reader->GetLOB(L"DATA"));
FdoByteArray* data = blobValue->GetData();
FdoByte test[] = { 0x25, 0x2f, 0x82, 0xe3 };
for (int i = 0; i < data->GetCount (); i++)
CPPUNIT_ASSERT_MESSAGE ("blob wrong", test[i] == (*data)[i]);
data->Release ();
FdoDateTime now = reader->GetDateTime (L"MODIFIED");
struct tm systime;
#ifdef _WIN32
#pragma warning(disable : 4996)
_getsystime (&systime);
#pragma warning(default : 4996)
#else
time_t current;
time (¤t);
localtime_r (¤t, &systime);
#endif
CPPUNIT_ASSERT_MESSAGE ("year wrong (NOTE: THIS IS MAY BE CAUSED BY TIME ZONE DIFFERENCE BETWEEN SERVER AND CLIENT MACHINES)", now.year == systime.tm_year + 1900);
CPPUNIT_ASSERT_MESSAGE ("month wrong (NOTE: THIS IS MAY BE CAUSED BY TIME ZONE DIFFERENCE BETWEEN SERVER AND CLIENT MACHINES)", now.month == systime.tm_mon + 1);
CPPUNIT_ASSERT_MESSAGE ("day wrong (NOTE: THIS IS OFTEN CAUSED BY TIME ZONE DIFFERENCE BETWEEN SERVER AND CLIENT MACHINES)", now.day == systime.tm_mday);
//THE FOLLOWING TEST FAILS FREQUENTLY, SINCE THE CLIENT'S TIME AND SERVER'S TIME ARE USUALLY NOT IN SYNC:
//CPPUNIT_ASSERT_MESSAGE ("hour wrong", now.hour == systime.tm_hour);
}
// Test aggregate functions in select clause:
sqlCmd->SetSQLStatement (ArcSDETestConfig::SqlStmtInsert2());
sqlCmd->ExecuteNonQuery ();
sqlCmd->SetSQLStatement (L"select count(*) from bar");
FdoPtr<FdoISQLDataReader> reader = sqlCmd->ExecuteReader();
CPPUNIT_ASSERT_MESSAGE("Expected 1 row, got 0 rows instead.", reader->ReadNext ());
FdoInt32 colCount = reader->GetColumnCount();
CPPUNIT_ASSERT_MESSAGE ("column count wrong", colCount == 1);
FdoString *colName = reader->GetColumnName(0);
CPPUNIT_ASSERT_MESSAGE ("column name wrong", 0==FdoCommonOSUtil::wcsicmp(colName, ArcSDETestConfig::SqlCountStarColumnName()));
FdoDataType colType = reader->GetColumnType(colName);
if (colType==FdoDataType_Int32)
{
FdoInt32 iRowCount = reader->GetInt32(colName);
CPPUNIT_ASSERT_MESSAGE("count(*) value wrong", iRowCount == 2);
}
else if (colType==FdoDataType_Double)
{
double dRowCount = reader->GetDouble(colName);
CPPUNIT_ASSERT_MESSAGE("count(*) value wrong", dRowCount == 2);
}
CPPUNIT_ASSERT_MESSAGE("Expected 1 row, got 2 or more rows instead.", !reader->ReadNext ());
// Test functions in where clause:
sqlCmd->SetSQLStatement (ArcSDETestConfig::SqlStmtAggrQuery1());
reader = sqlCmd->ExecuteReader();
CPPUNIT_ASSERT_MESSAGE("Expected 1 row, got 0 rows instead.", reader->ReadNext ());
colCount = reader->GetColumnCount();
CPPUNIT_ASSERT_MESSAGE ("column count wrong", colCount == 1);
colName = reader->GetColumnName(0);
CPPUNIT_ASSERT_MESSAGE ("column name wrong", 0==FdoCommonOSUtil::wcsicmp(colName, ArcSDETestConfig::SqlAggrColumnName()));
colType = reader->GetColumnType(colName);
CPPUNIT_ASSERT_MESSAGE ("column type wrong", colType==FdoDataType_Double);
double dResult = reader->GetDouble(colName);
CPPUNIT_ASSERT_MESSAGE("ABS(SUM(length)) value wrong", ArcSDETests::fuzzyEqual(dResult, ArcSDETestConfig::SqlStmtAggrQuery1Result()));
CPPUNIT_ASSERT_MESSAGE("Expected 1 row, got 2 or more rows instead.", !reader->ReadNext ());
// Clean up:
sqlCmd->SetSQLStatement (L"drop table bar");
sqlCmd->ExecuteNonQuery ();
}
catch (FdoException *e)
{
fail(e);
}
}
MgSpatialContextData* MgServerGetSpatialContexts::GetSpatialContextData(
FdoISpatialContextReader* spatialReader, MgSpatialContextInfo* spatialContextInfo)
{
Ptr<MgSpatialContextData> spatialData = new MgSpatialContextData();
// Name must exist
FdoString* name = spatialReader->GetName();
CHECKNULL((FdoString*)name, L"MgServerGetSpatialContexts.GetSpatialContexts");
spatialData->SetName(STRING(name));
STRING coordSysName = L"";
FdoString* csName = spatialReader->GetCoordinateSystem();
Ptr<MgCoordinateSystemFactory> csFactory;
// WKT for co-ordinate system
FdoString* csWkt = NULL;
STRING srsWkt = L"";
bool haveValidCoordSys = false;
if(NULL != csName && *csName != '\0')
{
coordSysName = STRING(csName);
}
else
{
csWkt = spatialReader->GetCoordinateSystemWkt();
if (csWkt != NULL && *csWkt != '\0')
{
srsWkt = csWkt;
try
{
csFactory = new MgCoordinateSystemFactory();
coordSysName = csFactory->ConvertWktToCoordinateSystemCode(srsWkt);
haveValidCoordSys = (coordSysName.size() != 0);
}
catch (MgException* e)
{
SAFE_RELEASE(e);
}
catch(...)
{
}
}
}
bool spatialContextDefined = !coordSysName.empty();
bool coordSysOverridden = false;
// look for coordinate system override
if (NULL != spatialContextInfo)
{
// Perform substitution of missing coordinate system with
// the spatial context mapping defined in feature source document
MgSpatialContextInfo::const_iterator iter = spatialContextInfo->find(name);
if (spatialContextInfo->end() != iter)
{
csName = (iter->second).c_str();
coordSysOverridden = true;
}
}
if (csName != NULL && *csName != '\0')
{
spatialData->SetCoordinateSystem(STRING(csName));
}
// Desc for spatial context
STRING desc = L"";
// This flag is obsolete and will be deprecated.
bool isActive = spatialReader->IsActive();
if (coordSysOverridden)
{
srsWkt = csName;
desc = MgServerFeatureUtil::GetMessage(L"MgCoordinateSystemOverridden");
}
else if (spatialContextDefined && !coordSysOverridden)
{
// avoid looking one more time after CS in case we have a valid one...
if (!haveValidCoordSys)
{
csWkt = spatialReader->GetCoordinateSystemWkt();
if(NULL != csWkt && *csWkt != '\0')
srsWkt = csWkt;
if (srsWkt.empty())
{
try
{
if (csFactory == NULL)
csFactory = new MgCoordinateSystemFactory();
// Check if the spatial context coordinate system data represents an EPSG
// code. If this is the case the WKT data for the EPSG code has to be
// retrieved.
if (IsEpsgCodeRepresentation(csName))
{
// This is an EPSG code
FdoString* p = NULL;
if ((csName[0] == L'E') || (csName[0] == L'e'))
p = csName+5;
else
p = csName;
INT32 epsgCode = (INT32)wcstol(p, NULL, 10);
// Convert the EPSG numerical code to WKT
srsWkt = csFactory->ConvertEpsgCodeToWkt(epsgCode);
}
else
{
srsWkt = csFactory->ConvertCoordinateSystemCodeToWkt(STRING(csName));
}
}
catch (MgException* e)
{
SAFE_RELEASE(e);
}
catch(...)
{
// Just use the empty WKT.
}
}
}
FdoString* fdoDesc = spatialReader->GetDescription();
if(NULL != fdoDesc)
desc = STRING(fdoDesc);
}
// retrieve other values from spatialReader
FdoSpatialContextExtentType extentType = spatialReader->GetExtentType();
FdoPtr<FdoByteArray> byteArray = spatialReader->GetExtent();
double xyTol = spatialReader->GetXYTolerance();
double zTol = spatialReader->GetZTolerance();
spatialData->SetCoordinateSystemWkt(srsWkt);
spatialData->SetDescription(desc);
spatialData->SetExtentType((INT32)extentType);
if (byteArray.p != NULL)
{
INT32 size = (INT32)byteArray->GetCount();
BYTE_ARRAY_IN bytes = (BYTE_ARRAY_IN)byteArray->GetData();
Ptr<MgByte> extent = new MgByte(bytes, size);
spatialData->SetExtent(extent);
}
// XY Tolerance
spatialData->SetXYTolerance(xyTol);
// Z Tolerance
spatialData->SetZTolerance(zTol);
// This flag is obsolete and will be deprecated.
spatialData->SetActiveStatus(isActive);
return spatialData.Detach();
}
void GwsBinaryFeatureWriter::WriteProperty(FdoPropertyDefinition* pd, FdoIFeatureReader* reader)
{
FdoDataPropertyDefinition* dpd = NULL;
if (pd->GetPropertyType() == FdoPropertyType_DataProperty)
dpd = (FdoDataPropertyDefinition*)pd;
FdoString* name = pd->GetName();
if (reader->IsNull(name))
{
//do not write anything if the reader does not have
//data for this property
//TODO: should we write the default property value instead?
return;
}
if (dpd)
{
switch (dpd->GetDataType())
{
case FdoDataType_Boolean :
m_wrtr.WriteByte(reader->GetBoolean(name) ? 1 : 0);
break;
case FdoDataType_Byte :
m_wrtr.WriteByte(reader->GetByte(name));
break;
case FdoDataType_DateTime :
m_wrtr.WriteDateTime(reader->GetDateTime(name));
break;
case FdoDataType_Decimal :
m_wrtr.WriteDouble(reader->GetDouble(name));
break;
case FdoDataType_Double :
m_wrtr.WriteDouble(reader->GetDouble(name));
break;
case FdoDataType_Int16 :
m_wrtr.WriteInt16(reader->GetInt16(name));
break;
case FdoDataType_Int32 :
m_wrtr.WriteInt32(reader->GetInt32(name));
break;
case FdoDataType_Int64 :
m_wrtr.WriteInt64(reader->GetInt64(name));
break;
case FdoDataType_Single :
m_wrtr.WriteSingle(reader->GetSingle(name));
break;
case FdoDataType_String :
m_wrtr.WriteRawString(reader->GetString(name));
break;
case FdoDataType_BLOB :
case FdoDataType_CLOB :
default:
GWS_THROW(eGwsNotSupported);
}
}
else
{
//we have a geometric property
FdoPtr<FdoByteArray> byteArray = reader->GetGeometry(name);
//Note we do not need to write the length of a byte array since we know it
//by subtracting the offsets into property values in the data record
if (byteArray)
m_wrtr.WriteBytes(byteArray->GetData(), byteArray->GetCount());
}
}
void GwsBinaryFeatureWriter::WriteProperty(FdoPropertyDefinition* pd, FdoPropertyValue* pv,
bool forAssociation)
{
FdoDataPropertyDefinition* dpd = NULL;
FdoPtr<FdoValueExpression> expression;
if (pd->GetPropertyType() == FdoPropertyType_DataProperty)
dpd = (FdoDataPropertyDefinition*)pd;
if (pv == NULL)
{
//if the property value is NULL, do not write anything to the data record
//the default value will be used if later the user asks for the value
//of this porperty
//TODO: should we write the default property value instead?
return;
}
expression = pv->GetValue();
if (dpd)
{
FdoDataValue* dv = (FdoDataValue*)expression.p;
if(dv == NULL || dv->IsNull())
return;
switch (dpd->GetDataType())
{
case FdoDataType_Boolean :
m_wrtr.WriteByte(((FdoBooleanValue*)(expression.p))->GetBoolean() ? 1 : 0);
break;
case FdoDataType_Byte :
m_wrtr.WriteByte(((FdoByteValue*)(expression.p))->GetByte());
break;
case FdoDataType_DateTime :
m_wrtr.WriteDateTime(((FdoDateTimeValue*)(expression.p))->GetDateTime());
break;
case FdoDataType_Decimal :
m_wrtr.WriteDouble(((FdoDecimalValue*)(expression.p))->GetDecimal());
break;
case FdoDataType_Double :
m_wrtr.WriteDouble(((FdoDoubleValue*)(expression.p))->GetDouble());
break;
case FdoDataType_Int16 :
m_wrtr.WriteInt16(((FdoInt16Value*)(expression.p))->GetInt16());
break;
case FdoDataType_Int32 :
m_wrtr.WriteInt32(((FdoInt32Value*)(expression.p))->GetInt32());
break;
case FdoDataType_Int64 :
m_wrtr.WriteInt64(((FdoInt64Value*)(expression.p))->GetInt64());
break;
case FdoDataType_Single :
m_wrtr.WriteSingle(((FdoSingleValue*)(expression.p))->GetSingle());
break;
case FdoDataType_String :
if( ! forAssociation )
m_wrtr.WriteRawString(((FdoStringValue*)(expression.p))->GetString());
else
m_wrtr.WriteString(((FdoStringValue*)(expression.p))->GetString());
break;
case FdoDataType_BLOB :
case FdoDataType_CLOB :
default:
GWS_THROW(eGwsNotSupported);
}
}
else
{
//we have a geometric property
FdoPtr<FdoByteArray> byteArray = ((FdoGeometryValue*)(expression.p))->GetGeometry();
//Note we do not need to write the length of a byte array since we know it
//by subtracting the offsets into property values in the data record
if (byteArray)
m_wrtr.WriteBytes(byteArray->GetData(), byteArray->GetCount());
}
}
FdoICurveSegmentAbstract* FgfUtil::ReadCurveSegment(
FdoFgfGeometryFactory * factory,
FdoInt32 dimensionality,
FdoIDirectPosition* startPos,
const FdoByte ** inputStream,
const FdoByte * streamEnd)
{
//
// Reads CurveSegment positions and creates a new
// CurveString using the startPos passed followed by positions
// read from the reader. In this manner it creates and returns a
// complete curveSeg with all of its positions (unlike its fgf
// counterpart that has its startPos stored as last position of
// immediately previous curveSeg.
//
// It is assumed that reader is currently pointing at beginning
// of CurveSeg.
//
FdoGeometryComponentType geomType = (FdoGeometryComponentType)ReadInt32(inputStream, streamEnd);
FdoPtr<FdoICurveSegmentAbstract> curveSeg;
switch (geomType)
{
case FdoGeometryComponentType_CircularArcSegment:
{
FdoPtr<FdoIDirectPosition> midPos = ReadDirectPosition(factory, dimensionality, inputStream, streamEnd);
FdoPtr<FdoIDirectPosition> endPos = ReadDirectPosition(factory, dimensionality, inputStream, streamEnd);
curveSeg = factory->CreateCircularArcSegment(startPos, midPos, endPos);
break;
}
case FdoGeometryComponentType_LineStringSegment:
{
FdoInt32 numPositions = ReadInt32(inputStream, streamEnd);
FdoInt32 numOrdsPerPos = GeometryUtility::DimensionalityToNumOrdinates(dimensionality);
FdoInt32 numOrds = (numPositions+1) * numOrdsPerPos;
FdoPtr<FdoDoubleArray> da = FdoDoubleArray::Create(numOrds);
double * ordinates = da->GetData();
double * currentOrdinates = ordinates;
const double * positionOrdinates = startPos->GetOrdinates();
// add the startPos
for (FdoInt32 i=0; i < numOrdsPerPos; i++)
*currentOrdinates++ = *positionOrdinates++;
// Now add remaining positions
numOrds -= numOrdsPerPos; // Adjust for already having start position.
FGFUTIL_STREAM_CHECK(inputStream, streamEnd, numOrds * sizeof(double));
positionOrdinates = (const double *) *inputStream;
for (FdoInt32 i=0; i < numOrds; i++)
*currentOrdinates++ = *positionOrdinates++;
*inputStream += numOrds * sizeof(double);
numOrds += numOrdsPerPos; // Adjust for start position + remaining ones.
curveSeg = factory->CreateLineStringSegment(dimensionality, numOrds, ordinates);
break;
}
default:
{
throw FdoException::Create(FdoException::NLSGetMessage(FDO_NLSID(FDO_1_UNKNOWN_GEOMETRY_COMPONENT_TYPE),
L"FgfUtil::ReadCurveSegment",
geomType));
}
} // of switch
return FDO_SAFE_ADDREF(curveSeg.p);
}
void RfpTestRasterConversion::testRgbToPalette()
{
// change the data model and tile size
FdoPtr<FdoRasterDataModel> dataModel = m_raster->GetDataModel();
dataModel->SetDataModelType(FdoRasterDataModelType_Palette);
dataModel->SetBitsPerPixel(8);
dataModel->SetTileSizeX(256);
dataModel->SetTileSizeY(256);
try
{
m_raster->SetDataModel(dataModel);
}
catch(FdoException*){/* Ok, expected exception was caught.*/}
catch(...) { CPPUNIT_ASSERT_MESSAGE ("FdoException expected but got none.", false); }
#ifdef notdef
// this might be useful later when palette support is implemented.
// get the palette
FdoPtr<FdoIRasterPropertyDictionary> propDict = m_raster->GetAuxiliaryProperties();
FdoPtr<FdoDataValue> pal = propDict->GetProperty(L"Palette");
CPPUNIT_ASSERT(pal->GetDataType() == FdoDataType_BLOB);
FdoLOBValue* palLOB = static_cast<FdoLOBValue*>(pal.p);
struct RgbColor
{
union {
struct { FdoByte red; FdoByte green; FdoByte blue; FdoByte alpha; } rgba;
FdoInt32 packed;
};
};
FdoPtr<FdoByteArray> palArray = palLOB->GetData();
RgbColor* palette = reinterpret_cast<RgbColor*>(palArray->GetData());
FdoPtr<FdoDataValue> num = propDict->GetProperty(L"NumOfPaletteEntries");
FdoInt32Value* numInt32 = static_cast<FdoInt32Value*>(num.p);
FdoInt32 numEntries = numInt32->GetInt32();
CPPUNIT_ASSERT(numEntries == 61);
// get the data
FdoIStreamReader * streamReader = m_raster->GetStreamReader();
FdoPtr<FdoIStreamReaderTmpl<FdoByte> > reader = static_cast<FdoIStreamReaderTmpl<FdoByte>*>(streamReader);
// read the strips (black, red, green, blue, white)
FdoInt32 pixelInStrip[] = {0x00000000, 0x000000ff, 0x0000ff00, 0x00ff0000, 0x00ffffff};
for (int strip = 0; strip < 5; strip++)
{
// read the data pixel by pixel
for (int row = 0; row < 40; row++)
{
for (int i = 0; i < 200; i++)
{
FdoByte pal;
reader->ReadNext(&pal, 0, 1);
FdoInt32 pixel = palette[pal].packed;
FdoInt32 colorDiff = (FdoInt32)RGB_COLOR_DIFF(pixel, pixelInStrip[strip]);
CPPUNIT_ASSERT(colorDiff < 209);
}
reader->Skip(56);
}
}
reader->Skip(56 * 256);
// there is no data left
FdoByte dummy;
CPPUNIT_ASSERT(reader->ReadNext(&dummy, 0, 1) == 0);
#endif
}