assert_bracket_operator_access< ContainerType > | A guard that ensures that operator[] access is possible. Throws a verbose compile time error if access is not possible |
assert_bracket_operator_access< std::deque< ElementType > > | Specialization: Allow operator[] if the underlying container is a std::deque<> |
assert_bracket_operator_access< std::vector< ElementType > > | Specialization: Allow operator[] if the underlying container is a std::vector<> |
bad_file_format_exception | Provides an exception for the case a parser problem occurs |
bndcell_filler< ElementTag, k > | Worker class that sets up the boundary k-cells of a n-cell |
bndcell_filler< hexahedron_tag, 1 > | Fills a segment or a domain with the edges of a hexahedron |
bndcell_filler< hexahedron_tag, 2 > | Fills a segment or a domain with the facets of a hexahedron |
bndcell_filler< quadrilateral_tag, 1 > | Fills a segment or a domain with the edges/facets of a quadrilateral |
bndcell_filler< tetrahedron_tag, 1 > | Fills a segment or a domain with the edges of a tetrahedron |
bndcell_filler< tetrahedron_tag, 2 > | Fills a segment or a domain with the edges/facets of a tetrahedron |
bndcell_filler< triangle_tag, 1 > | Fills a segment or a domain with the edges of a triangle |
bndcell_handling< ConfigType, T, dim > | Metafunction for the storage of boundary k-cells of an n-cell. By default, pointers to boundary k-cells are stored on n-cells |
bndcell_handling< ConfigType, domain_t< ConfigType >, 0 > | Specialization of the k-cell handling for the domain. Vertices always uses full handling (it is the defining entity of an element) |
bndcell_handling< ConfigType, domain_t< ConfigType >, dim > | Specialization of the k-cell handling for the domain |
bndcell_handling< ConfigType, segment_t< ConfigType >, 0 > | Specialization of the k-cell handling for segments. Vertices always uses full handling (it is the defining entity of an element) |
bndcell_handling< ConfigType, segment_t< ConfigType >, dim > | Specialization of the k-cell handling for segments |
bndcell_handling< ConfigType, T, 0 > | Specialization of the boundary k-cell handling for vertices. Vertex level always uses full handling (it is the defining entity of an element) |
bndcell_orientation< ConfigType, T, dim > | Metafunction for local-to-global-orienters: By default, orienters are stored on n-cells |
bndcells< ElementTag, level > | Holds the topological information about boundary cells for a n-cell |
bndcells< hexahedron_tag, 0 > | Topological description of the boundary 0-cells of a hexahedron |
bndcells< hexahedron_tag, 1 > | Topological description of the boundary 1-cells of a hexahedron |
bndcells< hexahedron_tag, 2 > | Topological description of the boundary 2-cells of a hexahedron |
bndcells< hypercube_tag< 1 >, 0 > | Topological description of the 0-cells of a line |
bndcells< quadrilateral_tag, 0 > | Topological description of the boundary 0-cells of a quadrilateral |
bndcells< quadrilateral_tag, 1 > | Topological description of the boundary 1-cells of a quadrilateral |
bndcells< simplex_tag< 1 >, 0 > | Topological description of the 0-cells of a line |
bndcells< tetrahedron_tag, 0 > | Topological description of the boundary 0-cells of a tetrahedron |
bndcells< tetrahedron_tag, 1 > | Topological description of the boundary 1-cells of a tetrahedron |
bndcells< tetrahedron_tag, 2 > | Topological description of the boundary 2-cells of a tetrahedron |
bndcells< triangle_tag, 0 > | Topological description of the boundary 0-cells (vertices) of a triangle |
bndcells< triangle_tag, 1 > | Topological description of the boundary 1-cells (edges) of a triangle |
boundary_key< T > | A key type for storing boundary information on n-cells, segments and domains |
boundary_key< domain_t< ConfigType > > | Specialization for domains |
boundary_key< element_t< ConfigType, ElementTag > > | Specialization for n-cells |
boundary_key< segment_t< ConfigType > > | Specialization for segments |
boundary_ncell_layer< ConfigType, ElementTag, dim, handling_tag, orienter_tag, LevelNull > | A class holding all information about boundary k-cells of a n-cell |
boundary_ncell_layer< ConfigType, ElementTag, 0, handling_tag, orienter_tag, true > | Specialization for the vertex level. Recursion ends here |
boundary_ncell_layer< ConfigType, ElementTag, dim, full_handling_tag, full_handling_tag, false > | Implementation of full storage of k-cells including orientations |
boundary_ncell_layer< ConfigType, ElementTag, dim, full_handling_tag, no_handling_tag, false > | Implementation of boundary k-cell storage without orientation |
boundary_ncell_layer< ConfigType, ElementTag, dim, no_handling_tag, orienter_tag, false > | Implementation of the case that boundary k-cells are not stored at all |
boundary_setter< dim > | Helper struct for setting boundary flag of lower level elements of a facet |
boundary_setter< -1 > | Ends the recursion below the vertex level |
cannot_open_file_exception | Provides an exception for the case a file cannot be opened |
cartesian_cs< d > | Provides the basic operations in a cartesian coordinate system |
cartesian_point< PointType > | Convenience metafunction for the conversion to Cartesian coordinates |
char_to_lower< dummy > | Functor for conversion to lowercase (avoids tolower()) |
cobnd_proxy< T, U > | A proxy object for cheaper setup of range objects using the ncells<>() function |
coboundary_key< T, dim > | A key used for ViennaData to store coboundary information on n-cells |
config< T > | Metafunction returning the configuration class of a topological element |
config< domain_t< ConfigType > > | Metafunction returning the configuration class of a topological element. Specialization for a domain |
config< element_t< ConfigType, ElementTag > > | Metafunction returning the configuration class of a topological element. Specialization for a n-cell |
config< segment_t< ConfigType > > | Metafunction returning the configuration class of a topological element. Specialization for a segment |
const_cobnd_proxy< T, U > | A proxy object for cheaper setup of range objects using the ncells<>() function |
const_ncell_proxy< T > | A proxy class for retrieving const n-cell ranges |
const_ncell_range< T, dim > | Meta function for returning a const-range of n-cells |
const_ncell_range< domain_t< config_type >, dim, false > | Main const-range class. Specialization for use with const-iteration or access to k-cells on the domain |
const_ncell_range< element_t< Config, ElementTag >, dim > | Const Range type retrieval for boundary and coboundary iteration |
const_ncell_range< element_t< config_type, tag >, dim, false > | The main const range object for iteration or direct access of boundary k-cells of a n-cell |
const_ncell_range< element_t< config_type, tag >, dim, true > | The range class for const iteration and access of coboundary k-cells of a n-cell, k>n |
const_ncell_range< segment_t< config_type >, dim, false > | Main const-range class. Specialization for use with const iteration or const access to k-cells of a segment |
const_on_element_iterator< ElementType > | Iterator class for const iteration over a range of elements given by a container of pointers |
const_on_segment_iterator< IteratorType, ElementType > | Iterator for const iteration over n-cells of a segment |
coordinate_converter< FromPointType, ToPointType, FromCoordinateSystem, ToCoordinateSystem > | A conversion facility for transformations between coordinate systems |
coordinate_converter< FromPointType, ToPointType, cartesian_cs< 2 >, polar_cs > | A functor for the transformation from two-dimensional Cartesian coordinates to polar coodinates |
coordinate_converter< FromPointType, ToPointType, cartesian_cs< 3 >, cylindrical_cs > | A functor for the transformation from three-dimensional Cartesian coordinates to cylindrical coodinates |
coordinate_converter< FromPointType, ToPointType, cartesian_cs< 3 >, spherical_cs > | A functor for the transformation from three-dimensional Cartesian coordinates to spherical coodinates |
coordinate_converter< FromPointType, ToPointType, cylindrical_cs, cartesian_cs< 3 > > | A functor for the transformation from cylindrical coodinates to three-dimensional Cartesian coordinates |
coordinate_converter< FromPointType, ToPointType, cylindrical_cs, spherical_cs > | A functor for the transformation from cylindrical coordinates to spherical coodinates |
coordinate_converter< FromPointType, ToPointType, polar_cs, cartesian_cs< 2 > > | A functor for the transformation from polar coordinates to two-dimensional Cartesian coordinates |
coordinate_converter< FromPointType, ToPointType, spherical_cs, cartesian_cs< 3 > > | A functor for the transformation from spherical coodinates to three-dimensional Cartesian coordinates |
coordinate_converter< FromPointType, ToPointType, spherical_cs, cylindrical_cs > | A functor for the transformation from spherical coodinates to cylindrical coordinates |
coordinate_system< PointType > | Returns the coordinate system of a point. Must be specialized for a user-provided point type |
coordinate_system< point_t< CoordType, CoordinateSystem > > | Returns the coordinate system of a point. Specialization for a ViennaGrid point |
cross_prod_impl< PointType, 1 > | Implementation of the cross product calculation in 1d for compatibility. Returns the zero-vector |
cross_prod_impl< PointType, 2 > | Implementation of the cross product calculation in 2d for compatibility. Returns the zero-vector |
cross_prod_impl< PointType, 3 > | Implementation of the cross product calculation in 3d |
cs_base< CSystem > | Common base for all non-cartesian coordinate systems |
cylindrical_cs | Provides the basic operations in a cylindrical coordinate system (rho, theta, z) |
data_accessor_interface< ElementType > | The interface for all data accessor wrappers. Uses type erasure to wrap the templated wrappers into a single container |
data_accessor_wrapper< ElementType > | The final wrapper class for IO implementations. Provides a uniform type for all quantity types on a n-cell |
dimension< point_t< CoordType, CoordinateSystem > > | Returns the geometric dimension of a point. Specialization for a ViennaGrid point |
dimension_tag< d > | A helper tag for dispatches based on the geometrical or topological dimension |
domain< ConfigType > | Metafunction for returning the domain type for a given configuration class |
domain_iterators< Config, dim, cell_level > | Helper for iterator construction for iteration over the whole domain |
domain_iterators< Config, 0, cell_level > | Helper for iterator construction for vertex iteration over the whole domain |
domain_iterators< Config, cell_level, cell_level > | Helper for iterator construction for cell iteration over the whole domain |
domain_layers< Config, dim, is_cell, STOR > | Class holding all n-cells of a particular topological dimension n. Uses recursive inheritance similar to n-cells themselves |
domain_layers< Config, 0, is_cell, STOR > | Specialization for the vertex level. Terminates the recursive inheritance |
domain_layers< Config, dim, false, no_handling_tag > | Specialization of a domin layer without the storage of n-cells |
domain_layers< Config, dim, true, full_handling_tag > | Specialization for the cell level |
domain_segment_container< DomainType, SegmentType > | Class responsible for holding the segments inside a domain |
domain_subcell_iterator< ElementType, MapIterator > | Iterator over non-vertices and non-cells on a domain |
domain_t< Config > | The domain class. Assembled at compile time by recursive inheritance for each topological level by the detail::domain_layers class |
DXHelper< DIM > | A helper class returning dimension-dependent attribute strings |
DXHelper< 1 > | |
DXHelper< 2 > | |
DXHelper< 3 > | |
element_container< domain_t< ConfigType >, 0, cell_level > | Metafunction returning the container used for storing the n-cells in the domain. Specialization for a vertices |
element_container< domain_t< ConfigType >, cell_level, cell_level > | Metafunction returning the container used for storing the n-cells in the domain. Specialization for a cells |
element_container< domain_t< ConfigType >, dim, cell_level > | Metafunction returning the container used for storing the n-cells in the domain |
element_container< element_t< Config, ElementTag >, dim, cell_level > | Returns the internal storage type of ranges for boundary k-cells |
element_container< segment_t< config_type >, 0, cell_level > | Metafunction returning the internal storage scheme of a segment at vertex level |
element_container< segment_t< config_type >, cell_level, cell_level > | Metafunction returning the internal storage scheme of a segment at cell level |
element_container< segment_t< config_type >, dim, cell_level > | Metafunction returning the internal storage scheme of a segment at non-vertex and non-cell level |
element_id_handler< ConfigType, ElementTag > | Metafunction that returns the ID handling class of an n-cell |
element_key< ConfigType, ElementType > | A key type that uniquely identifies an element by its vertices |
element_orientation< num_vertices > | A permutator for mapping local orientations to global vertices of a boundary k-cell |
element_refinement< tetrahedron_tag > | Class specialization for the refinement of a tetrahedron: A LOT of spaghetti-code to follow |
element_refinement< triangle_tag > | Specialization of the refinement class for a triangle |
element_t< ConfigType, ElementTag > | The main n-cell class. Assembled by recursive inheritance |
element_t< ConfigType, point_tag > | Specialization of the main n-cell class for vertices. Does not need to do any recursive inheritance here |
ELEMENT_TAG_TO_VTK_TYPE< ElementTag > | Translates element tags to VTK type identifiers |
ELEMENT_TAG_TO_VTK_TYPE< hexahedron_tag > | Specialization for a hexahedron |
ELEMENT_TAG_TO_VTK_TYPE< hypercube_tag< 1 > > | Specialization for a line (one-dimensional hypercube) |
ELEMENT_TAG_TO_VTK_TYPE< quadrilateral_tag > | Specialization for a quadrilateral |
ELEMENT_TAG_TO_VTK_TYPE< simplex_tag< 1 > > | Specialization for a line (one-dimensional simplex) |
ELEMENT_TAG_TO_VTK_TYPE< tetrahedron_tag > | Specialization for a tetrahedron |
ELEMENT_TAG_TO_VTK_TYPE< triangle_tag > | Specialization for a triangle |
ElementIteratorChecker< ElementTag, level, handling_tag > | A helper class that checks whether a certain iterator is available |
ElementIteratorChecker< ElementTag, level, full_handling_tag > | Specialization for an available iterator |
ElementKeyStorageType< ConfigType, ElementType, IDHandler > | Internal helper class: holds an ordered number of vertices. Comparisons also take permutations into account |
ElementKeyStorageType< ConfigType, ElementType, integral_id > | |
full_handling_tag | A tag denoting full storage of (boundary) k-cells of a certain topological dimension |
global_scalar_data_accessor< ElementType, KeyType, DataType > | Wrapper: Access scalar-valued data for all elements in the domain |
global_vector_data_accessor< ElementType, KeyType, DataType > | Wrapper: Access vector-valued data for all elements in the domain |
hexahedral_3d | Predefined configuration class for three-dimensional hypercube cells (hexahedra) in a 3d geometry using Cartesian coordinates |
hypercube_tag< 1 > | Topological description of a 1-cell (line). Same as simplex_tag<1> |
hypercube_tag< 2 > | Topological description of a quadrilateral |
hypercube_tag< 3 > | A hypercube of dimension 3, aka. hexahedron |
id_ptr_compare | Helper class for comparing the ID of n-cells, for which only the pointers are available. Used as comparison in std::map |
inf_tag | Tag for denoting the infinity-norm |
inner_prod_impl< PointType, 1 > | Implementation of the inner product in one dimension |
inner_prod_impl< PointType, 2 > | Implementation of the inner product in two dimensions |
inner_prod_impl< PointType, 3 > | Implementation of the inner product in three dimensions |
integral_id | ID handler class for IDs of type long. Has to be used for dense quantity storage with ViennaData |
interface_key | A key used for ViennaData in order to store interface information |
interface_setter< dim > | Helper struct for setting interface flag of boundary k-cells of a facet |
interface_setter< -1 > | Specialization that stops recursion below the vertex level |
is_smaller< a, b > | Helper function for less-than comparison at compile time |
iterator< element_t< config_type, tag >, dim > | Returns the iterator for iteration over a range |
iterator< viennagrid::const_ncell_range< T, dim, is_coboundary >, 0 > | Specialization of the iterator metafunction for returning the correct iterator from a const range |
iterator< viennagrid::ncell_range< T, dim, is_coboundary >, 0 > | Specialization of the iterator metafunction for returning the correct iterator from a range |
IteratorChecker< ElementType, level > | Class that checks the validity of the requested iterator |
IteratorChecker< element_t< Config, ElementTag >, level > | Class that checks the validity of the requested iterator |
key_dispatch< viennagrid::boundary_key< viennagrid::domain_t< ConfigType > > > | |
line_1d | Predefined configuration class for one-dimensional simplex cells (lines) in a 1d geometry using Cartesian coordinates |
line_2d | Predefined configuration class for one-dimensional simplex cells (lines) in a 2d geometry using Cartesian coordinates |
line_3d | Predefined configuration class for one-dimensional simplex cells (lines) in a 3d geometry using Cartesian coordinates |
local_refinement_tag | A tag denoting local refinement |
ncell< Config, dim, cell_level > | Metafunction for the type retrieval of n-cells |
ncell< Config, cell_level, cell_level > | Metafunction for the type retrieval of n-cells. Specialization for the cells |
ncell_proxy< T > | A proxy class for retrieving n-cell ranges |
ncell_range< T, dim > | Meta function for returning a range of n-cells |
ncell_range< domain_t< config_type >, dim, false > | Main range class. Specialization for use with iteration or access to k-cells on the domain |
ncell_range< element_t< Config, ElementTag >, dim > | Range type retrieval for boundary and coboundary iteration |
ncell_range< element_t< config_type, tag >, dim, false > | The main non-const range object for iteration or direct access of boundary k-cells of a n-cell |
ncell_range< element_t< config_type, tag >, dim, true > | The range class for non-const iteration and access of coboundary k-cells of a n-cell, k>n |
ncell_range< segment_t< config_type >, dim, false > | Main range class (non-const). Specialization for use with iteration or access to k-cells of a segment |
netgen_reader | Reader for Netgen files obtained from the 'Export mesh...' menu item. Tested with Netgen version 4.9.12 |
next_segment_layer_selector< Config, dim, handling_tag > | Helper class that returns the next class type for recursive inheritance. Was introduced due to Visual Studio compilation problems of the first approach |
next_segment_layer_selector< Config, 0, handling_tag > | |
next_segment_layer_selector< Config, dim, no_handling_tag > | |
no_handling_tag | A tag denoting that the (boundary) k-cells should not be stored |
norm_impl< Tag > | |
norm_impl< viennagrid::inf_tag > | Implementation of the inf-norm |
norm_impl< viennagrid::one_tag > | Implementation of the 1-norm |
norm_impl< viennagrid::two_tag > | Implementation of the 2-norm |
on_element_iterator< ElementType > | Iterator class for iterating over a range of elements given by a container of pointers |
on_segment_iterator< IteratorType, ElementType > | Iterator for non-const iteration over n-cells of a segment |
one_tag | Tag for denoting the 1-norm |
opendx_writer< DomainType > | The OpenDX writer object. Does not support segments - always the full domain is written |
point< Config > | Metafunction returning the type of a geometric point as used by vertices of the domain |
point_filler< CoordType, d > | A helper class for filling point coordinates with values |
point_filler< CoordType, 1 > | A helper class for filling point coordinates with values. Specialization for one dimension |
point_filler< CoordType, 2 > | A helper class for filling point coordinates with values. Specialization for two dimensions |
point_filler< CoordType, 3 > | A helper class for filling point coordinates with values. Specialization for three dimensions |
point_index_out_of_bounds_exception | An exception class for invalid point indices |
point_less | This class provides a less-than comparison for points. Entries are checked for inequality, starting from the first and continuing only in the case of equality |
point_t< CoordType, CoordinateSystem > | Represents an arbitrary point in the underlying coordinate system |
point_tag | Topological description of a 0-cell (vertex) |
pointer_id | ID handler class for IDs based on the n-cell address |
PointWriter< dim > | Helper class for writing points to file. Aids as a generic layer for point types that don't have operator<< overloaded in a suitable way |
PointWriter< 1 > | |
PointWriter< 2 > | |
PointWriter< 3 > | |
polar_cs | Provides the basic operations in a polar coordinate system (r, phi) |
quadrilateral_2d | Predefined configuration class for two-dimensional hypercube cells (quadrilaterals) in a 2d geometry using Cartesian coordinates |
quadrilateral_3d | Predefined configuration class for two-dimensional hypercube cells (quadrilaterals) in a 3d geometry using Cartesian coordinates |
refinement_key | A key type used for tagging edges for refinement using ViennaData |
refinement_proxy< DomainType, RefinementTag > | A proxy class that is used to allow ' refined_domain = refine(domain); ' without temporary |
refinement_vertex_id_requirement< DomainType, VertexIDHandler > | Refinement requies vertex IDs. This class makes sure that they are available |
refinement_vertex_id_requirement< DomainType, pointer_id > | |
seg_cell_normal_data | Data type for cell normals in algorithm/cell_normals.hpp (to be added in afuture release) |
seg_cell_normal_tag | Types for cell normals in algorithm/cell_normals.hpp (to be added in afuture release) |
segment< ConfigType > | Metafunction for returning the type of a segment derived from the configuration class |
segment_domain_holder< Conf > | Class that holds a reference to the domain the segment belongs to |
segment_iterators< Config, cell_level, cell_level > | Segment iterator type retrieval for cells |
segment_layers_empty< Config, dim > | No handling of elements by cells on that level. Therefore, don't handle it within segments as well. Uses recursive inheritance |
segment_layers_full< Config, dim > | Full handling of a particular topological dimension of a segment |
segment_layers_full< Config, 0 > | Specialization of full handling at vertex level. Terminates recursion |
segment_layers_top< Config, dim > | Handler for cells in a segment. Since cells are the defining entity of segments, this requires special treatment |
segment_mapping_key< SegmentType > | |
segment_scalar_data_accessor< ElementType, KeyType, DataType > | Wrapper: Access scalar-valued data for elements per segment |
segment_t< Conf > | |
segment_vector_data_accessor< ElementType, KeyType, DataType > | Wrapper: Access vector-valued data for elements per segment |
simplex_tag< 1 > | Topological description of a 1-cell (line). Same as hypercube_tag<1> |
simplex_tag< 2 > | Topological description of a triangle |
simplex_tag< 3 > | Topological description of a tetrahedron |
spanned_volume_impl< PointType, 1 > | Implementation of the volume spanned by two points in one dimension |
spanned_volume_impl< PointType, 2 > | Implementation of the volume of simplices spanned by points in two geometrical dimension |
spanned_volume_impl< PointType, 3 > | Implementation of the volume of simplices spanned by points in three geometrical dimension |
spherical_cs | Provides the basic operations in a spherical coordinate system (r, theta, phi) with theta denoting the elevation angle |
static_size< point_t< CoordType, CoordinateSystem > > | Returns the static (compile time) size of a point. Specialization for a ViennaGrid point |
strChecker | Checks for a string being a number |
tetrahedral_3d | Predefined configuration class for three-dimensional simplex cells (tetrahedra) in a 3d geometry using Cartesian coordinates |
triangular_2d | Predefined configuration class for two-dimensional simplex cells (triangles) in a 2d geometry using Cartesian coordinates |
triangular_3d | Predefined configuration class for two-dimensional simplex cells (triangles) in a 3d geometry using Cartesian coordinates |
two_tag | Tag for denoting the 2-norm |
uniform_refinement_tag | A tag denoting uniform refinement |
value_type< point_t< CoordType, CoordinateSystem > > | Value Type retrieval for a point. Returns the numeric type of each coordinate entry. Specialization for a ViennaGrid point |
viennagrid_to_vtk_orientations< CellTag > | Tranformations of reference orientations from ViennaGrid to VTK |
viennagrid_to_vtk_orientations< hexahedron_tag > | Specialization for hexahedra: Switch vertices (2, 3) and (6, 7) |
viennagrid_to_vtk_orientations< quadrilateral_tag > | Specialization for quadrilaterals: Switch vertices 2 and 3 |
voronoi_box_volume_key | ViennaData key for the Voronoi box volume associated with an edge or vertex |
voronoi_interface_area_key | ViennaData key for the Voronoi interface area associated with an edge |
vtk_reader< DomainType > | A VTK reader class that allows to read meshes from XML-based VTK files as defined in http://www.vtk.org/pdf/file-formats.pdf |
vtk_to_viennagrid_orientations< CellTag > | Tranformations of reference orientations from VTK to ViennaGrid |
vtk_to_viennagrid_orientations< hexahedron_tag > | Specialization for hexahedra: Switch vertices (2, 3) and (6, 7) |
vtk_to_viennagrid_orientations< quadrilateral_tag > | Specialization for quadrilaterals: Switch vertices 2 and 3 |
vtk_vertex_id_repository< DomainSegmentType, IDHandler > | A utility class managing the vertex ID in the domain. This is trivial if the vertices provide an ID, but a little tricky if vertex objects don't provide integral IDs |
vtk_vertex_id_repository< viennagrid::domain_t< ConfigType >, viennagrid::integral_id > | Specialization for a domain. The simple case: Vertices know their global IDs |
vtk_vertex_id_repository< viennagrid::domain_t< ConfigType >, viennagrid::pointer_id > | Specialization for a domain. The tough case: Vertices don't know their global IDs. Set up a map first |
vtk_writer< DomainType > | Main VTK writer class. Writes a domain or a segment to a file |
xml_tag< dummy > | Helper class that parses a XML tag |