lemon-0.x: comparison lemon/lemon

equal deleted inserted replaced

-:028ac22cb3c4
+:b435a12f8831
 struct Arg { typedef Map& Type; };
 template <typename Graph, typename Map>
 class ForwardComposeMap {
 public:
-typedef typename Graph::UndirEdge Key;
+typedef typename Graph::UEdge Key;
 typedef typename Map::Value Value;
 ForwardComposeMap(const Graph& _graph, typename Arg<Map>::Type _map)
 	: graph(_graph), map(_map) {}
 }
 template <typename Graph, typename Map>
 class BackwardComposeMap {
 public:
-typedef typename Graph::UndirEdge Key;
+typedef typename Graph::UEdge Key;
 typedef typename Map::Value Value;
 BackwardComposeMap(const Graph& _graph, typename Arg<Map>::Type _map)
 	: graph(_graph), map(_map) {}
 /// \ingroup io_group
 /// \brief SectionReader for reading a undirected graph's edgeset.
 ///
 /// The lemon format can store multiple undirected edgesets with several
-/// maps. The undirected edgeset section's header line is \c \@undiredgeset
+/// maps. The undirected edgeset section's header line is \c \@uedgeset
-/// \c undiredgeset_name, but the \c undiredgeset_name may be empty.
+/// \c uedgeset_name, but the \c uedgeset_name may be empty.
 ///
 /// The first line of the section contains the names of the maps separated
 /// with white spaces. Each next lines describes an edge in the edgeset. The
 /// line contains the connected nodes' id and the mapped values for each map.
 ///
 /// difference.
 ///
 /// If the edgeset contains an \c "label" named map then it will be regarded
 /// as id map. This map should contain only unique values and when the
 /// \c readLabel() member will read a value from the given stream it will
-/// give back that undiricted edge which is mapped to this value.
+/// give back that uicted edge which is mapped to this value.
 ///
 /// The undirected edgeset reader needs a node id reader to identify which
 /// nodes have to be connected. If a NodeSetReader reads an "label" named map,
 /// it will be able to resolve the nodes by ids.
 ///
 /// \relates LemonReader
 template <typename _Graph, typename _Traits = DefaultReaderTraits>
-class UndirEdgeSetReader : public LemonReader::SectionReader {
+class UEdgeSetReader : public LemonReader::SectionReader {
 typedef LemonReader::SectionReader Parent;
 public:
 typedef _Graph Graph;
 typedef _Traits Traits;
 typedef typename Graph::Node Node;
 typedef typename Graph::Edge Edge;
-typedef typename Graph::UndirEdge UndirEdge;
+typedef typename Graph::UEdge UEdge;
 typedef typename Traits::Skipper DefaultSkipper;
 /// \brief Constructor.
 ///
-/// Constructor for UndirEdgeSetReader. It creates the UndirEdgeSetReader
+/// Constructor for UEdgeSetReader. It creates the UEdgeSetReader
 /// and attach it into the given LemonReader. The undirected edgeset
 /// reader will add the readed undirected edges to the given Graph. It
 /// will use the given node id reader to read the source and target
 /// nodes of the edges. The reader will read the section only if the
-/// \c _name and the \c undiredgset_name are the same.
+/// \c _name and the \c uedgset_name are the same.
 template <typename NodeLabelReader>
-UndirEdgeSetReader(LemonReader& _reader,
+UEdgeSetReader(LemonReader& _reader,
 		       Graph& _graph,
 		       const NodeLabelReader& _nodeLabelReader,
 		       const std::string& _name = std::string(),
 		       const DefaultSkipper& _skipper = DefaultSkipper())
 : Parent(_reader), graph(_graph), name(_name), skipper(_skipper) {
 nodeLabelReader.reset(new _reader_bits::
 			 LabelReader<Node, NodeLabelReader>(_nodeLabelReader));
 }
 /// \brief Destructor.
 ///
-/// Destructor for UndirEdgeSetReader.
+/// Destructor for UEdgeSetReader.
-virtual ~UndirEdgeSetReader() {
+virtual ~UEdgeSetReader() {
 for (typename MapReaders::iterator it = readers.begin();
 	   it != readers.end(); ++it) {
 	delete it->second;
 }
 }
 private:
-UndirEdgeSetReader(const UndirEdgeSetReader&);
+UEdgeSetReader(const UEdgeSetReader&);
-void operator=(const UndirEdgeSetReader&);
+void operator=(const UEdgeSetReader&);
 public:
 /// \brief Add a new undirected edge map reader command for the reader.
 ///
 /// Add a new edge undirected map reader command for the reader.
 template <typename Map>
-UndirEdgeSetReader& readUndirEdgeMap(std::string name, Map& map) {
+UEdgeSetReader& readUEdgeMap(std::string name, Map& map) {
 return _readMap<
 	typename Traits::template Reader<typename Map::Value>, Map,
 	typename _reader_bits::Arg<Map>::Type>(name, map);
 }
 template <typename Map>
-UndirEdgeSetReader& readUndirEdgeMap(std::string name, const Map& map) {
+UEdgeSetReader& readUEdgeMap(std::string name, const Map& map) {
 return _readMap<
 	typename Traits::template Reader<typename Map::Value>, Map,
 	typename _reader_bits::Arg<Map>::Type>(name, map);
 }
 /// \brief Add a new undirected edge map reader command for the reader.
 ///
 /// Add a new edge undirected map reader command for the reader.
 template <typename Reader, typename Map>
-UndirEdgeSetReader& readUndirEdgeMap(std::string name, Map& map,
+UEdgeSetReader& readUEdgeMap(std::string name, Map& map,
 					 const Reader& reader = Reader()) {
 return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
 	(name, map, reader);
 }
 template <typename Reader, typename Map>
-UndirEdgeSetReader& readUndirEdgeMap(std::string name, const Map& map,
+UEdgeSetReader& readUEdgeMap(std::string name, const Map& map,
 					 const Reader& reader = Reader()) {
 return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type >
 	(name, map, reader);
 }
 private:
 template <typename Reader, typename Map, typename MapParameter>
-UndirEdgeSetReader& _readMap(std::string name, MapParameter map,
+UEdgeSetReader& _readMap(std::string name, MapParameter map,
 				 const Reader& reader = Reader()) {
-checkConcept<concept::WriteMap<UndirEdge, typename Map::Value>, Map>();
+checkConcept<concept::WriteMap<UEdge, typename Map::Value>, Map>();
 checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
 if (readers.find(name) != readers.end()) {
 	ErrorMessage msg;
 	msg << "Multiple read rule for edge map: " << name;
 	throw IOParameterError(msg.message());
 }
 readers.insert(
 	make_pair(name, new _reader_bits::
-		  MapReader<UndirEdge, Map, Reader>(map, reader)));
+		  MapReader<UEdge, Map, Reader>(map, reader)));
 return *this;
 }
 public:
 /// \brief Add a new undirected edge map skipper command for the reader.
 ///
 /// Add a new undirected edge map skipper command for the reader.
 template <typename Reader>
-UndirEdgeSetReader& skipUndirEdgeMap(std::string name,
+UEdgeSetReader& skipUEdgeMap(std::string name,
 					 const Reader& reader = Reader()) {
 if (readers.find(name) != readers.end()) {
 	ErrorMessage msg;
 	msg << "Multiple read rule for node map: " << name;
 	throw IOParameterError(msg.message());
 }
 readers.insert(make_pair(name, new _reader_bits::
-			       SkipReader<UndirEdge, Reader>(reader)));
+			       SkipReader<UEdge, Reader>(reader)));
 return *this;
 }
 /// \brief Add a new directed edge map reader command for the reader.
 ///
 /// Add a new directed edge map reader command for the reader.
 template <typename Map>
-UndirEdgeSetReader& readEdgeMap(std::string name, Map& map) {
+UEdgeSetReader& readEdgeMap(std::string name, Map& map) {
 return _readDirMap<
 	typename Traits::template Reader<typename Map::Value>, Map,
 	typename _reader_bits::Arg<Map>::Type>(name, map);
 }
 template <typename Map>
-UndirEdgeSetReader& readEdgeMap(std::string name, const Map& map) {
+UEdgeSetReader& readEdgeMap(std::string name, const Map& map) {
 return _readDirMap<
 	typename Traits::template Reader<typename Map::Value>, Map,
 	typename _reader_bits::Arg<Map>::Type>(name, map);
 }
 /// \brief Add a new directed edge map reader command for the reader.
 ///
 /// Add a new directed edge map reader command for the reader.
 template <typename Reader, typename Map>
-UndirEdgeSetReader& readEdgeMap(std::string name, Map& map,
+UEdgeSetReader& readEdgeMap(std::string name, Map& map,
 				    const Reader& reader = Reader()) {
 return _readDirMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
 	(name, map, reader);
 }
 template <typename Reader, typename Map>
-UndirEdgeSetReader& readEdgeMap(std::string name, const Map& map,
+UEdgeSetReader& readEdgeMap(std::string name, const Map& map,
 				    const Reader& reader = Reader()) {
 return _readDirMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
 	(name, map, reader);
 }
 private:
 template <typename Reader, typename Map, typename MapParameter>
-UndirEdgeSetReader& _readDirMap(std::string name, MapParameter map,
+UEdgeSetReader& _readDirMap(std::string name, MapParameter map,
 				    const Reader& reader = Reader()) {
 checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
 checkConcept<concept::WriteMap<Edge, typename Map::Value>, Map>();
 readMap("+" + name,
 	      _reader_bits::forwardComposeMap(graph, map), reader);
 /// \brief Add a new directed edge map skipper command for the reader.
 ///
 /// Add a new directed edge map skipper command for the reader.
 template <typename Reader>
-UndirEdgeSetReader& skipEdgeMap(std::string name,
+UEdgeSetReader& skipEdgeMap(std::string name,
 				    const Reader& reader = Reader()) {
 skipMap("+" + name, reader);
 skipMap("-" + name, reader);
 return *this;
 }
 protected:
 /// \brief Gives back true when the SectionReader can process
 /// the section with the given header line.
 ///
-/// It gives back true when the header line starts with \c \@undiredgeset,
+/// It gives back true when the header line starts with \c \@uedgeset,
 /// and the header line's name and the edgeset's name are the same.
 virtual bool header(const std::string& line) {
 std::istringstream ls(line);
 std::string command;
 std::string id;
 ls >> command >> name;
-return command == "@undiredgeset" && name == id;
+return command == "@uedgeset" && name == id;
 }
 /// \brief Reader function of the section.
 ///
 /// It reads the content of the section.
 virtual void read(std::istream& is) {
 if (!nodeLabelReader->isLabelReader()) {
 	throw DataFormatError("Cannot find nodeset or label map");
 }
-std::vector<_reader_bits::MapReaderBase<UndirEdge>* > index;
+std::vector<_reader_bits::MapReaderBase<UEdge>* > index;
 std::string line;
 getline(is, line);
 std::istringstream ls(line);
 std::string id;
 }
 while (getline(is, line)) {
 	std::istringstream ls(line);
 	Node from = nodeLabelReader->read(ls);
 	Node to = nodeLabelReader->read(ls);
-	UndirEdge edge = graph.addEdge(from, to);
+	UEdge edge = graph.addEdge(from, to);
 	for (int i = 0; i < (int)index.size(); ++i) {
 	  index[i]->read(ls, edge);
 	}
 }
 }
 /// \brief Gives back the undirected edge by its label.
 ///
 /// It reads an id from the stream and gives back which undirected edge
 /// belongs to it. It is possible only if there was read an "label" named map.
-void readLabel(std::istream& is, UndirEdge& undirEdge) const {
+void readLabel(std::istream& is, UEdge& uEdge) const {
-undirEdge = inverter->read(is);
+uEdge = inverter->read(is);
 }
 /// \brief Gives back the directed edge by its label.
 ///
 /// It reads an id from the stream and gives back which directed edge
 /// and the undirected edge id. It is possible only if there was read
 /// an "label" named map.
 void readLabel(std::istream& is, Edge& edge) const {
 char c;
 is >> c;
-UndirEdge undirEdge = inverter->read(is);
+UEdge uEdge = inverter->read(is);
 if (c == '+') {
-	edge = graph.direct(undirEdge, true);
+	edge = graph.direct(uEdge, true);
 } else if (c == '-') {
-edge = graph.direct(undirEdge, false);
+edge = graph.direct(uEdge, false);
 } else {
 	throw DataFormatError("Wrong id format for edge "
 			      "in undirected edgeset");
 }
 }
 private:
 typedef std::map<std::string,
-		     _reader_bits::MapReaderBase<UndirEdge>*> MapReaders;
+		     _reader_bits::MapReaderBase<UEdge>*> MapReaders;
 MapReaders readers;
 Graph& graph;
 std::string name;
-_reader_bits::SkipReader<UndirEdge, DefaultSkipper> skipper;
+_reader_bits::SkipReader<UEdge, DefaultSkipper> skipper;
-std::auto_ptr<_reader_bits::MapInverterBase<UndirEdge> > inverter;
+std::auto_ptr<_reader_bits::MapInverterBase<UEdge> > inverter;
 std::auto_ptr<_reader_bits::LabelReaderBase<Node> > nodeLabelReader;
 };
 /// \ingroup io_group
 /// \brief SectionReader for reading labeled nodes.
 };
 /// \ingroup io_group
 /// \brief SectionReader for reading labeled undirected edges.
 ///
-/// The undirected edges section's header line is \c \@undiredges
+/// The undirected edges section's header line is \c \@uedges
-/// \c undiredges_name, but the \c undiredges_name may be empty.
+/// \c uedges_name, but the \c uedges_name may be empty.
 ///
 /// Each line in the section contains the name of the undirected edge
 /// and then the undirected edge id.
 ///
 /// \relates LemonReader
 template <typename _Graph>
-class UndirEdgeReader : public LemonReader::SectionReader {
+class UEdgeReader : public LemonReader::SectionReader {
 typedef LemonReader::SectionReader Parent;
 typedef _Graph Graph;
 typedef typename Graph::Edge Edge;
-typedef typename Graph::UndirEdge UndirEdge;
+typedef typename Graph::UEdge UEdge;
 public:
 /// \brief Constructor.
 ///
-/// Constructor for UndirEdgeReader. It creates the UndirEdgeReader and
+/// Constructor for UEdgeReader. It creates the UEdgeReader and
 /// attach it into the given LemonReader. It will use the given
 /// undirected edge id reader to give back the edges. The reader will
-/// read the section only if the \c _name and the \c undiredges_name are
+/// read the section only if the \c _name and the \c uedges_name are
 /// the same.
 template <typename _LabelReader>
-UndirEdgeReader(LemonReader& _reader, const _LabelReader& _labelReader,
+UEdgeReader(LemonReader& _reader, const _LabelReader& _labelReader,
 	       const std::string& _name = std::string())
 : Parent(_reader), name(_name) {
-checkConcept<_reader_bits::ItemLabelReader<UndirEdge>, _LabelReader>();
+checkConcept<_reader_bits::ItemLabelReader<UEdge>, _LabelReader>();
 checkConcept<_reader_bits::ItemLabelReader<Edge>, _LabelReader>();
-undirEdgeLabelReader.reset(new _reader_bits::
+uEdgeLabelReader.reset(new _reader_bits::
-			      LabelReader<UndirEdge, _LabelReader>(_labelReader));
+			      LabelReader<UEdge, _LabelReader>(_labelReader));
 edgeLabelReader.reset(new _reader_bits::
 			 LabelReader<Edge, _LabelReader>(_labelReader));
 }
 /// \brief Destructor.
 ///
-/// Destructor for UndirEdgeReader.
+/// Destructor for UEdgeReader.
-virtual ~UndirEdgeReader() {}
+virtual ~UEdgeReader() {}
 private:
-UndirEdgeReader(const UndirEdgeReader&);
+UEdgeReader(const UEdgeReader&);
-void operator=(const UndirEdgeReader&);
+void operator=(const UEdgeReader&);
 public:
-/// \brief Add an undirected edge reader command for the UndirEdgeReader.
+/// \brief Add an undirected edge reader command for the UEdgeReader.
 ///
-/// Add an undirected edge reader command for the UndirEdgeReader.
+/// Add an undirected edge reader command for the UEdgeReader.
-void readUndirEdge(const std::string& name, UndirEdge& item) {
+void readUEdge(const std::string& name, UEdge& item) {
-if (undirEdgeReaders.find(name) != undirEdgeReaders.end()) {
+if (uEdgeReaders.find(name) != uEdgeReaders.end()) {
 	ErrorMessage msg;
 	msg << "Multiple read rule for undirected edge: " << name;
 	throw IOParameterError(msg.message());
 }
-undirEdgeReaders.insert(make_pair(name, _reader_bits::
+uEdgeReaders.insert(make_pair(name, _reader_bits::
-					ItemStore<UndirEdge>(item)));
+					ItemStore<UEdge>(item)));
 }
-/// \brief Add an edge reader command for the UndirEdgeReader.
+/// \brief Add an edge reader command for the UEdgeReader.
 ///
-/// Add an edge reader command for the UndirEdgeReader.
+/// Add an edge reader command for the UEdgeReader.
 void readEdge(const std::string& name, Edge& item) {
 if (edgeReaders.find(name) != edgeReaders.end()) {
 	ErrorMessage msg;
 	msg << "Multiple read rule for edge: " << name;
 	throw IOParameterError(msg.message());
 virtual bool header(const std::string& line) {
 std::istringstream ls(line);
 std::string command;
 std::string id;
 ls >> command >> name;
-return command == "@undiredges" && name == id;
+return command == "@uedges" && name == id;
 }
 /// \brief Reader function of the section.
 ///
 /// It reads the content of the section.
 virtual void read(std::istream& is) {
 if (!edgeLabelReader->isLabelReader()) {
 	throw DataFormatError("Cannot find undirected edgeset or label map");
 }
-if (!undirEdgeLabelReader->isLabelReader()) {
+if (!uEdgeLabelReader->isLabelReader()) {
 	throw DataFormatError("Cannot find undirected edgeset or label map");
 }
 std::string line;
 while (getline(is, line)) {
 	std::istringstream ls(line);
 	std::string id;
 	ls >> id;
 	{
-	  typename UndirEdgeReaders::iterator it = undirEdgeReaders.find(id);
+	  typename UEdgeReaders::iterator it = uEdgeReaders.find(id);
-	  if (it != undirEdgeReaders.end()) {
+	  if (it != uEdgeReaders.end()) {
-	    it->second.read(undirEdgeLabelReader->read(ls));
+	    it->second.read(uEdgeLabelReader->read(ls));
 	    it->second.touch();
 	    continue;
 	  }
 	} {
 	  typename EdgeReaders::iterator it = edgeReaders.find(id);
 	  ErrorMessage msg;
 	  msg << "Edge not found in file: " << it->first;
 	  throw IOParameterError(msg.message());
 	}
 }
-for (typename UndirEdgeReaders::iterator it = undirEdgeReaders.begin();
+for (typename UEdgeReaders::iterator it = uEdgeReaders.begin();
-	   it != undirEdgeReaders.end(); ++it) {
+	   it != uEdgeReaders.end(); ++it) {
 	if (!it->second.touched()) {
 	  ErrorMessage msg;
-	  msg << "UndirEdge not found in file: " << it->first;
+	  msg << "UEdge not found in file: " << it->first;
 	  throw IOParameterError(msg.message());
 	}
 }
 }
 private:
 std::string name;
 typedef std::map<std::string,
-		     _reader_bits::ItemStore<UndirEdge> > UndirEdgeReaders;
+		     _reader_bits::ItemStore<UEdge> > UEdgeReaders;
-UndirEdgeReaders undirEdgeReaders;
+UEdgeReaders uEdgeReaders;
-std::auto_ptr<_reader_bits::LabelReaderBase<UndirEdge> > undirEdgeLabelReader;
+std::auto_ptr<_reader_bits::LabelReaderBase<UEdge> > uEdgeLabelReader;
 typedef std::map<std::string, _reader_bits::ItemStore<Edge> > EdgeReaders;
 EdgeReaders edgeReaders;
 std::auto_ptr<_reader_bits::LabelReaderBase<Edge> > edgeLabelReader;
 };
 }
 /// \brief Gives back how many undirected edgesets are in the file.
 ///
 /// Gives back how many undirected edgesets are in the file.
-int undirEdgeSetNum() const {
+int uEdgeSetNum() const {
-return undiredgesets.size();
+return uedgesets.size();
 }
 /// \brief Gives back the name of undirected edgeset on the indiced
 /// position.
 ///
 /// Gives back the name of undirected edgeset on the indiced position.
-std::string undirEdgeSetName(int index) const {
+std::string uEdgeSetName(int index) const {
-return undiredgesets[index].name;
+return uedgesets[index].name;
 }
 /// \brief Gives back the map names of undirected edgeset on the indiced
 /// position.
 ///
 /// Gives back the map names of undirected edgeset on the indiced position.
-const std::vector<std::string>& undirEdgeSetMaps(int index) const {
+const std::vector<std::string>& uEdgeSetMaps(int index) const {
-return undiredgesets[index].items;
+return uedgesets[index].items;
 }
 /// \brief Gives back how many labeled nodes section are in the file.
 ///
 /// Gives back how many labeled nodes section are in the file.
 /// \brief Gives back how many labeled undirected edges section are
 /// in the file.
 ///
 /// Gives back how many labeled undirected edges section are in the file.
-int undirEdgesNum() const {
+int uEdgesNum() const {
-return undiredges.size();
+return uedges.size();
 }
 /// \brief Gives back the name of labeled undirected edges section
 /// on the indiced position.
 ///
 /// Gives back the name of labeled undirected edges section on the
 /// indiced position.
-std::string undirEdgesName(int index) const {
+std::string uEdgesName(int index) const {
-return undiredges[index].name;
+return uedges[index].name;
 }
 /// \brief Gives back the names of the labeled undirected edges in
 /// the indiced section.
 ///
 /// Gives back the names of the labeled undirected edges in the
 /// indiced section.
-const std::vector<std::string>& undirEdgesItems(int index) const {
+const std::vector<std::string>& uEdgesItems(int index) const {
-return undiredges[index].items;
+return uedges[index].items;
 }
 /// \brief Gives back how many attributes section are in the file.
 ///
 	current = command;
 	nodesets.push_back(SectionInfo(name));
 } else if (command == "@edgeset") {
 	current = command;
 	edgesets.push_back(SectionInfo(name));
-} else if (command == "@undiredgeset") {
+} else if (command == "@uedgeset") {
 	current = command;
-	undiredgesets.push_back(SectionInfo(name));
+	uedgesets.push_back(SectionInfo(name));
 } else if (command == "@nodes") {
 	current = command;
 	nodes.push_back(SectionInfo(name));
 } else if (command == "@edges") {
 	current = command;
 	edges.push_back(SectionInfo(name));
-} else if (command == "@undiredges") {
+} else if (command == "@uedges") {
 	current = command;
-	undiredges.push_back(SectionInfo(name));
+	uedges.push_back(SectionInfo(name));
 } else if (command == "@attributes") {
 	current = command;
 	attributes.push_back(SectionInfo(name));
 } else {
 	sections.push_back(line);
 void read(std::istream& is) {
 if (current == "@nodeset") {
 	readMapNames(is, nodesets.back().items);
 } else if (current == "@edgeset") {
 	readMapNames(is, edgesets.back().items);
-} else if (current == "@undiredgeset") {
+} else if (current == "@uedgeset") {
-	readMapNames(is, undiredgesets.back().items);
+	readMapNames(is, uedgesets.back().items);
 } else if (current == "@nodes") {
 	readItemNames(is, nodes.back().items);
 } else if (current == "@edges") {
 	readItemNames(is, edges.back().items);
-} else if (current == "@undiredges") {
+} else if (current == "@uedges") {
-	readItemNames(is, undiredges.back().items);
+	readItemNames(is, uedges.back().items);
 } else if (current == "@attributes") {
 	readItemNames(is, attributes.back().items);
 }
 }
 SectionInfo(const std::string& _name) : name(_name) {}
 };
 std::vector<SectionInfo> nodesets;
 std::vector<SectionInfo> edgesets;
-std::vector<SectionInfo> undiredgesets;
+std::vector<SectionInfo> uedgesets;
 std::vector<SectionInfo> nodes;
 std::vector<SectionInfo> edges;
-std::vector<SectionInfo> undiredges;
+std::vector<SectionInfo> uedges;
 std::vector<SectionInfo> attributes;
 std::vector<std::string> sections;

changeset 1913	49fe71fce7fb
parent 1901	723b2b81d900
child 1946	17eb3eaad9f8