Skip to content

L
libcifpp
Commit 7c111303 by Maarten L. Hekkelman
Options

explicitly export what needs to be exported

parent 151915be
Showing with 119 additions and 190 deletions
include/cif++/atom_type.hpp
......@@ -194,7 +194,7 @@ enum class ionic_radius_type
effective, crystal
};
struct atom_type_info
struct CIFPP_EXPORT atom_type_info
{
atom_type type;
std::string name;
......@@ -204,12 +204,12 @@ struct atom_type_info
float radii[kRadiusTypeCount];
};
extern const atom_type_info kKnownAtoms[];
CIFPP_EXPORT extern const atom_type_info kKnownAtoms[];
// --------------------------------------------------------------------
// AtomTypeTraits
class atom_type_traits
class CIFPP_EXPORT atom_type_traits
{
public:
atom_type_traits(atom_type a);
......
include/cif++/category.hpp
......@@ -45,7 +45,7 @@ namespace cif
// --------------------------------------------------------------------
// special exception
class duplicate_key_error : public std::runtime_error
class CIFPP_EXPORT duplicate_key_error : public std::runtime_error
{
public:
duplicate_key_error(const std::string &msg)
......@@ -54,7 +54,7 @@ class duplicate_key_error : public std::runtime_error
// --------------------------------------------------------------------
class category
class CIFPP_EXPORT category
{
public:
friend class row_handle;
......
include/cif++/compound.hpp
......@@ -67,7 +67,7 @@ bond_type from_string(const std::string &bondType);
/// \brief struct containing information about an atom in a chemical compound.
/// This is a subset of the available information. Contact the author if you need more fields.
struct compound_atom
struct CIFPP_EXPORT compound_atom
{
std::string id;
atom_type type_symbol;
......@@ -86,7 +86,7 @@ struct compound_atom
/// --------------------------------------------------------------------
/// \brief struct containing information about the bonds
struct compound_bond
struct CIFPP_EXPORT compound_bond
{
std::string atom_id[2];
bond_type type;
......@@ -101,7 +101,7 @@ struct compound_bond
/// compound definitions by calling the addExtraComponents function and
/// pass it a valid CCD formatted file.
class compound
class CIFPP_EXPORT compound
{
public:
// accessors
......@@ -149,7 +149,7 @@ class compound
// --------------------------------------------------------------------
// Factory class for compound and Link objects
class compound_factory
class CIFPP_EXPORT compound_factory
{
public:
/// \brief Initialise a singleton instance.
......
include/cif++/condition.hpp
......@@ -40,16 +40,16 @@ namespace cif
// --------------------------------------------------------------------
// let's make life easier
iset get_category_fields(const category &cat);
uint16_t get_column_ix(const category &cat, std::string_view col);
bool is_column_type_uchar(const category &cat, std::string_view col);
CIFPP_EXPORT iset get_category_fields(const category &cat);
CIFPP_EXPORT uint16_t get_column_ix(const category &cat, std::string_view col);
CIFPP_EXPORT bool is_column_type_uchar(const category &cat, std::string_view col);
// --------------------------------------------------------------------
// some more templates to be able to do querying
namespace detail
{
struct condition_impl
struct CIFPP_EXPORT condition_impl
{
virtual ~condition_impl() {}
......@@ -61,7 +61,7 @@ namespace detail
virtual bool equals(const condition_impl *rhs) const { return false; }
};
struct all_condition_impl : public condition_impl
struct CIFPP_EXPORT all_condition_impl : public condition_impl
{
bool test(row_handle) const override { return true; }
void str(std::ostream &os) const override { os << "*"; }
......@@ -72,7 +72,7 @@ namespace detail
struct not_condition_impl;
} // namespace detail
class condition
class CIFPP_EXPORT condition
{
public:
using condition_impl = detail::condition_impl;
......@@ -155,7 +155,7 @@ class condition
namespace detail
{
struct key_is_empty_condition_impl : public condition_impl
struct CIFPP_EXPORT key_is_empty_condition_impl : public condition_impl
{
key_is_empty_condition_impl(const std::string &item_tag)
: m_item_tag(item_tag)
......@@ -182,7 +182,7 @@ namespace detail
uint16_t m_item_ix = 0;
};
struct key_equals_condition_impl : public condition_impl
struct CIFPP_EXPORT key_equals_condition_impl : public condition_impl
{
key_equals_condition_impl(item &&i)
: m_item_tag(i.name())
......@@ -228,7 +228,7 @@ namespace detail
std::optional<row_handle> m_single_hit;
};
struct key_equals_or_empty_condition_impl : public condition_impl
struct CIFPP_EXPORT key_equals_or_empty_condition_impl : public condition_impl
{
key_equals_or_empty_condition_impl(key_equals_condition_impl *equals)
: m_item_tag(equals->m_item_tag)
......@@ -286,7 +286,7 @@ namespace detail
std::optional<row_handle> m_single_hit;
};
struct key_compare_condition_impl : public condition_impl
struct CIFPP_EXPORT key_compare_condition_impl : public condition_impl
{
template <typename COMP>
key_compare_condition_impl(const std::string &item_tag, COMP &&comp, const std::string &s)
......@@ -320,7 +320,7 @@ namespace detail
std::string m_str;
};
struct key_matches_condition_impl : public condition_impl
struct CIFPP_EXPORT key_matches_condition_impl : public condition_impl
{
key_matches_condition_impl(const std::string &item_tag, const std::regex &rx)
: m_item_tag(item_tag)
......@@ -352,7 +352,7 @@ namespace detail
};
template <typename T>
struct any_is_condition_impl : public condition_impl
struct CIFPP_EXPORT any_is_condition_impl : public condition_impl
{
typedef T valueType;
......@@ -392,7 +392,7 @@ namespace detail
valueType mValue;
};
struct any_matches_condition_impl : public condition_impl
struct CIFPP_EXPORT any_matches_condition_impl : public condition_impl
{
any_matches_condition_impl(const std::regex &rx)
: mRx(rx)
......@@ -434,7 +434,7 @@ namespace detail
// TODO: Optimize and_condition by having a list of sub items.
// That way you can also collapse multiple _is_ conditions in
// case they make up an indexed tuple.
struct and_condition_impl : public condition_impl
struct CIFPP_EXPORT and_condition_impl : public condition_impl
{
and_condition_impl() = default;
......@@ -537,7 +537,7 @@ namespace detail
std::vector<condition_impl *> m_sub;
};
struct or_condition_impl : public condition_impl
struct CIFPP_EXPORT or_condition_impl : public condition_impl
{
or_condition_impl(condition &&a, condition &&b)
{
......@@ -628,7 +628,7 @@ namespace detail
std::vector<condition_impl *> m_sub;
};
struct not_condition_impl : public condition_impl
struct CIFPP_EXPORT not_condition_impl : public condition_impl
{
not_condition_impl(condition &&a)
: mA(nullptr)
......@@ -705,7 +705,7 @@ inline condition operator or(condition &&a, condition &&b)
return condition(std::move(b));
}
struct empty_type
struct CIFPP_EXPORT empty_type
{
};
......@@ -713,7 +713,7 @@ struct empty_type
inline constexpr empty_type null = empty_type();
struct key
struct CIFPP_EXPORT key
{
explicit key(const std::string &itemTag)
: m_item_tag(itemTag)
......@@ -829,7 +829,7 @@ inline condition operator not(condition &&rhs)
return condition(new detail::not_condition_impl(std::move(rhs)));
}
struct any_type
struct CIFPP_EXPORT any_type
{
};
......
include/cif++/datablock.hpp
......@@ -34,7 +34,7 @@ namespace cif
// --------------------------------------------------------------------
class datablock : public std::list<category>
class CIFPP_EXPORT datablock : public std::list<category>
{
public:
datablock() = default;
......
include/cif++/dictionary_parser.hpp
......@@ -31,6 +31,6 @@
namespace cif
{
validator parse_dictionary(std::string_view name, std::istream &is);
CIFPP_EXPORT validator parse_dictionary(std::string_view name, std::istream &is);
} // namespace cif
include/cif++/file.hpp
......@@ -28,6 +28,7 @@
#include <list>
#include <cif++/exports.hpp>
#include <cif++/datablock.hpp>
#include <cif++/parser.hpp>
......@@ -36,7 +37,7 @@ namespace cif
// --------------------------------------------------------------------
class file : public std::list<datablock>
class CIFPP_EXPORT file : public std::list<datablock>
{
public:
file() = default;
......
include/cif++/format.hpp
......@@ -39,7 +39,7 @@ namespace cif
namespace detail
{
template <typename T>
struct to_varg
struct CIFPP_EXPORT to_varg
{
using type = T;
......@@ -54,7 +54,7 @@ namespace detail
};
template <>
struct to_varg<const char *>
struct CIFPP_EXPORT to_varg<const char *>
{
using type = const char *;
......@@ -69,7 +69,7 @@ namespace detail
};
template <>
struct to_varg<std::string>
struct CIFPP_EXPORT to_varg<std::string>
{
using type = const char *;
......@@ -86,7 +86,7 @@ namespace detail
} // namespace
template <typename... Args>
class format_plus_arg
class CIFPP_EXPORT format_plus_arg
{
public:
using args_vector_type = std::tuple<detail::to_varg<Args>...>;
......@@ -141,7 +141,7 @@ constexpr auto format(std::string_view fmt, Args... args)
// --------------------------------------------------------------------
/// A streambuf that fills out lines with spaces up until a specified width
class fill_out_streambuf : public std::streambuf
class CIFPP_EXPORT fill_out_streambuf : public std::streambuf
{
public:
using base_type = std::streambuf;
......
include/cif++/forward_decl.hpp
......@@ -26,21 +26,23 @@
#pragma once
#include <cif++/exports.hpp>
#include <string>
#include <vector>
namespace cif
{
class category;
class datablock;
class file;
class parser;
class CIFPP_EXPORT category;
class CIFPP_EXPORT datablock;
class CIFPP_EXPORT file;
class CIFPP_EXPORT parser;
class row;
class row_handle;
class CIFPP_EXPORT row;
class CIFPP_EXPORT row_handle;
class item;
struct item_handle;
class CIFPP_EXPORT item;
struct CIFPP_EXPORT item_handle;
} // namespace cif
\ No newline at end of file
include/cif++/item.hpp
......@@ -51,7 +51,7 @@ namespace cif
// --------------------------------------------------------------------
/// \brief item is a transient class that is used to pass data into rows
/// but it also takes care of formatting data.
class item
class CIFPP_EXPORT item
{
public:
/// \brief Default constructor, empty item
......@@ -188,7 +188,7 @@ class item
/// Typically, more than 99% of the strings in an mmCIF file are less
/// than 8 bytes in length.
struct item_value
struct CIFPP_EXPORT item_value
{
item_value() = default;
......@@ -265,7 +265,7 @@ struct item_value
/// \brief This is item_handle, it is used to access the data stored in item_value.
struct item_handle
struct CIFPP_EXPORT item_handle
{
public:
// conversion helper class
......
include/cif++/list.hpp deleted 100644 → 0
/*-
* SPDX-License-Identifier: BSD-2-Clause
*
* Copyright (c) 2022 NKI/AVL, Netherlands Cancer Institute
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include <memory>
namespace cif
{
// --------------------------------------------------------------------
template<typename Allocator = std::allocator<void>>
class list
{
public:
protected:
struct list_item
{
list_item *m_next = nullptr;
};
using list_item_allocator_type = typename std::allocator_traits<Alloc>::template rebind_alloc<list_item>;
using list_item_allocator_traits = std::allocator_traits<item_allocator_type>;
list_item_allocator_traits::pointer get_item()
{
list_item_allocator_type ia(get_allocator());
return list_item_allocator_traits::allocate(ia, 1);
}
template<typename ...Arguments>
list_item *create_list_item(uint16_t column_ix, Arguments... args)
{
auto p = this->get_item();
list_item_allocator_type ia(get_allocator());
list_item_allocator_traits::construct(ia, p, std::forward<Arguments>(args)...);
return p;
}
void delete_list_item(list_item *iv)
{
list_item_allocator_type ia(get_allocator());
list_item_allocator_traits::destroy(ia, iv);
list_item_allocator_traits::deallocate(ia, iv, 1);
}
list_item *m_head = nullptr, *m_tail = nullptr;
};
} // namespace cif
include/cif++/model.hpp
......@@ -45,7 +45,7 @@ class structure;
// --------------------------------------------------------------------
class atom
class CIFPP_EXPORT atom
{
private:
struct atom_impl : public std::enable_shared_from_this<atom_impl>
......@@ -388,7 +388,7 @@ enum class EntityType
// --------------------------------------------------------------------
class residue
class CIFPP_EXPORT residue
{
public:
friend class structure;
......@@ -499,7 +499,7 @@ class residue
// --------------------------------------------------------------------
// a monomer models a single residue in a protein chain
class monomer : public residue
class CIFPP_EXPORT monomer : public residue
{
public:
// monomer();
......@@ -570,7 +570,7 @@ class monomer : public residue
// --------------------------------------------------------------------
class polymer : public std::vector<monomer>
class CIFPP_EXPORT polymer : public std::vector<monomer>
{
public:
polymer(structure &s, const std::string &entityID, const std::string &asymID, const std::string &auth_asym_id);
......@@ -599,9 +599,9 @@ class polymer : public std::vector<monomer>
// --------------------------------------------------------------------
// sugar and branch, to describe glycosylation sites
class branch;
class CIFPP_EXPORT branch;
class sugar : public residue
class CIFPP_EXPORT sugar : public residue
{
public:
sugar(branch &branch, const std::string &compoundID,
......@@ -638,7 +638,7 @@ class sugar : public residue
atom m_link;
};
class branch : public std::vector<sugar>
class CIFPP_EXPORT branch : public std::vector<sugar>
{
public:
branch(structure &structure, const std::string &asym_id, const std::string &entity_id);
......@@ -724,7 +724,7 @@ inline bool operator&(StructureOpenOptions a, StructureOpenOptions b)
// --------------------------------------------------------------------
class structure
class CIFPP_EXPORT structure
{
public:
structure(file &p, size_t modelNr = 1, StructureOpenOptions options = {});
......
include/cif++/parser.hpp
......@@ -36,7 +36,7 @@ namespace cif
// --------------------------------------------------------------------
class parse_error : public std::runtime_error
class CIFPP_EXPORT parse_error : public std::runtime_error
{
public:
parse_error(uint32_t line_nr, const std::string &message)
......@@ -49,7 +49,7 @@ class parse_error : public std::runtime_error
// TODO: Need to implement support for transformed long lines
class sac_parser
class CIFPP_EXPORT sac_parser
{
public:
using datablock_index = std::map<std::string, std::size_t>;
......@@ -267,7 +267,7 @@ class sac_parser
// --------------------------------------------------------------------
class parser : public sac_parser
class CIFPP_EXPORT parser : public sac_parser
{
public:
parser(std::istream &is, file &file)
......
include/cif++/point.hpp
......@@ -26,6 +26,8 @@
#pragma once
#include <cif++/exports.hpp>
#include <cmath>
#include <complex>
#include <functional>
......@@ -49,7 +51,7 @@ const double
// We use quaternions to do rotations in 3d space
template <typename T>
class quaternion_type
class CIFPP_EXPORT quaternion_type
{
public:
using value_type = T;
......@@ -353,7 +355,7 @@ using quaternion = quaternion_type<float>;
// tie(x, y, z) = atom.loc();
template <typename F>
struct point_type
struct CIFPP_EXPORT point_type
{
using value_type = F;
......@@ -680,21 +682,21 @@ constexpr auto distance_point_to_line(const point_type<F> &l1, const point_type<
// a random direction with a distance randomly chosen from a normal
// distribution with a stddev of offset.
point nudge(point p, float offset);
CIFPP_EXPORT point nudge(point p, float offset);
// --------------------------------------------------------------------
quaternion construct_from_angle_axis(float angle, point axis);
std::tuple<double, point> quaternion_to_angle_axis(quaternion q);
CIFPP_EXPORT quaternion construct_from_angle_axis(float angle, point axis);
CIFPP_EXPORT std::tuple<double, point> quaternion_to_angle_axis(quaternion q);
/// @brief Given four points and an angle, return the quaternion required to rotate
/// point p4 along the p2-p3 axis and around point p3 to obtain the required within
/// an accuracy of esd
quaternion construct_for_dihedral_angle(point p1, point p2, point p3, point p4,
CIFPP_EXPORT quaternion construct_for_dihedral_angle(point p1, point p2, point p3, point p4,
float angle, float esd);
point centroid(const std::vector<point> &Points);
point center_points(std::vector<point> &Points);
CIFPP_EXPORT point centroid(const std::vector<point> &Points);
CIFPP_EXPORT point center_points(std::vector<point> &Points);
/// \brief Returns how the two sets of points \a a and \b b can be aligned
///
......@@ -702,10 +704,10 @@ point center_points(std::vector<point> &Points);
/// \param b The second set of points
/// \result The quaternion which should be applied to the points in \a a to
/// obtain the best superposition.
quaternion align_points(const std::vector<point> &a, const std::vector<point> &b);
CIFPP_EXPORT quaternion align_points(const std::vector<point> &a, const std::vector<point> &b);
/// \brief The RMSd for the points in \a a and \a b
double RMSd(const std::vector<point> &a, const std::vector<point> &b);
CIFPP_EXPORT double RMSd(const std::vector<point> &a, const std::vector<point> &b);
// --------------------------------------------------------------------
// Helper class to generate evenly divided points on a sphere
......
include/cif++/row.hpp
......@@ -103,7 +103,7 @@ auto tie(Ts &...v)
// --------------------------------------------------------------------
/// \brief the row class, this one is not directly accessible from the outside
class row : public std::vector<item_value>
class CIFPP_EXPORT row : public std::vector<item_value>
{
public:
row() = default;
......@@ -145,7 +145,7 @@ class row : public std::vector<item_value>
// --------------------------------------------------------------------
/// \brief row_handle is the way to access data stored in rows
class row_handle
class CIFPP_EXPORT row_handle
{
public:
friend struct item_handle;
......@@ -265,7 +265,7 @@ class row_handle
// --------------------------------------------------------------------
class row_initializer : public std::vector<item>
class CIFPP_EXPORT row_initializer : public std::vector<item>
{
public:
friend class category;
......
include/cif++/symmetry.hpp
......@@ -44,7 +44,7 @@ enum class space_group_name
Hall
};
struct space_group
struct CIFPP_EXPORT space_group
{
const char *name;
const char *xHM;
......@@ -57,7 +57,7 @@ extern CIFPP_EXPORT const std::size_t kNrOfSpaceGroups;
// --------------------------------------------------------------------
struct symop_data
struct CIFPP_EXPORT symop_data
{
constexpr symop_data(const std::array<int, 15> &data)
: m_packed((data[0] & 0x03ULL) << 34 bitor
......@@ -122,7 +122,7 @@ struct symop_data
uint64_t m_packed;
};
struct symop_datablock
struct CIFPP_EXPORT symop_datablock
{
constexpr symop_datablock(int spacegroup, int rotational_number, const std::array<int, 15> &rt_data)
: m_v((spacegroup & 0xffffULL) << 48 bitor
......@@ -141,12 +141,12 @@ struct symop_datablock
static_assert(sizeof(symop_datablock) == sizeof(uint64_t), "Size of symop_data is wrong");
extern const symop_datablock kSymopNrTable[];
extern const std::size_t kSymopNrTableSize;
CIFPP_EXPORT extern const symop_datablock kSymopNrTable[];
CIFPP_EXPORT extern const std::size_t kSymopNrTableSize;
// --------------------------------------------------------------------
int get_space_group_number(std::string spacegroup); // alternative for clipper's parsing code, using space_group_name::full
int get_space_group_number(std::string spacegroup, space_group_name type); // alternative for clipper's parsing code
CIFPP_EXPORT int get_space_group_number(std::string spacegroup); // alternative for clipper's parsing code, using space_group_name::full
CIFPP_EXPORT int get_space_group_number(std::string spacegroup, space_group_name type); // alternative for clipper's parsing code
} // namespace cif
include/cif++/text.hpp
......@@ -26,6 +26,8 @@
#pragma once
#include <cif++/exports.hpp>
#include <charconv>
#include <cmath>
#include <limits>
......@@ -107,16 +109,16 @@ namespace cif
// some basic utilities: Since we're using ASCII input only, we define for optimisation
// our own case conversion routines.
bool iequals(std::string_view a, std::string_view b);
int icompare(std::string_view a, std::string_view b);
CIFPP_EXPORT bool iequals(std::string_view a, std::string_view b);
CIFPP_EXPORT int icompare(std::string_view a, std::string_view b);
bool iequals(const char *a, const char *b);
int icompare(const char *a, const char *b);
CIFPP_EXPORT bool iequals(const char *a, const char *b);
CIFPP_EXPORT int icompare(const char *a, const char *b);
void to_lower(std::string &s);
std::string to_lower_copy(std::string_view s);
CIFPP_EXPORT void to_lower(std::string &s);
CIFPP_EXPORT std::string to_lower_copy(std::string_view s);
void to_upper(std::string &s);
CIFPP_EXPORT void to_upper(std::string &s);
// std::string toUpperCopy(const std::string &s);
template <typename IterType>
......@@ -179,7 +181,7 @@ std::vector<StringType> split(std::string_view s, std::string_view separators, b
return result;
}
void replace_all(std::string &s, std::string_view what, std::string_view with = {});
CIFPP_EXPORT void replace_all(std::string &s, std::string_view what, std::string_view with = {});
#if defined(__cpp_lib_starts_ends_with)
......@@ -223,15 +225,15 @@ inline bool contains(std::string_view s, std::string_view q)
#endif
bool icontains(std::string_view s, std::string_view q);
CIFPP_EXPORT bool icontains(std::string_view s, std::string_view q);
void trim_left(std::string &s);
void trim_right(std::string &s);
void trim(std::string &s);
CIFPP_EXPORT void trim_left(std::string &s);
CIFPP_EXPORT void trim_right(std::string &s);
CIFPP_EXPORT void trim(std::string &s);
std::string trim_left_copy(std::string_view s);
std::string trim_right_copy(std::string_view s);
std::string trim_copy(std::string_view s);
CIFPP_EXPORT std::string trim_left_copy(std::string_view s);
CIFPP_EXPORT std::string trim_right_copy(std::string_view s);
CIFPP_EXPORT std::string trim_copy(std::string_view s);
// To make life easier, we also define iless and iset using iequals
......@@ -257,17 +259,17 @@ inline char tolower(int ch)
// --------------------------------------------------------------------
std::tuple<std::string, std::string> split_tag_name(std::string_view tag);
CIFPP_EXPORT std::tuple<std::string, std::string> split_tag_name(std::string_view tag);
// --------------------------------------------------------------------
// generate a cif name, mainly used to generate asym_id's
std::string cif_id_for_number(int number);
CIFPP_EXPORT std::string cif_id_for_number(int number);
// --------------------------------------------------------------------
// custom wordwrapping routine
std::vector<std::string> word_wrap(const std::string &text, size_t width);
CIFPP_EXPORT std::vector<std::string> word_wrap(const std::string &text, size_t width);
// --------------------------------------------------------------------
/// std::from_chars for floating point types.
......
include/cif++/utilities.hpp
......@@ -55,18 +55,18 @@ namespace cif
extern CIFPP_EXPORT int VERBOSE;
// the git 'build' number
std::string get_version_nr();
CIFPP_EXPORT std::string get_version_nr();
// std::string get_version_date();
// --------------------------------------------------------------------
// Code helping with terminal i/o
uint32_t get_terminal_width();
CIFPP_EXPORT uint32_t get_terminal_width();
// --------------------------------------------------------------------
// Path of the current executable
std::string get_executable_path();
CIFPP_EXPORT std::string get_executable_path();
// --------------------------------------------------------------------
// some manipulators to write coloured text to terminals
......@@ -157,7 +157,7 @@ inline auto coloured(std::basic_string<CharT, Traits, Alloc> &s, StringColour fo
// --------------------------------------------------------------------
// A progress bar
class Progress
class CIFPP_EXPORT Progress
{
public:
Progress(int64_t inMax, const std::string &inAction);
......@@ -178,8 +178,8 @@ class Progress
// --------------------------------------------------------------------
// Resources
std::unique_ptr<std::istream> load_resource(std::filesystem::path name);
void add_file_resource(const std::string &name, std::filesystem::path dataFile);
void add_data_directory(std::filesystem::path dataDir);
CIFPP_EXPORT std::unique_ptr<std::istream> load_resource(std::filesystem::path name);
CIFPP_EXPORT void add_file_resource(const std::string &name, std::filesystem::path dataFile);
CIFPP_EXPORT void add_data_directory(std::filesystem::path dataDir);
} // namespace cif
include/cif++/validate.hpp
......@@ -40,7 +40,7 @@ struct category_validator;
// --------------------------------------------------------------------
class validation_error : public std::exception
class CIFPP_EXPORT validation_error : public std::exception
{
public:
validation_error(const std::string &msg);
......@@ -59,11 +59,11 @@ enum class DDL_PrimitiveType
Numb
};
DDL_PrimitiveType map_to_primitive_type(std::string_view s);
CIFPP_EXPORT DDL_PrimitiveType map_to_primitive_type(std::string_view s);
struct regex_impl;
struct type_validator
struct CIFPP_EXPORT type_validator
{
std::string m_name;
DDL_PrimitiveType m_primitive_type;
......@@ -100,7 +100,7 @@ struct type_validator
int compare(std::string_view a, std::string_view b) const;
};
struct item_validator
struct CIFPP_EXPORT item_validator
{
std::string m_tag;
bool m_mandatory;
......@@ -133,7 +133,7 @@ struct item_validator
void operator()(std::string_view value) const;
};
struct category_validator
struct CIFPP_EXPORT category_validator
{
std::string m_name;
std::vector<std::string> m_keys;
......@@ -156,7 +156,7 @@ struct category_validator
}
};
struct link_validator
struct CIFPP_EXPORT link_validator
{
int m_link_group_id;
std::string m_parent_category;
......@@ -168,7 +168,7 @@ struct link_validator
// --------------------------------------------------------------------
class validator
class CIFPP_EXPORT validator
{
public:
validator(std::string_view name)
......@@ -217,7 +217,7 @@ class validator
};
// --------------------------------------------------------------------
class validator_factory
class CIFPP_EXPORT validator_factory
{
public:
static validator_factory &instance()
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment