Rosetta  2020.28
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Classes | Typedefs | Enumerations | Functions
utility::tag Namespace Reference

Classes

class  Tag
 
class  XMLErrorHandler
 
class  XMLSchemaAttribute
 class XMLSchemaAttribute represents what we refer to in Rosetta as an option for a tag. An attribute would reside inside of a tag, such as "scorefxn" in this tag (this XML Element): <MinMover name="min" scorefxn="talaris2014"> More...
 
class  XMLSchemaComplexType
 class XMLSchemaComplexType represents the definition of the type for an element – that is, the structure of a set of elements with the same name. If an XMLSchemaElement is analogous to a utility::tag::Tag, an XMLSchemaComplexType is analogous to the wiki page describing the valid format for an instance of that Tag. More...
 
class  XMLSchemaComplexTypeGenerator
 The XMLComplexTypeSchemaGenerator is used to define the schema for a complex type as they typically occurr in Rosetta. More...
 
class  XMLSchemaComplexTypeGeneratorImpl
 
class  XMLSchemaDefinition
 The XMLSchemaDefinition class's purpose is to collect all of the elements that go into an XML Schema, to filter out the elements that are repeated (e.g. a restriction such as the "int_cslist" given in the description for XMLSchemaRestriction above may be reported twice to the XMLSchemaDefinition by several attributes that rely upon it), to detect non-identical duplicates that have the same name, and to write out the elements that it has been handed into a single string. The XMLSchemaDefinition is intended to be passed between static functions / non-class-member functions as a container for the XML Schema representations that these functions define. Such functions will always take an XMLSchemaDefinition reference as one of their input parameters. It is perfectly legitimate / recommended for one XML-schema-defining function that relies on a complexType or restriction that it does not itself define to pass its input XMLSchemaDefinition to the function that does define that complexType or restriction. More...
 
class  XMLSchemaElement
 An XMLSchema element, e.g. the FixbbMover "tag" <FixbbMover name="fixbb" task_operations="ex1,ex2"> or the And element which contains a sub-element: <And><Chain id="A"></And>. An element can be defined with an unnamed complex type in-line, or it can say that its type is that of a complex type defined elsewhere. (In XML naming a tag is a single block beginning with "<" and ending with ">", so both "<And>" and "</And>" are tags. The block between the opening and closing tags is called an element. The utility::tag::Tag class represents a complete Element, and not simply the opening or closing tag of an element. This is certainly confusing. More...
 
class  XMLSchemaModelGroup
 The ModelGroup covers four XML Schema model groups: xs:sequence, xs:choice, xs:all, and xs:group. A ModelGroup may contain any number of XMLSchemaParticles, interchanging between XMLElements and XMLModelGroups, BUT there are some fairly heavy restrictions on the xs:all model group, marginally enforced by this class and by XMLSchemaComplexType. This class is not exactly a top-level element, in that only xs:group is allowed to appear at the top level, but it is definitely worthwhile for this class to implement the write_definition funciton. More...
 
class  XMLSchemaParticle
 This abstract class is meant to represent either an XMLSChemaElement or an XMLSchemaModelGroup so that the interchangable set of these objects in a ModelGroup can be represented. I may be misusing the term "particle" in the way that it is meant within XML Schema – so the mapping of this term to the term used in XML Schema is probably imperfect. More...
 
class  XMLSchemaRepeatableCTNode
 
class  XMLSchemaRestriction
 class XMLSchemaRestriction describes a refinement on the behavior of existing types. For example, one could define a restriction representing a list of residue indexes separating commas: "15,44,102" and then describe an attribute of a complex type as having to conform to that restriction. An xml-schema validator would be able to say that an input file with "fifteen,fortyfour,onehundredandtwo" did not meet the schema. More...
 
class  XMLSchemaSimpleSubelementList
 The XMLSchemaSimpleSubelementList class defines an interface that can be used by those wishing to define a complexType that contains sub-elements. The structure of the XML Schema for the sub-elements will determined by how this list is given to the XMLSchemaComplexTypeGenerator. "simple" subelements are those which themselves contain no subelements (but may contain attributes). Also allowed are subelements that refer to previously-defined complexTypes or those that refer to previously defined xs:groups. More...
 
class  XMLSchemaTopLevelElement
 The XMLSchemaTopLevelElement class signifies a class that could be written out as an XML element, with possible sub-elemets, in an XML schema. When generating a schema, the developer will hand an instance of a class derived from an XMLSchemaTopLevelElement to an XMLSchemaDefinition object. More...
 
class  XMLSchemaType
 class XMLSchemaType represents the name of a defined type that can be used to describe either an XMLElement or an XMLAttribute. It may refer to either a complex type or to a primative type or to a simple type. More...
 
class  XMLValidationOutput
 
class  XMLValidator
 
class  XMLValidatorImpl
 

Typedefs

typedef
::utility::pointer::shared_ptr
< Tag
TagPtr
 
typedef
::utility::pointer::shared_ptr
< Tag
TagOP
 
typedef
::utility::pointer::shared_ptr
< Tag const > 
TagCOP
 
typedef
::utility::pointer::weak_ptr
< Tag
TagAP
 
typedef
::utility::pointer::weak_ptr
< Tag const > 
TagCAP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaType
XMLSchemaTypeOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaType const > 
XMLSchemaTypeCOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaAttribute
XMLSchemaAttributeOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaAttribute const > 
XMLSchemaAttributeCOP
 
typedef std::list
< utility::tag::XMLSchemaAttribute
AttributeList
 
typedef
utility::pointer::shared_ptr
< XMLSchemaElement
XMLSchemaElementOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaElement const > 
XMLSchemaElementCOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaRestriction
XMLSchemaRestrictionOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaRestriction const > 
XMLSchemaRestrictionCOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaParticle
XMLSchemaParticleOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaParticle const > 
XMLSchemaParticleCOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaModelGroup
XMLSchemaModelGroupOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaModelGroup const > 
XMLSchemaModelGroupCOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaComplexType
XMLSchemaComplexTypeOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaComplexType const > 
XMLSchemaComplexTypeCOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaElementType > 
XMLSchemaElementTypeOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaElementType const > 
XMLSchemaElementTypeCOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaDefinition
XMLSchemaDefinitionOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaDefinition const > 
XMLSchemaDefinitionCOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaSimpleSubelementList
XMLSchemaSimpleSubelementListOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaSimpleSubelementList
const > 
XMLSchemaSimpleSubelementListCOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaComplexTypeGenerator
XMLSchemaComplexTypeGeneratorOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaComplexTypeGenerator
const > 
XMLSchemaComplexTypeGeneratorCOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaRepeatableCTNode
XMLSchemaRepeatableCTNodeOP
 
typedef
utility::pointer::shared_ptr
< XMLSchemaRepeatableCTNode
const > 
XMLSchemaRepeatableCTNodeCOP
 
typedef
utility::pointer::weak_ptr
< XMLSchemaRepeatableCTNode
XMLSchemaRepeatableCTNodeAP
 
typedef
utility::pointer::weak_ptr
< XMLSchemaRepeatableCTNode
const > 
XMLSchemaRepeatableCTNodeCAP
 
typedef
utility::pointer::shared_ptr
< XMLValidator
XMLSchemaValidatorOP
 

Enumerations

enum  AutoBool { AutoBool::False = 0, AutoBool::True, AutoBool::Auto }
 
enum  XMLSchemaDataType {
  xs_string, xs_decimal, xs_integer, xs_boolean,
  xs_date, xs_time, xs_common, xs_custom
}
 The simple types provided by the XMLSchema language itself. These are not always the types that you want to use. More...
 
enum  XMLSchemaMinOccursMaxOccurs { xsminmax_unbounded = -2, xsminmax_unspecified = -1 }
 
enum  XMLSchemaRestrictionType {
  xsr_enumeration, xsr_fractionDigits, xsr_length, xsr_maxExclusive,
  xsr_maxInclusive, xsr_maxLength, xsr_minExclusive, xsr_minInclusive,
  xsr_minLength, xsr_pattern, xsr_totalDigits, xsr_whitespace
}
 
enum  XMLSchemaModelGroupType { xsmgt_sequence, xsmgt_all, xsmgt_choice, xsmgt_group }
 
enum  XMLSchemaElementCategory { xs_element_is_type_reference, xs_element_is_abstract, xs_element_is_complex_type_w_definition, xs_element_is_element_reference }
 
enum  CTGenSubelementBehavior {
  se_none, se_repeatable, se_choice_req, se_choice_opt,
  se_single_req, se_single_opt, se_single_req_ordered, se_ordered_sets
}
 
enum  XMLSchemaCommonType {
  xsct_none, xsct_int_cslist, xsct_string_cslist, xsct_int_wsslist,
  xsct_nnegative_int_cslist, xsct_nnegative_int_wsslist, xsct_real, xsct_real_cslist,
  xsct_real_cslist_w_ws, xsct_real_wsslist, xsct_bool_cslist, xsct_bool_wsslist,
  xsct_positive_integer_cslist, xsct_positive_integer_wsslist, xsct_non_negative_integer, xsct_positive_integer,
  xsct_rosetta_bool, xsct_rosetta_autobool, xsct_residue_number, xsct_residue_number_cslist,
  xsct_refpose_enabled_residue_number, xsct_refpose_enabled_residue_number_cslist, xsct_char, xsct_minimizer_type,
  xsct_size_cs_pair, xsct_chain_cslist, xsct_dssp_string, xsct_canonical_res_char,
  xsct_packer_palette, xsct_task_operation, xsct_task_operation_comma_separated_list, xsct_pose_cached_task_operation
}
 An enum listing lots of commonly-used simple types so they don't have to be added manually in lots of places. If you create an XMLSchemaType using this enum, then the corresponding restriction will be added to the XMLSchemaDefintion automatically. More...
 

Functions

std::ostream & operator<< (std::ostream &out, Tag const &tag)
 
std::ostream & operator<< (std::ostream &out, TagCOP const &tag_ptr)
 
void add_schema_restrictions_for_strings (XMLSchemaDefinition &xsd, std::string type_name, vector1< std::string > const &restrictions)
 Add a SchemaRestriction for a set of strings. Useful for enums. The type name is then used as the type when adding an attribute. More...
 
template<class Creator >
void define_xml_schema_group (typename std::map< std::string, utility::pointer::shared_ptr< Creator > > const &creator_map, std::string const &widget_group_name, std::function< std::string(std::string const &) > const &complex_type_name_for_widget_func, XMLSchemaDefinition &xsd)
 
char string_contains_gt_lt_or_ampersand (std::string const &s)
 Check if given string contain any of '<>&' and if so return found character. If no character is found return 0. More...
 
std::string chr_chains_nonrepeated ()
 
std::string name_for_common_type (XMLSchemaCommonType common_type)
 
std::ostream & operator<< (std::ostream &os, XMLSchemaCommonType common_type)
 
void indent_w_spaces (int indentation, std::ostream &os)
 
void write_min_occurs_max_occurs_if_necessary (int min_occurs, int max_occurs, std::ostream &os)
 
std::string real_regex_pattern ()
 
std::string rosetta_bool_string ()
 the set of all strings recognized as booleans according to Rosetta (in utility/string_util.cc) More...
 
std::string rosetta_autobool_string ()
 
std::string chain_cslist_string ()
 
std::string residue_number_string ()
 
std::string residue_number_cslist_string ()
 
std::string refpose_enabled_residue_number_string ()
 
std::string refpose_enabled_residue_number_cslist_string ()
 
std::string canonical_res_char_string ()
 
std::string task_operation_name_pattern ()
 
void activate_common_simple_type (utility::tag::XMLSchemaDefinition &xsd, XMLSchemaCommonType common_type)
 
AttributeListoperator+ (AttributeList &attributes, XMLSchemaAttribute const &attribute_to_append)
 
std::string restriction_type_name (XMLSchemaRestrictionType type)
 
std::ostream & operator<< (std::ostream &os, XMLSchemaRestrictionType type)
 
std::string xs_model_group_name (XMLSchemaModelGroupType xsmgt)
 
std::ostream & operator<< (std::ostream &os, XMLSchemaModelGroupType type)
 
XMLSchemaRestriction integer_range_restriction (std::string const &name, int lower_inclusive, int upper_inclusive)
 Convenience function for defining an inclusive range restriction. More...
 
XMLSchemaAttribute optional_name_attribute (std::string const &description="")
 This function creates an attribute named "name" of type xs_string that is optional; naming is not always required – it is not even mostly required. This is probably the function you need; very few classes actually need to have a name – the name is often only used by the function reading in the name, but there are reasonable times when a Mover, e.g. could go nameless – for instance, in the fixbb_jd3 application, a PackRotamersMover can be given as a subtag of the <Job> tag. In this case, the PackRotamersMover doesn't need to be given a name. More...
 
XMLSchemaAttribute required_name_attribute (std::string const &description="")
 This function creates an attribute named "name" of type xs_string that is required; naming is not always required – it is not even mostly required. This function is probably not what you need. Use with care. See comments for the "optional_name_attribute" function above. More...
 
void append_name_and_attributes_to_complex_type (AttributeList const &attributes, XMLSchemaComplexType &type_definition)
 append an attribute of "name" with type "xs:string" along with the other attributes in the input attribute list to the input complex type. More...
 
void append_required_name_and_attributes_to_complex_type (AttributeList const &attributes, XMLSchemaComplexType &type_definition)
 append a required attribute of "name" with type "xs:string" along with the other attributes in the input attribute list to the input complex type. More...
 
bool attribute_w_name_in_attribute_list (std::string const &attname, AttributeList const &attlist)
 check whether an attribute with name attname already exists in AttributeList attlist to avoid collisions More...
 
std::string element_type_name (xmlElementType element_type)
 
int length_of_message (const char *message, va_list args)
 
char * make_message (int length, const char *message, va_list args)
 
void handle_structured_xml_error (void *ctxt, xmlErrorPtr error)
 
void handle_xml_error (void *ctxt, char const *message,...)
 
void handle_xml_warning (void *ctxt, char const *message,...)
 
void print_node_stack (utility::vector1< xmlNode * > const &node_stack, std::ostringstream &oss)
 
std::string concat_stringlist (std::list< std::string > const &strings)
 
int recurse_through_tree (xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node, XMLErrorHandler handler)
 
XMLValidationOutput validate_xml_against_xsd (std::string const &xml_string, std::string const &xsd_string)
 
XMLValidationOutput test_if_schema_is_valid (std::string const &xsd_string)
 

Typedef Documentation

typedef ::utility::pointer::weak_ptr< Tag > utility::tag::TagAP
typedef ::utility::pointer::weak_ptr< Tag const > utility::tag::TagCAP
typedef ::utility::pointer::shared_ptr< Tag const > utility::tag::TagCOP
typedef ::utility::pointer::shared_ptr< Tag > utility::tag::TagOP
typedef ::utility::pointer::shared_ptr< Tag > utility::tag::TagPtr
typedef utility::pointer::shared_ptr< XMLSchemaAttribute const > utility::tag::XMLSchemaAttributeCOP
typedef utility::pointer::shared_ptr< XMLSchemaDefinition const > utility::tag::XMLSchemaDefinitionCOP
typedef utility::pointer::shared_ptr< XMLSchemaElement const > utility::tag::XMLSchemaElementCOP
typedef utility::pointer::shared_ptr< XMLSchemaElementType const > utility::tag::XMLSchemaElementTypeCOP
typedef utility::pointer::shared_ptr< XMLSchemaElementType > utility::tag::XMLSchemaElementTypeOP
typedef utility::pointer::shared_ptr< XMLSchemaModelGroup const > utility::tag::XMLSchemaModelGroupCOP
typedef utility::pointer::shared_ptr< XMLSchemaParticle const > utility::tag::XMLSchemaParticleCOP
typedef utility::pointer::shared_ptr< XMLSchemaType const > utility::tag::XMLSchemaTypeCOP
typedef utility::pointer::shared_ptr< XMLSchemaType > utility::tag::XMLSchemaTypeOP
typedef utility::pointer::shared_ptr< XMLValidator > utility::tag::XMLSchemaValidatorOP

Enumeration Type Documentation

Enumerator
False 
True 
Auto 
Enumerator
se_none 
se_repeatable 
se_choice_req 
se_choice_opt 
se_single_req 
se_single_opt 
se_single_req_ordered 
se_ordered_sets 

An enum listing lots of commonly-used simple types so they don't have to be added manually in lots of places. If you create an XMLSchemaType using this enum, then the corresponding restriction will be added to the XMLSchemaDefintion automatically.

Enumerator
xsct_none 
xsct_int_cslist 
xsct_string_cslist 
xsct_int_wsslist 
xsct_nnegative_int_cslist 
xsct_nnegative_int_wsslist 
xsct_real 
xsct_real_cslist 
xsct_real_cslist_w_ws 
xsct_real_wsslist 
xsct_bool_cslist 
xsct_bool_wsslist 
xsct_positive_integer_cslist 
xsct_positive_integer_wsslist 
xsct_non_negative_integer 
xsct_positive_integer 
xsct_rosetta_bool 
xsct_rosetta_autobool 
xsct_residue_number 
xsct_residue_number_cslist 
xsct_refpose_enabled_residue_number 
xsct_refpose_enabled_residue_number_cslist 
xsct_char 
xsct_minimizer_type 
xsct_size_cs_pair 
xsct_chain_cslist 
xsct_dssp_string 
xsct_canonical_res_char 
xsct_packer_palette 
xsct_task_operation 
xsct_task_operation_comma_separated_list 
xsct_pose_cached_task_operation 

The simple types provided by the XMLSchema language itself. These are not always the types that you want to use.

In particular, xs_decimal does not support scientific notation, so you probably want to use xsct_real (defined in the XMLSchemaCommonType enumeration in XMLSchemaGeneration.hh) to represent real-valued numbers.

Also, the boolean-value reading function in tag::getOption< bool > accepts more values for "true" and "false" than the xs_boolean so you want to use xsct_rosetta_bool in your schemas instead.

Enumerator
xs_string 
xs_decimal 
xs_integer 
xs_boolean 
xs_date 
xs_time 
xs_common 
xs_custom 
Enumerator
xs_element_is_type_reference 
xs_element_is_abstract 
xs_element_is_complex_type_w_definition 
xs_element_is_element_reference 
Enumerator
xsminmax_unbounded 
xsminmax_unspecified 
Enumerator
xsmgt_sequence 
xsmgt_all 
xsmgt_choice 
xsmgt_group 
Enumerator
xsr_enumeration 
xsr_fractionDigits 
xsr_length 
xsr_maxExclusive 
xsr_maxInclusive 
xsr_maxLength 
xsr_minExclusive 
xsr_minInclusive 
xsr_minLength 
xsr_pattern 
xsr_totalDigits 
xsr_whitespace 

Function Documentation

void utility::tag::activate_common_simple_type ( utility::tag::XMLSchemaDefinition xsd,
XMLSchemaCommonType  common_type 
)

References utility::tag::XMLSchemaRestriction::add_restriction(), utility::tag::XMLSchemaDefinition::add_top_level_element(), utility::tag::XMLSchemaRestriction::base_type(), canonical_res_char_string(), chain_cslist_string(), utility::tag::XMLSchemaRestriction::name(), name_for_common_type(), basic::options::OptionKeys::james::real, real_regex_pattern(), refpose_enabled_residue_number_cslist_string(), refpose_enabled_residue_number_string(), residue_number_cslist_string(), residue_number_string(), rosetta_autobool_string(), rosetta_bool_string(), task_operation_name_pattern(), xs_integer, xs_string, xsct_bool_cslist, xsct_bool_wsslist, xsct_canonical_res_char, xsct_chain_cslist, xsct_char, xsct_dssp_string, xsct_int_cslist, xsct_int_wsslist, xsct_minimizer_type, xsct_nnegative_int_cslist, xsct_nnegative_int_wsslist, xsct_non_negative_integer, xsct_packer_palette, xsct_pose_cached_task_operation, xsct_positive_integer, xsct_positive_integer_cslist, xsct_positive_integer_wsslist, xsct_real, xsct_real_cslist, xsct_real_cslist_w_ws, xsct_real_wsslist, xsct_refpose_enabled_residue_number, xsct_refpose_enabled_residue_number_cslist, xsct_residue_number, xsct_residue_number_cslist, xsct_rosetta_autobool, xsct_rosetta_bool, xsct_size_cs_pair, xsct_string_cslist, xsct_task_operation, xsct_task_operation_comma_separated_list, xsr_enumeration, xsr_maxLength, xsr_minInclusive, and xsr_pattern.

Referenced by utility::tag::XMLSchemaAttribute::prepare_for_output(), utility::tag::XMLSchemaRestriction::prepare_for_output(), and utility::tag::XMLSchemaElement::prepare_for_output().

void utility::tag::add_schema_restrictions_for_strings ( XMLSchemaDefinition &  xsd,
std::string  type_name,
vector1< std::string > const &  restrictions 
)

Add a SchemaRestriction for a set of strings. Useful for enums. The type name is then used as the type when adding an attribute.

Example: attlist+ XMLScemaAttribute(tag_name, type_name, description);

References utility::tag::XMLSchemaRestriction::add_restriction(), utility::tag::XMLSchemaDefinition::add_top_level_element(), utility::tag::XMLSchemaRestriction::base_type(), utility::tag::XMLSchemaRestriction::name(), res, xs_string, and xsr_enumeration.

void utility::tag::append_name_and_attributes_to_complex_type ( AttributeList const &  attributes,
XMLSchemaComplexType &  type_definition 
)

append an attribute of "name" with type "xs:string" along with the other attributes in the input attribute list to the input complex type.

Most XML tags have a "name" attribute; this function does not require that the name be provided.

References utility::tag::XMLSchemaComplexType::add_attribute(), utility::tag::XMLSchemaComplexType::add_attributes(), and optional_name_attribute().

void utility::tag::append_required_name_and_attributes_to_complex_type ( AttributeList const &  attributes,
XMLSchemaComplexType &  type_definition 
)

append a required attribute of "name" with type "xs:string" along with the other attributes in the input attribute list to the input complex type.

Most XML tags in Rosetta have a "name" attribute; this function appends an attribute "name" and states that the attribute is required

References utility::tag::XMLSchemaComplexType::add_attribute(), utility::tag::XMLSchemaComplexType::add_attributes(), and required_name_attribute().

bool utility::tag::attribute_w_name_in_attribute_list ( std::string const &  attname,
AttributeList const &  attlist 
)
std::string utility::tag::canonical_res_char_string ( )
std::string utility::tag::chain_cslist_string ( )
std::string utility::tag::chr_chains_nonrepeated ( )

Referenced by chain_cslist_string().

std::string utility::tag::concat_stringlist ( std::list< std::string > const &  strings)
template<class Creator >
void utility::tag::define_xml_schema_group ( typename std::map< std::string, utility::pointer::shared_ptr< Creator > > const &  creator_map,
std::string const &  widget_group_name,
std::function< std::string(std::string const &) > const &  complex_type_name_for_widget_func,
XMLSchemaDefinition &  xsd 
)

Creator must define a single function: provide_xml_schema()

Exceptions
Inthe event that the Creator does not define a complex type with the name coming from the complex_type_name_for_widget_func, this function will throw a utility::excn::Excn_Msg_Excption. Classes calling this function should wrap it in a try/catch block and append extra information informing the user (presumably the programmer) which function should be called when defining the schema for the offending class.

References utility::tag::XMLSchemaDefinition::add_top_level_element(), utility::tag::XMLSchemaModelGroup::append_particle(), CREATE_EXCEPTION, test.T009_Exceptions::e, utility::tag::XMLSchemaModelGroup::group_name(), utility::tag::XMLSchemaDefinition::has_top_level_element(), utility::excn::Exception::msg(), and xsmgt_choice.

std::string utility::tag::element_type_name ( xmlElementType  element_type)
void utility::tag::handle_structured_xml_error ( void *  ctxt,
xmlErrorPtr  error 
)
void utility::tag::handle_xml_error ( void *  ctxt,
char const *  message,
  ... 
)
void utility::tag::handle_xml_warning ( void *  ctxt,
char const *  message,
  ... 
)
void utility::tag::indent_w_spaces ( int  indentation,
std::ostream &  os 
)
XMLSchemaRestriction utility::tag::integer_range_restriction ( std::string const &  name,
int  lower,
int  upper 
)
int utility::tag::length_of_message ( const char *  message,
va_list  args 
)
char* utility::tag::make_message ( int  length,
const char *  message,
va_list  args 
)
std::string utility::tag::name_for_common_type ( XMLSchemaCommonType  common_type)
AttributeList & utility::tag::operator+ ( AttributeList &  attributes,
XMLSchemaAttribute const &  attribute_to_append 
)
std::ostream & utility::tag::operator<< ( std::ostream &  os,
XMLSchemaCommonType  common_type 
)
std::ostream & utility::tag::operator<< ( std::ostream &  os,
XMLSchemaRestrictionType  type 
)
std::ostream & utility::tag::operator<< ( std::ostream &  out,
Tag const &  tag 
)
std::ostream & utility::tag::operator<< ( std::ostream &  out,
TagCOP const &  tag_ptr 
)
std::ostream & utility::tag::operator<< ( std::ostream &  os,
XMLSchemaModelGroupType  type 
)

References xs_model_group_name().

XMLSchemaAttribute utility::tag::optional_name_attribute ( std::string const &  desc)

This function creates an attribute named "name" of type xs_string that is optional; naming is not always required – it is not even mostly required. This is probably the function you need; very few classes actually need to have a name – the name is often only used by the function reading in the name, but there are reasonable times when a Mover, e.g. could go nameless – for instance, in the fixbb_jd3 application, a PackRotamersMover can be given as a subtag of the <Job> tag. In this case, the PackRotamersMover doesn't need to be given a name.

References xs_string.

Referenced by utility::tag::XMLSchemaComplexTypeGenerator::add_optional_name_attribute(), append_name_and_attributes_to_complex_type(), basic::resource_manager::resource_loader_xsd_type_definition_w_attributes(), basic::resource_manager::resource_loader_xsd_type_definition_w_attributes_and_repeatable_subelements(), basic::resource_manager::locator::xsd_type_definition_w_attributes(), and basic::resource_manager::locator::xsd_type_definition_w_attributes_and_repeatable_subelements().

void utility::tag::print_node_stack ( utility::vector1< xmlNode * > const &  node_stack,
std::ostringstream &  oss 
)
std::string utility::tag::real_regex_pattern ( )
int utility::tag::recurse_through_tree ( xmlSchemaValidCtxtPtr  ctxt,
xmlNodePtr  node,
XMLErrorHandler  handler 
)
std::string utility::tag::refpose_enabled_residue_number_cslist_string ( )
std::string utility::tag::refpose_enabled_residue_number_string ( )
XMLSchemaAttribute utility::tag::required_name_attribute ( std::string const &  desc)

This function creates an attribute named "name" of type xs_string that is required; naming is not always required – it is not even mostly required. This function is probably not what you need. Use with care. See comments for the "optional_name_attribute" function above.

References utility::tag::XMLSchemaAttribute::required_attribute(), and xs_string.

Referenced by utility::tag::XMLSchemaComplexTypeGenerator::add_required_name_attribute(), append_required_name_and_attributes_to_complex_type(), and basic::resource_manager::ResourceManager::schema_for_resource_definition_file().

std::string utility::tag::residue_number_cslist_string ( )
std::string utility::tag::residue_number_string ( )
std::string utility::tag::restriction_type_name ( XMLSchemaRestrictionType  type)
std::string utility::tag::rosetta_autobool_string ( )
std::string utility::tag::rosetta_bool_string ( )

the set of all strings recognized as booleans according to Rosetta (in utility/string_util.cc)

Referenced by activate_common_simple_type(), and rosetta_autobool_string().

char utility::tag::string_contains_gt_lt_or_ampersand ( std::string const &  str)
std::string utility::tag::task_operation_name_pattern ( )
XMLValidationOutput utility::tag::test_if_schema_is_valid ( std::string const &  xsd_string)
XMLValidationOutput utility::tag::validate_xml_against_xsd ( std::string const &  xml_string,
std::string const &  xsd_string 
)
void utility::tag::write_min_occurs_max_occurs_if_necessary ( int  min_occurs,
int  max_occurs,
std::ostream &  os 
)
std::string utility::tag::xs_model_group_name ( XMLSchemaModelGroupType  xsmgt)

References xsmgt_all, xsmgt_choice, xsmgt_group, and xsmgt_sequence.

Referenced by operator<<().