fix win include and export

Author: Tieqiong

src/diffpy/Attributes.hpp

@@ -26,6 +26,8 @@
 #include <stdexcept>
 #include <boost/shared_ptr.hpp>
 
+#include <diffpy/Export.hpp>
+
 namespace diffpy {
 namespace attributes {
 
@@ -46,7 +48,7 @@ class DoubleAttributeError : public std::runtime_error
 /// @class BaseDoubleAttribute
 /// @brief abstract base class for accessing a particular double attribute
 
-class BaseDoubleAttribute
+class DLL_EXPORT BaseDoubleAttribute
 {
     public:
 
@@ -75,7 +77,7 @@ class BaseAttributesVisitor
 /// should derive from Attributes and register their setter and
 /// getter methods in their constructors.
 
-class Attributes
+class DLL_EXPORT Attributes
 {
     public:
 
@@ -98,7 +100,7 @@ class Attributes
 
     protected:
 
-        friend void registerBaseDoubleAttribute(Attributes*,
+        friend DLL_EXPORT void registerBaseDoubleAttribute(Attributes*,
                 const std::string&, attributes::BaseDoubleAttribute* pa);
         template <class T, class Getter>
             void registerDoubleAttribute(const std::string& name, T* obj, Getter);
@@ -186,10 +188,10 @@ class Attributes
 
 // non-member helpers
 
-void registerBaseDoubleAttribute(Attributes* obj,
+DLL_EXPORT void registerBaseDoubleAttribute(Attributes* obj,
         const std::string& name, BaseDoubleAttribute* pa);
 
-void throwDoubleAttributeReadOnly();
+DLL_EXPORT void throwDoubleAttributeReadOnly();
 
 }   // namespace attributes
 }   // namespace diffpy

src/diffpy/EventTicker.hpp

@@ -26,10 +26,12 @@
 #include <boost/serialization/utility.hpp>
 #include <boost/serialization/split_member.hpp>
 
+#include <diffpy/Export.hpp>
+
 namespace diffpy {
 namespace eventticker {
 
-class EventTicker
+class DLL_EXPORT EventTicker
 {
     public:
 

src/diffpy/Export.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#if defined(_WIN32)
+  #if defined(BUILD_DLL)
+    #define DLL_EXPORT __declspec(dllexport)
+  #else
+    #define DLL_EXPORT __declspec(dllimport)
+  #endif
+#else
+  #define DLL_EXPORT
+#endif

src/diffpy/mathutils.ipp

@@ -34,12 +34,6 @@ inline double remainder(double x, double y)
         fmod(x, y) : (fmod(x, y) + y);
 }
 
-
-inline double log2(double x)
-{
-    return log(x) / log(2.0);
-}
-
 #endif  // _MSC_VER
 
 namespace diffpy {

src/diffpy/runtimepath.cpp

@@ -23,8 +23,57 @@
 #include <sstream>
 #include <stdexcept>
 #include <sys/stat.h>
-#include <dlfcn.h>
+#include <dlfcn.h> // not available on Windows, conda install dlfcn-win32
+
+// libgen.h is not available on Windows
+#ifdef _WIN32
+#include <string>
+#include <algorithm>
+
+// A simple replacement for dirname() on Windows.
+inline std::string win_dirname(const std::string& path)
+{
+    // Find the last occurrence of either '\' or '/'
+    size_t pos = path.find_last_of("\\/");
+    if (pos == std::string::npos)
+        return ".";  // No directory found, return current directory
+    return path.substr(0, pos);
+}
+
+// Overload to match the expected C-style interface if needed:
+inline char* dirname(char* path)
+{
+    static std::string dir;
+    dir = win_dirname(std::string(path));
+    return const_cast<char*>(dir.c_str());
+}
+#else
 #include <libgen.h>
+#endif
+
+// S_ISDIR, PATH_MAX, realpath, etc.
+#ifdef _WIN32
+#include <windows.h>
+#include <stdlib.h>    // for _fullpath
+#include <sys/stat.h>  // for _stat
+#include <direct.h>    // for _getcwd, etc.
+
+// Define S_ISDIR using the Windows _S_IFDIR flag from sys/stat.h.
+#ifndef S_ISDIR
+#define S_ISDIR(mode) (((mode) & _S_IFDIR) == _S_IFDIR)
+#endif
+
+// Use MAX_PATH from <windows.h> as PATH_MAX if not defined.
+#ifndef PATH_MAX
+#define PATH_MAX MAX_PATH
+#endif
+
+// Define realpath in terms of _fullpath.
+// _fullpath returns a pointer to the resolved path in the buffer you provide.
+// The usage should be nearly equivalent.
+#define realpath(N, R) _fullpath((R), (N), PATH_MAX)
+#endif
+
 
 #include <diffpy/version.hpp>
 #include <diffpy/runtimepath.hpp>

src/diffpy/serialization.hpp

@@ -32,9 +32,10 @@
 namespace diffpy {
 
 template <typename T>
-    std::string serialization_tostring(const T& tobj);
+std::string serialization_tostring(const T& tobj);
+
 template <typename T>
-    void serialization_fromstring(T& tobj, const std::string& s);
+void serialization_fromstring(T& tobj, const std::string& s);
 
 namespace serialization {
 
@@ -44,4 +45,7 @@ typedef ::boost::archive::binary_oarchive oarchive;
 }   // namespace serialization
 }   // namespace diffpy
 
+// Pull in the inline definitions and macro logic
+#include "serialization.ipp"
+
 #endif  // SERIALIZATION_HPP_INCLUDED

src/diffpy/serialization.ipp

@@ -54,25 +54,30 @@ void serialization_fromstring(T& tobj, const std::string& s)
     ia >> tobj;
 }
 
-}   // namespace diffpy
-
 // Macros --------------------------------------------------------------------
+// Macros for explicit instantiation:
+// - On Windows (_WIN32), make them no-ops to avoid dllimport/dllexport issues.
+// - On other platforms, keep them as they were.
+#ifdef _WIN32
+
+    #define DIFFPY_INSTANTIATE_SERIALIZATION(C)     /* no-op */
+    #define DIFFPY_INSTANTIATE_PTR_SERIALIZATION(C) /* no-op */
 
-/// Insert explicit instantiations for serialization_tostring and
-/// serialization_fromstring for class C.
+#else
 
-#define DIFFPY_INSTANTIATE_SERIALIZATION(C) \
-    template \
-        std::string \
-        diffpy::serialization_tostring<C>(const C&); \
-    template \
-        void \
-        diffpy::serialization_fromstring<C>(C&, const std::string&); \
+    /// Insert explicit instantiations for serialization_tostring and
+    /// serialization_fromstring for class C.
+    #define DIFFPY_INSTANTIATE_SERIALIZATION(C) \
+        template std::string diffpy::serialization_tostring<C>(const C&); \
+        template void diffpy::serialization_fromstring<C>(C&, const std::string&);
 
-/// Insert explicit instantiations for serialization_tostring and
-/// serialization_fromstring for type boost::shared_ptr<C>.
+    /// Insert explicit instantiations for serialization_tostring and
+    /// serialization_fromstring for type boost::shared_ptr<C>.
+    #define DIFFPY_INSTANTIATE_PTR_SERIALIZATION(C) \
+        DIFFPY_INSTANTIATE_SERIALIZATION(boost::shared_ptr<C>)
 
-#define DIFFPY_INSTANTIATE_PTR_SERIALIZATION(C) \
-    DIFFPY_INSTANTIATE_SERIALIZATION(boost::shared_ptr<C>)
+#endif
+
+}   // namespace diffpy
 
 #endif  // SERIALIZATION_IPP_INCLUDED

src/diffpy/srreal/AtomRadiiTable.cpp

@@ -29,7 +29,7 @@
 namespace diffpy {
 
 // Unique instantiation of the template registry base class.
-template class HasClassRegistry<srreal::AtomRadiiTable>;
+template class DLL_EXPORT HasClassRegistry<srreal::AtomRadiiTable>;
 
 namespace srreal {
 

src/diffpy/srreal/AtomRadiiTable.hpp

@@ -32,10 +32,12 @@
 
 #include <diffpy/HasClassRegistry.hpp>
 
+#include <diffpy/Export.hpp>
+
 namespace diffpy {
 namespace srreal {
 
-class AtomRadiiTable :
+class DLL_EXPORT AtomRadiiTable :
     public diffpy::HasClassRegistry<AtomRadiiTable>
 {
     public:

src/diffpy/srreal/AtomicStructureAdapter.hpp

@@ -24,10 +24,12 @@
 
 #include <diffpy/srreal/StructureAdapter.hpp>
 
+#include <diffpy/Export.hpp>
+
 namespace diffpy {
 namespace srreal {
 
-class Atom
+class DLL_EXPORT Atom
 {
     public:
 
@@ -64,17 +66,17 @@ class Atom
 
 // Functions related to class Atom
 
-bool operator<(const Atom&, const Atom&);
+DLL_EXPORT bool operator<(const Atom&, const Atom&);
 inline bool operator>(const Atom& a0, const Atom& a1)  { return a1 < a0; }
 inline bool operator<=(const Atom& a0, const Atom& a1)  { return !(a1 < a0); }
 inline bool operator>=(const Atom& a0, const Atom& a1)  { return !(a0 < a1); }
 
-bool operator==(const Atom&, const Atom&);
-bool operator!=(const Atom&, const Atom&);
-size_t hash_value(const Atom&);
+DLL_EXPORT bool operator==(const Atom&, const Atom&);
+DLL_EXPORT bool operator!=(const Atom&, const Atom&);
+DLL_EXPORT size_t hash_value(const Atom&);
 
 
-class AtomicStructureAdapter : public StructureAdapter
+class DLL_EXPORT AtomicStructureAdapter : public StructureAdapter
 {
     public: