Add C# wrapper (#60)

AnnService/CoreLibrary.vcxproj

@@ -149,6 +149,7 @@
     <ClInclude Include="inc\Core\DefinitionList.h" />
     <ClInclude Include="inc\Core\MetadataSet.h" />
     <ClInclude Include="inc\Core\SearchQuery.h" />
+    <ClInclude Include="inc\Core\SearchResult.h" />
     <ClInclude Include="inc\Core\VectorIndex.h" />
     <ClInclude Include="inc\Core\VectorSet.h" />
     <ClInclude Include="inc\Helper\ArgumentsParser.h" />
@@ -167,7 +168,6 @@
     <ClCompile Include="src\Core\Common\NeighborhoodGraph.cpp" />
     <ClCompile Include="src\Core\KDT\KDTIndex.cpp" />
     <ClCompile Include="src\Core\Common\WorkSpacePool.cpp" />
-    <ClCompile Include="src\Core\CommonDataStructure.cpp" />
     <ClCompile Include="src\Core\MetadataSet.cpp" />
     <ClCompile Include="src\Core\VectorIndex.cpp" />
     <ClCompile Include="src\Core\VectorSet.cpp" />

AnnService/CoreLibrary.vcxproj.filters

@@ -52,6 +52,9 @@
     <ClInclude Include="inc\Core\SearchQuery.h">
       <Filter>Header Files\Core</Filter>
     </ClInclude>
+    <ClInclude Include="inc\Core\SearchResult.h">
+      <Filter>Header Files\Core</Filter>
+    </ClInclude>
     <ClInclude Include="inc\Core\VectorIndex.h">
       <Filter>Header Files\Core</Filter>
     </ClInclude>
@@ -132,9 +135,6 @@
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="src\Core\CommonDataStructure.cpp">
-      <Filter>Source Files\Core</Filter>
-    </ClCompile>
     <ClCompile Include="src\Core\VectorIndex.cpp">
       <Filter>Source Files\Core</Filter>
     </ClCompile>

AnnService/inc/Core/CommonDataStructure.h

@@ -4,53 +4,223 @@
 #ifndef _SPTAG_COMMONDATASTRUCTURE_H_
 #define _SPTAG_COMMONDATASTRUCTURE_H_
 
-#include "Common.h"
+#include "inc/Core/Common.h"
 
 namespace SPTAG
 {
 
-class ByteArray
+template<typename T>
+class Array
 {
 public:
-    ByteArray();
+    Array();
 
-    ByteArray(ByteArray&& p_right);
+    Array(T* p_array, std::size_t p_length, bool p_transferOwnership);
+
+    Array(T* p_array, std::size_t p_length, std::shared_ptr<T> p_dataHolder);
 
-    ByteArray(std::uint8_t* p_array, std::size_t p_length, bool p_transferOnwership);
+    Array(Array<T>&& p_right);
 
-    ByteArray(std::uint8_t* p_array, std::size_t p_length, std::shared_ptr<std::uint8_t> p_dataHolder);
+    Array(const Array<T>& p_right);
 
-    ByteArray(const ByteArray& p_right);
+    Array<T>& operator= (Array<T>&& p_right);
 
-    ByteArray& operator= (const ByteArray& p_right);
+    Array<T>& operator= (const Array<T>& p_right);
 
-    ByteArray& operator= (ByteArray&& p_right);
+    T& operator[] (std::size_t p_index);
 
-    ~ByteArray();
+    const T& operator[] (std::size_t p_index) const;
 
-    static ByteArray Alloc(std::size_t p_length);
+    ~Array();
 
-    std::uint8_t* Data() const;
+    T* Data() const;
 
-	std::size_t Length() const;
-
-	void SetData(std::uint8_t* p_array, std::size_t p_length);
+    std::size_t Length() const;
 
-    std::shared_ptr<std::uint8_t> DataHolder() const;
+    std::shared_ptr<T> DataHolder() const;
+
+    void Set(T* p_array, std::size_t p_length, bool p_transferOwnership);
 
     void Clear();
 
-    const static ByteArray c_empty;
+    static Array<T> Alloc(std::size_t p_length);
+
+    const static Array<T> c_empty;
 
 private:
-    std::uint8_t* m_data;
+    T* m_data;
 
     std::size_t m_length;
 
     // Notice this is holding an array. Set correct deleter for this.
-    std::shared_ptr<std::uint8_t> m_dataHolder;
+    std::shared_ptr<T> m_dataHolder;
 };
 
+template<typename T>
+const Array<T> Array<T>::c_empty;
+
+
+template<typename T>
+Array<T>::Array()
+    : m_data(nullptr),
+    m_length(0)
+{
+}
+
+template<typename T>
+Array<T>::Array(T* p_array, std::size_t p_length, bool p_transferOnwership)
+
+    : m_data(p_array),
+    m_length(p_length)
+{
+    if (p_transferOnwership)
+    {
+        m_dataHolder.reset(m_data, std::default_delete<T[]>());
+    }
+}
+
+
+template<typename T>
+Array<T>::Array(T* p_array, std::size_t p_length, std::shared_ptr<T> p_dataHolder)
+    : m_data(p_array),
+    m_length(p_length),
+    m_dataHolder(std::move(p_dataHolder))
+{
+}
+
+
+template<typename T>
+Array<T>::Array(Array<T>&& p_right)
+    : m_data(p_right.m_data),
+    m_length(p_right.m_length),
+    m_dataHolder(std::move(p_right.m_dataHolder))
+{
+}
+
+
+template<typename T>
+Array<T>::Array(const Array<T>& p_right)
+    : m_data(p_right.m_data),
+    m_length(p_right.m_length),
+    m_dataHolder(p_right.m_dataHolder)
+{
+}
+
+
+template<typename T>
+Array<T>&
+Array<T>::operator= (Array<T>&& p_right)
+{
+    m_data = p_right.m_data;
+    m_length = p_right.m_length;
+    m_dataHolder = std::move(p_right.m_dataHolder);
+
+    return *this;
+}
+
+
+template<typename T>
+Array<T>&
+Array<T>::operator= (const Array<T>& p_right)
+{
+    m_data = p_right.m_data;
+    m_length = p_right.m_length;
+    m_dataHolder = p_right.m_dataHolder;
+
+    return *this;
+}
+
+
+template<typename T>
+T&
+Array<T>::operator[] (std::size_t p_index)
+{
+    return m_data[p_index];
+}
+
+
+template<typename T>
+const T&
+Array<T>::operator[] (std::size_t p_index) const
+{
+    return m_data[p_index];
+}
+
+
+template<typename T>
+Array<T>::~Array()
+{
+}
+
+
+template<typename T>
+T*
+Array<T>::Data() const
+{
+    return m_data;
+}
+
+
+template<typename T>
+std::size_t
+Array<T>::Length() const
+{
+    return m_length;
+}
+
+
+template<typename T>
+std::shared_ptr<T>
+Array<T>::DataHolder() const
+{
+    return m_dataHolder;
+}
+
+
+template<typename T>
+void
+Array<T>::Set(T* p_array, std::size_t p_length, bool p_transferOwnership)
+{
+    m_data = p_array;
+    m_length = p_length;
+
+    if (p_transferOwnership)
+    {
+        m_dataHolder.reset(m_data, std::default_delete<T[]>());
+    }
+}
+
+
+template<typename T>
+void
+Array<T>::Clear()
+{
+    m_data = nullptr;
+    m_length = 0;
+    m_dataHolder.reset();
+}
+
+
+template<typename T>
+Array<T>
+Array<T>::Alloc(std::size_t p_length)
+{
+    Array<T> arr;
+    if (0 == p_length)
+    {
+        return arr;
+    }
+
+    arr.m_dataHolder.reset(new T[p_length], std::default_delete<T[]>());
+
+    arr.m_length = p_length;
+    arr.m_data = arr.m_dataHolder.get();
+    return arr;
+}
+
+
+typedef Array<std::uint8_t> ByteArray;
+
 } // namespace SPTAG
 
 #endif // _SPTAG_COMMONDATASTRUCTURE_H_