def load_elt_from_node(node):
"""Load an element from the given entry"""
fact = find_factory(ST.load_cls(node))
if fact:
return fact.load(node)
else:
raise TypeError("No element found at the given node")
def test_load_element_from_entry(self):
std = self.std
fact = aster_s.CommFile("fname.comm")
elt = fact.build(std)
lelt = std.load_elt_from_entry(elt.node.entry)
self.assert_(ST.load_cls(elt.node) is aster_s.CommFile)
self.assertEqual(lelt.node, elt.node)
def create_elt(self, parent, compo):
"""Create the element from user data"""
std = parent.give_aster_study()
src_elt = std.load_elt_from_entry(compo.entry)
if not issubclass(ST.load_cls(src_elt.node), self._src_cls):
mess = "'%s' type expected for the source"
raise TypeError(mess % self._src_cls.__name__)
return self._create_elt(parent, src_elt)
def test_attach_eficas_file(self):
fdata = self.fdata
efile = ST.attach_eficas_file(fdata["node"])
self.assertEqual(efile.node.entry, fdata["node"].entry)
self.assertEqual(efile.read_name(), fdata["name"])
self.assertEqual(efile.read_fname(), fdata["fname"])
self.assertEqual(efile.read_type(), fdata["ftype"])
self.assert_(ST.load_cls(efile.node) is None)
self.assertRaises(TypeError, ST.attach_eficas_file, self.std.node)
def test_manage_type_attr(self):
node = self.std.add_root("R")
attr = node.get_attr(ST.Type)
self.assert_(attr.load() is None)
attr.store(MeshFile)
attr = node.get_attr(ST.Type)
self.assert_(attr.load() is MeshFile)
self.assert_(ST.load_cls(node) is MeshFile)
self.assertEqual(
self.pal_std.getTypeAndValue(node.entry)[0], ST.dumps(MeshFile))
attr.write("FICHIER_ASTER")
self.assertEqual(attr.read(), "FICHIER_ASTER")
self.assert_(attr.load() is None)
self.assert_(ST.load_cls(node) is None)
attr.write("")
self.assert_(attr.load() is None)
def test_copy_study_case_building_objects(self):
root = AS.Elt(self.std.node.add_node("root"), AS.Elt)
dest = AS.Elt(self.std.node.add_node("dest"), AS.Elt)
sfile_fact = aster_s.CommFile("fcomm")
sfile = sfile_fact.build(root)
copy = sfile.copy_to(dest)
self.assert_(copy is not dest)
self.assert_(copy.node.parent is dest.node)
self.assertEqual(copy.read_name(), "fcomm")
self.assertEqual(copy.read_fname(), "fcomm")
self.assert_(copy.sfile.load_type() is aster_s.CommFile)
self.assert_(isinstance(copy, AS.File))
version = aster_s.Value("version", "STA10.0")
velt = version.build(root)
copy = velt.copy_to(dest)
self.assert_(ST.load_cls(copy.node) is aster_s.Value)
entry_compo = aster_s.CommEntry(sfile.node.entry)
centry = entry_compo.build(root)
copy = centry.copy_to(dest)
self.assertEqual(copy.node.give_source().entry,
centry.node.give_source().entry)
def fill_popup_menu(self, popup):
"""Fill the popup menu according to the selection"""
node = self.stracker.give_node()
if node:
self.popup_menu_bld.build_for(ST.load_cls(node), popup, self.sqt)
def __call__(self, mod):
"""Run the given callback"""
node = self._stracker.give_node()
if node and (ST.load_cls(node) in self._clss):
self._callback(mod, AS.load_elt_from_node(node))
def is_valid_mesh(node):
"""Validate if the given node holds a mesh"""
return ST.is_mesh(node) or (ST.load_cls(node) is aster_s.MedFile)
def is_valid_comm_file(node):
"""Validate if the given node holds a command file"""
return (ST.load_cls(node) is aster_s.CommFile) or ST.is_eficas_file(node)
