gemmi::cif namespace

Contents

Namespaces

namespace numb_rules
namespace rules

Classes

template<typename Rule>
struct Action
template<>
struct Action<rules::datablockname>
template<>
struct Action<rules::endframe>
template<>
struct Action<rules::framename>
template<>
struct Action<rules::item_tag>
template<>
struct Action<rules::item_value>
template<>
struct Action<rules::loop>
template<>
struct Action<rules::loop_tag>
template<>
struct Action<rules::loop_value>
template<>
struct Action<rules::str_global>
template<>
struct Action<rules::str_loop>
template<typename Rule>
struct ActionNumb
template<>
struct ActionNumb<numb_rules::exponent>
template<>
struct ActionNumb<numb_rules::fraction>
template<>
struct ActionNumb<numb_rules::numb>
template<>
struct ActionNumb<numb_rules::uint_digit>
struct Block
template<typename Rule>
struct CheckAction
template<>
struct CheckAction<rules::missing_value>
class Column
struct CommentArg
struct Document
struct FrameArg
struct Item
struct Loop
struct LoopArg
struct Table

Enums

enum class ItemType: unsigned char { Pair, Loop, Frame, Comment, Erased }
enum class Style { Simple, NoBlankLines, PreferPairs, Pdbx, Indent35 }

Typedefs

using Pair = std::array<std::string, 2>

Functions

template<typename Rule>
auto error_message() -> const std::string&
template<typename Input>
void parse_input(Document& d, Input&& in)
template<typename Input>
auto read_input(Input&& in) -> Document
auto read_file(const std::string& filename) -> Document
auto read_string(const std::string& data) -> Document
auto read_memory(const char* data, size_t size, const char* name) -> Document
auto read_cstream(std::FILE* f, size_t bufsize, const char* name) -> Document
auto read_istream(std::istream& is, size_t bufsize, const char* name) -> Document
template<typename Input>
auto check_syntax(Input&& in, std::string* msg) -> bool
template<typename T>
auto read(T&& input) -> Document
template<typename T>
auto check_syntax_any(T&& input, std::string* msg) -> bool
auto char_table(char c) -> uint8_t
void assert_tag(const std::string& tag)
void ensure_mmcif_category(std::string& cat)
auto is_null(const std::string& value) -> bool
auto as_string(const std::string& value) -> std::string
auto as_string(const std::string* value) -> std::string
auto as_char(const std::string& value, char null) -> char
auto as_int(const std::string& str) -> int
auto as_int(const std::string& str, int null) -> int
auto as_any(const std::string& s, int null) -> int
auto as_any(const std::string& s, char null) -> char
void cif_fail(const std::string& source, const Block& b, const Item& item, const std::string& s)
void check_for_missing_values_in_block(const Block& block, const std::string& source)
void check_for_missing_values(const Document& d)
void check_for_duplicates(const Document& d)
auto is_text_field(const std::string& val) -> bool
auto quote(std::string v) -> std::string
auto json_type_as_string(sajson::type t) -> std::string
auto as_cif_value(const sajson::value& val) -> std::string
void fill_document_from_sajson(Document& d, const sajson::document& s)
auto read_mmjson_insitu(char* buffer, size_t size, const std::string& name = "mmJSON") -> Document
auto read_mmjson_file(const std::string& path) -> Document
template<typename T>
auto read_mmjson(T&& input) -> Document
auto is_numb(const std::string& s) -> bool
auto as_number(const std::string& s, double nan = NAN) -> double
auto as_any(const std::string& s, float null) -> float
auto as_any(const std::string& s, double null) -> double
void write_text_field(std::ostream& os, const std::string& value)
void write_out_pair(std::ostream& os, const std::string& name, const std::string& value, Style style)
void write_out_loop(std::ostream& os, const Loop& loop, Style style)
void write_out_item(std::ostream& os, const Item& item, Style style)
auto should_be_separted_(const Item& a, const Item& b) -> bool
void write_cif_to_stream(std::ostream& os, const Document& doc, Style s = Style::Simple)