add two useless table.InvalidElemntNames.it will be remove later.

OTSCPP/OTSClassifyEngine/CInvalidElement.cpp

@@ -0,0 +1,100 @@
+#include "stdafx.h"
+#include "CInvalidElement.h"
+namespace OTSClassifyEngine
+{
+	using namespace OTSSQLITE;
+
+	void CInvalidElement::AddColumn(ColumnDefine col)
+	{
+		return myTable->AddColumn(col);
+	}
+
+	int CInvalidElement::GetColumnCount()
+	{
+		return myTable->GetColumnCount();
+	}
+
+	CString CInvalidElement::GetTableName()
+	{
+		return myTable->GetTableName();
+	}
+
+	void CInvalidElement::SetTableName(LPCTSTR a_sTableName)
+	{
+		return myTable->SetTableName(a_sTableName);
+	}
+
+	CString CInvalidElement::GetColumnName(const int a_nColId)
+	{
+		return myTable->GetColumnName(a_nColId);
+	}
+
+	CString CInvalidElement::GetColumnFullName(const int a_nColId)
+	{
+		return myTable->GetColumnFullName(a_nColId);
+	}
+
+	CString CInvalidElement::GetColumnNames(const BOOL a_bWithPrimary /*= TRUE*/)
+	{
+		return myTable->GetColumnNames(a_bWithPrimary);
+	}
+
+	CString CInvalidElement::GetColumnFullNames(const BOOL a_bWithPrimary /*= TRUE*/)
+	{
+		return myTable->GetColumnFullNames(a_bWithPrimary);
+	}
+
+	OTSSQLITE::ColumnType CInvalidElement::GetColumnType(const int a_nColId)
+	{
+		return myTable->GetColumnType(a_nColId);
+	}
+
+	CString CInvalidElement::GetCreateTableCommandString()
+	{
+		return myTable->GetCreateTableCommandString();
+	}
+
+	CString CInvalidElement::GetDeleteTableCommandString()
+	{
+		return myTable->GetDeleteTableCommandString();
+	}
+
+	CString CInvalidElement::GetRemoveAllRowsCommandString()
+	{
+		return myTable->GetRemoveAllRowsCommandString();
+	}
+
+	CString CInvalidElement::GetInsertCommandFormatString(const BOOL a_bWithPrimary /*= FALSE*/)
+	{
+		return myTable->GetInsertCommandFormatString(a_bWithPrimary);
+	}
+
+	CString CInvalidElement::GetInsertCommandFormatString(std::vector<int>& a_colIndexes)
+	{
+		return myTable->GetInsertCommandFormatString(a_colIndexes);
+	}
+
+	CString CInvalidElement::GetUpdateCommandFormatString(std::vector<int>& a_updateColIndexes, const int a_nConditionColIndex)
+	{
+		return myTable->GetUpdateCommandFormatString(a_updateColIndexes, a_nConditionColIndex);
+	}
+
+	CInvalidElement::CInvalidElement()
+	{
+		myTable = CreateNewSQLiteTable();
+	
+		myTable->AddColumn(std::make_pair(_T("Id"), ColumnType(ColumnType::ID::INT, TRUE)));
+		myTable->AddColumn(std::make_pair(_T("ElementName"), ColumnType(ColumnType::ID::INT, FALSE)));
+	
+
+		ASSERT(myTable->GetColumnCount() == ((int)ColumnID::MAX - (int)ColumnID::MIN) + 1);
+
+		SetTableName("InvalidElementNames");
+
+	}
+
+
+	CInvalidElement::~CInvalidElement()
+	{
+	}
+}

OTSCPP/OTSClassifyEngine/CInvalidElement.h

@@ -0,0 +1,69 @@
+#pragma once
+#include "DBTableBase.h"
+namespace OTSClassifyEngine
+{
+	using namespace OTSSQLITE;
+	class CInvalidElement : public CDBTableBase
+	{
+	public:
+		enum class ColumnID
+		{
+			INVALID = -1,
+			MIN = 0,
+			N_Id = 0,
+			S_Name = 1,			
+			MAX = 1
+		};
+
+		virtual void AddColumn(ColumnDefine col) override;
+
+
+		virtual int GetColumnCount() override;
+
+
+		virtual CString GetTableName() override;
+
+
+		virtual void SetTableName(LPCTSTR a_sTableName) override;
+
+
+		virtual CString GetColumnName(const int a_nColId) override;
+
+
+		virtual CString GetColumnFullName(const int a_nColId) override;
+
+
+		virtual CString GetColumnNames(const BOOL a_bWithPrimary = TRUE) override;
+
+
+		virtual CString GetColumnFullNames(const BOOL a_bWithPrimary = TRUE) override;
+
+
+		virtual ColumnType GetColumnType(const int a_nColId) override;
+
+
+		virtual CString GetCreateTableCommandString() override;
+
+
+		virtual CString GetDeleteTableCommandString() override;
+
+
+		virtual CString GetRemoveAllRowsCommandString() override;
+
+
+		virtual CString GetInsertCommandFormatString(const BOOL a_bWithPrimary = FALSE) override;
+
+
+		virtual CString GetInsertCommandFormatString(std::vector<int>& a_colIndexes) override;
+
+
+		virtual CString GetUpdateCommandFormatString(std::vector<int>& a_updateColIndexes, const int a_nConditionColIndex) override;
+
+	public:
+		CInvalidElement();
+		~CInvalidElement();
+	private:
+		CDBTableBasePtr myTable;
+	};
+}
+

OTSCPP/OTSClassifyEngine/CInvalidElementDB.cpp

@@ -0,0 +1,103 @@
+#include "stdafx.h"
+#include "CInvalidElement.h"
+#include "CInvalidElementDB.h"
+#include "stdafx.h"
+
+
+namespace OTSClassifyEngine
+{
+	using namespace OTSSQLITE;
+	CInvalidElementDB::CInvalidElementDB(CDBStoreBasePtr a_datastore)
+	{
+		m_tableInfo.reset(new CInvalidElement());
+		myDB = CreateNewSQLiteDB(a_datastore, m_tableInfo);
+	}
+
+	CInvalidElementDB::~CInvalidElementDB()
+	{
+	}
+
+	
+
+	std::vector<CString>& CInvalidElementDB::GetElementNameList()
+	{
+		auto tableInfoPtr = GetTableInfo();
+		ASSERT(tableInfoPtr);
+		
+
+		auto query = GetTableQuery();
+		ASSERT(query);
+		if (!query)
+		{
+			return m_eleNameList;
+		}
+
+		m_eleNameList=ReadItemList(query);
+
+		return m_eleNameList;
+	}
+
+	CDBTableBasePtr CInvalidElementDB::GetTableInfo()
+	{
+
+		return m_tableInfo;
+	}
+
+	BOOL CInvalidElementDB::Init(const BOOL a_bClean /*= FALSE*/)
+	{
+		return myDB->Init(a_bClean);
+	}
+
+
+
+	BOOL CInvalidElementDB::IsDBExist()
+	{
+		return myDB->IsDBExist();
+	}
+
+	OTSSQLITE::CDBStoreBasePtr CInvalidElementDB::GetDatastore()
+	{
+		return myDB->GetDatastore();
+	}
+
+	OTSSQLITE::CDBQueryBasePtr CInvalidElementDB::GetTableQuery(LPCTSTR a_sOrderColumnName /*= nullptr*/)
+	{
+		return myDB->GetTableQuery(a_sOrderColumnName);
+	}
+
+	
+
+	std::vector<CString> CInvalidElementDB::ReadItemList(CDBQueryBasePtr a_query)
+	{
+		std::vector<CString> listItem;
+
+		int nRowId = 0;
+		int nWrongItems = 0;
+		while (!a_query->IsEOF())
+		{
+			CString s = ReadItem(a_query);//current x-ray point		
+			
+
+			listItem.push_back(s);
+
+			a_query->NextRow();
+			nRowId++;
+		}
+
+		return listItem;
+	}
+
+	CString CInvalidElementDB::ReadItem(CDBQueryBasePtr a_query)
+	{
+		int nCol;	
+
+		CString sName;
+		nCol = (int)CInvalidElement::ColumnID::S_Name - (int)CInvalidElement::ColumnID::MIN;
+		sName = a_query->GetColStringValue(nCol, _T(""));
+		
+		return sName;
+	}
+	
+}
+
+

OTSCPP/OTSClassifyEngine/CInvalidElementDB.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "DBBase.h"
+#include "CInvalidElementDB.h"
+
+namespace OTSClassifyEngine
+{
+	using namespace OTSSQLITE;
+	class  __declspec(dllexport) CInvalidElementDB
+	{
+	public:
+		CInvalidElementDB(CDBStoreBasePtr a_datastore);
+		~CInvalidElementDB();
+
+		std::vector<CString>& GetElementNameList();
+
+		virtual CDBTableBasePtr GetTableInfo();
+
+
+		virtual BOOL Init(const BOOL a_bClean = FALSE);
+
+
+		virtual BOOL IsDBExist();
+
+
+		virtual CDBStoreBasePtr GetDatastore();
+
+
+		virtual CDBQueryBasePtr GetTableQuery(LPCTSTR a_sOrderColumnName = nullptr);
+
+	protected:
+	
+		std::vector<CString> ReadItemList(CDBQueryBasePtr a_query);
+		CString ReadItem(CDBQueryBasePtr a_query);
+	
+
+	protected:
+		CDBTableBasePtr m_tableInfo;
+	
+		std::vector<CString> m_eleNameList;
+	private:
+		CDBBasePtr myDB;
+	};
+
+	
+}
+

OTSCPP/OTSClassifyEngine/InclutionEngine/STDFileMgr.cpp

@@ -2,7 +2,6 @@
 #include "STDFileMgr.h"
 
 #include "OTSFileSys.h"
-//#include "OTSHelper.h"
 
 namespace OTSClassifyEngine {
 
@@ -274,24 +273,7 @@ namespace OTSClassifyEngine {
 				return FALSE;
 			}
 
-			//get element list
-
-			/*long nElementSize = pInfo->GetElementRange();
-
-			if (nElementSize == 0)
-			{
-				m_listSTDItem.push_back(pItem);
-				continue;
-			}*/
-
-			/*CElementRangeList listElementRange;
-			if (!GetElementRange(a_STDId, nElementSize, listElementRange))
-			{
-				LogErrorTrace(__FILE__, __LINE__, _T("GetXrayList: get x-ray data failed."));
-				return FALSE;
-			}
-
-			pItem->SetElementRangeList(listElementRange);*/
+	
 			
 			m_listSTDItem.push_back(pItem);
 		}
@@ -312,21 +294,7 @@ namespace OTSClassifyEngine {
 
 		return TRUE;
 	}
-	/*BOOL CSTDFileMgr::GetElementRange(const long a_nSTDId, const long a_nElementSize, CElementRangeList& a_listElementRange)
-	{
-		auto ElementRangeDB = GetElementRangeDB();
-		if (!ElementRangeDB)
-		{
-			LogErrorTrace(__FILE__, __LINE__, _T("Failed to open element range table"));
-			ASSERT(FALSE);
-			return FALSE;
-		}
-
-		a_listElementRange.clear();
-		a_listElementRange = ElementRangeDB->GetElementRangeListById(a_nSTDId, a_nElementSize);
 
-		return TRUE;
-	}*/
 	BOOL CSTDFileMgr::GetSTDData(const long a_nSTDId, CSTDItemPtr a_pSTDItem)
 	{
 		ASSERT(a_pSTDItem);
@@ -363,21 +331,7 @@ namespace OTSClassifyEngine {
 
 		return m_pSTDDataDB;
 	}
-	/*CElementRangeDBPtr CSTDFileMgr::GetElementRangeDB()
-	{
-		if (!m_pElementRangeDB)
-		{
-			auto datastorePtr = GetDatastore();
-			if (datastorePtr)
-			{
-				m_pElementRangeDB = std::make_shared<CElementRangeDB>(datastorePtr);
-			}
-		}
-
-		ASSERT(m_pElementRangeDB);
 
-		return m_pElementRangeDB;
-	}*/
 	
 	// cleanup 
 	void CSTDFileMgr::Cleanup()

OTSCPP/OTSClassifyEngine/OTSClassifyEngine.vcxproj

@@ -389,6 +389,8 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClInclude Include="CInvalidElement.h" />
+    <ClInclude Include="CInvalidElementDB.h" />
     <ClInclude Include="CurveCompareEngine.h" />
     <ClInclude Include="CurveCompareEngine\STDGroupDB.h" />
     <ClInclude Include="CurveCompareEngine\STDGroupTable.h" />
@@ -427,6 +429,8 @@
     <ClInclude Include="stdafx.h" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="CInvalidElement.cpp" />
+    <ClCompile Include="CInvalidElementDB.cpp" />
     <ClCompile Include="CurveCompareEngine.cpp" />
     <ClCompile Include="CurveCompareEngine\STDGroupDB.cpp" />
     <ClCompile Include="CurveCompareEngine\STDGroupTable.cpp" />

OTSCPP/OTSClassifyEngine/OTSClassifyEngine.vcxproj.filters

@@ -144,6 +144,12 @@
     <ClInclude Include="CurveCompareEngine\MultiLang.h">
       <Filter>CurveCompareEngine</Filter>
     </ClInclude>
+    <ClInclude Include="CInvalidElement.h">
+      <Filter>InclutionEngine</Filter>
+    </ClInclude>
+    <ClInclude Include="CInvalidElementDB.h">
+      <Filter>InclutionEngine</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="InclutionEngine\InclutionSTDData.cpp">
@@ -245,6 +251,12 @@
     <ClCompile Include="CurveCompareEngine\MultiLang.cpp">
       <Filter>CurveCompareEngine</Filter>
     </ClCompile>
+    <ClCompile Include="CInvalidElement.cpp">
+      <Filter>InclutionEngine</Filter>
+    </ClCompile>
+    <ClCompile Include="CInvalidElementDB.cpp">
+      <Filter>InclutionEngine</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="app.rc">

OTSIncAMeasureApp/App.config

@@ -10,8 +10,8 @@
   </startup>
   <connectionStrings>
     <add name="XMLFilePath" connectionString="Resources/XMLData/SystemData.XML"/>
-    <add name="LogAppPath" connectionString="C:\\Log\\OTSSysMgrApp"/>
-    <add name="LogPath" connectionString="C:\\Log\\OTSSysMgrApp_OTSControl"/>
+    <add name="LogAppPath" connectionString="Log\\Nlog"/>
+    <add name="LogPath" connectionString="Log\\Nlog"/>
     <add name="XMLFileName" connectionString="Config/ProData/HardwareConfig.xml"/>
   </connectionStrings>
   <nlog>

OTSIncAMeasureApp/ServiceCenter/SemController.cs

@@ -232,7 +232,7 @@ namespace OTSModelSharp.ServiceInterface
                 {
                     return false;
                 }
-                NLog.LogManager.GetCurrentClassLogger().Warn("Set WorkingDistance:" + a_distance.ToString("F2"));
+               
                 return hw.GetSemWorkingDistance(ref a_distance);
             }
         }