rubyang 0.1.1 → 0.1.2

data/lib/rubyang/database/schema_tree.rb

@@ -9,6 +9,59 @@ require_relative '../xpath'
 module Rubyang
 	class Database
 		class SchemaTree
+			# when start
+			class When
+				attr_reader :arg, :xpath
+				def initialize schema_node, schema
+					@schema_node = schema_node
+					@schema = schema
+					@arg = schema.arg
+					@xpath = Rubyang::Xpath::Parser.parse @arg
+					require 'yaml'
+					puts ''
+					puts 'when xpath:'
+					puts @xpath.to_yaml
+					puts
+					@schema_node.evaluate_xpath @xpath
+				end
+			end
+			# end
+
+			# must start
+			class Must
+				attr_reader :arg, :xpath
+				def initialize schema_node, schema
+					@schema_node = schema_node
+					@schema = schema
+					@arg = schema.arg
+					@xpath = Rubyang::Xpath::Parser.parse @arg
+					@logger = Rubyang::Logger.instance
+					@logger.debug @xpath
+					@schema_node.evaluate_xpath @xpath
+				end
+			end
+			# end
+
+			# min-elements start
+			class MinElements
+				attr_reader :arg
+				def initialize schema_node
+					@schema_node = schema_node
+					@arg = schema_node.arg
+				end
+			end
+			# end
+
+			# max-elements start
+			class MaxElements
+				attr_reader :arg
+				def initialize schema_node
+					@schema_node = schema_node
+					@arg = schema_node.arg
+				end
+			end
+			# end
+
 			class Type
 				attr_reader :arg
 			end
@@ -36,6 +89,15 @@ module Rubyang
 					result
 				end
 			end
+			class Decimal64Type < Type
+				def initialize arg
+					@arg = arg
+				end
+				def valid? value
+					result = true
+					result
+				end
+			end
 			class StringType < Type
 				attr_reader :length, :pattern
 				def initialize
@@ -113,14 +175,13 @@ module Rubyang
 				end
 			end
 			class LeafrefType < Type
-				def initialize interior_schema_node, path_arg
+				def initialize schema_node, path_arg
 					@arg = 'leafref'
 					@path_arg = path_arg
-					@path = Path.new interior_schema_node, path_arg
+					@path = Path.new schema_node, path_arg
 				end
 				def path
-					@path_arg
-					@path.path
+					@path.xpath
 				end
 				def valid? data_tree, value
 					result = true
@@ -151,17 +212,39 @@ module Rubyang
 					result
 				end
 			end
+			class Identityref < Type
+				def initialize identity_list, type_stmt
+					@arg = 'identityref'
+					@base_arg = type_stmt.substmt( 'base' ).first.arg
+					@identity_list = identity_list
+				end
+				def valid? value
+					@identity_list.select{ |identity| (identity.substmt( 'base' ).first.arg rescue nil) == @base_arg }.any?{ |identity| identity.arg == value }
+				end
+			end
 
 			class Path
-				attr_reader :path
+				attr_reader :xpath
 
-				def initialize interior_schema_node, arg
-					@path = Rubyang::Xpath::Parser.parse arg
-					if !(@path[0].axis.name == Rubyang::Xpath::Axis::PARENT && @path[0].node_test.node_test == Rubyang::Xpath::NodeTest::NodeType::NODE)
-						raise "unsupported path: #{@path}"
+				def initialize schema_node, arg
+					@xpath = Rubyang::Xpath::Parser.parse arg
+					#if !(@xpath[0].axis.name == Rubyang::Xpath::Axis::PARENT && @xpath[0].node_test.node_test == Rubyang::Xpath::NodeTest::NodeType::NODE)
+						#raise "unsupported path: #{@xpath}"
+					#end
+					if Rubyang::Xpath::Parser::DEBUG
+						require 'yaml'
+						puts
+						puts 'in Path:'
+						puts
+						puts 'schema_node:'
+						puts schema_node.to_yaml
+						puts
+						puts '@xpath:'
+						puts @xpath.to_yaml
+						puts
 					end
-					target = interior_schema_node.evaluate_xpath( @path[1..-1] )
-					if target.size == 0
+					target = schema_node.evaluate_xpath( @xpath )
+					if target.class != Array || target.size == 0
 						raise ArgumentError, "#{arg} is not valid"
 					end
 					@target = target
@@ -184,7 +267,7 @@ module Rubyang
 				end
 				def update arg
 					new_range = Array.new
-					arg.gsub( ' ', '' ).split( '|' ).each{ |range_part|
+					arg.delete( ' ' ).split( '|' ).each{ |range_part|
 						case range_part
 						when /[^\.]+\.\.[^\.]+/
 							min, max = range_part.split('..')
@@ -227,7 +310,7 @@ module Rubyang
 				end
 				def update arg
 					new_length = Array.new
-					arg.gsub( ' ', '' ).split( '|' ).each{ |length_part|
+					arg.delete( ' ' ).split( '|' ).each{ |length_part|
 						case length_part
 						when /[^\.]+\.\.[^\.]+/
 							min, max = length_part.split('..')
@@ -322,6 +405,18 @@ module Rubyang
 					@yang = yang
 					@parent = parent
 					@module = _module
+					@logger = Rubyang::Logger.instance
+				end
+				def to_s parent=true
+					head, vars, tail = "#<#{self.class.to_s}:0x#{(self.object_id << 1).to_s(16).rjust(14,'0')} ", Array.new, ">"
+					if parent
+						vars.push "@yangs=#{@yangs.to_s}"
+						vars.push "@arg=#{@arg.to_s}"
+						vars.push "@yang=#{@yang.to_s(false) rescue @yang.to_s}"
+						vars.push "@parent=#{@parent.to_s(false) rescue @parent.to_s}"
+						vars.push "@module=#{@module.to_s(false) rescue @module.to_s}"
+					end
+					head + vars.join(', ') + tail
 				end
 				def model
 					@yang
@@ -344,19 +439,95 @@ module Rubyang
 					self.to_json_recursive( h )
 					h.to_json
 				end
-				def evaluate_xpath location_steps, current=self
-					location_step = location_steps.first
-					candidates_by_axis = self.evaluate_xpath_axis( location_step, current )
-					candidates_by_node_test = candidates_by_axis.inject([]){ |cs, c| cs + c.evaluate_xpath_node_test( location_step, current ) }
-					candidates_by_predicates = candidates_by_node_test.inject([]){ |cs, c| cs + c.evaluate_xpath_predicates( location_step, current ) }
-					if location_steps[1..-1].size == 0
+
+				def evaluate_xpath xpath, current=self
+					if Rubyang::Xpath::Parser::DEBUG
+						require 'yaml'
+						puts
+						puts 'in evaluate_xpath:'
+						puts
+						puts 'xpath:'
+						puts xpath.to_yaml
+						puts
+						puts 'current:'
+						puts current.class
+						puts
+					end
+					evaluate_xpath_expr xpath, current
+				end
+
+				def evaluate_xpath_path location_path, current
+					if Rubyang::Xpath::Parser::DEBUG
+						require 'yaml'
+						puts
+						puts 'in evaluate_xpath_path:'
+						puts
+						puts 'location_path:'
+						puts location_path.to_yaml
+						puts
+						puts 'current:'
+						puts current.class
+					end
+					first_location_step = location_path.location_step_sequence.first
+					if Rubyang::Xpath::Parser::DEBUG
+						require 'yaml'
+						puts
+						puts 'first_location_step:'
+						puts first_location_step.to_yaml
+					end
+					candidates_by_axis = self.evaluate_xpath_axis( first_location_step, current )
+					if Rubyang::Xpath::Parser::DEBUG
+						require 'yaml'
+						puts
+						puts 'candidates_by_axis:'
+						puts candidates_by_axis.to_yaml
+					end
+					candidates_by_node_test = candidates_by_axis.inject([]){ |cs, c| cs + c.evaluate_xpath_node_test( first_location_step, current ) }
+					if Rubyang::Xpath::Parser::DEBUG
+						require 'yaml'
+						puts
+						puts 'candidates_by_node_test:'
+						puts candidates_by_node_test.to_yaml
+					end
+					candidates_by_predicates = candidates_by_node_test.inject([]){ |cs, c| cs + c.evaluate_xpath_predicates( first_location_step, current ) }
+					if Rubyang::Xpath::Parser::DEBUG
+						require 'yaml'
+						puts
+						puts 'candidates_by_predicates:'
+						puts candidates_by_predicates.to_yaml
+					end
+					if location_path.location_step_sequence[1..-1].size == 0
 						candidates_by_predicates
 					else
-						candidates_by_predicates.inject([]){ |cs, c| c.evaluate_xpath( location_steps[1..-1], current ) }
+						candidates_by_predicates.inject([]){ |cs, c|
+							following_location_path = Rubyang::Xpath::LocationPath.new *(location_path.location_step_sequence[1..-1])
+							if Rubyang::Xpath::Parser::DEBUG
+								puts
+								puts 'following_location_path:'
+								puts following_location_path.to_yaml
+								puts
+							end
+							c.evaluate_xpath_path( following_location_path, current )
+						}
 					end
 				end
+
 				def evaluate_xpath_axis location_step, current
+					if Rubyang::Xpath::Parser::DEBUG
+						require 'yaml'
+						puts
+						puts 'in evaluate_xpath_axis:'
+						puts
+						puts 'location_step:'
+						puts location_step.to_yaml
+						puts
+						puts 'current:'
+						puts current.class
+						puts
+					end
 					case location_step.axis.name
+					when Rubyang::Xpath::Axis::SELF
+						[self]
 					when Rubyang::Xpath::Axis::PARENT
 						[@parent]
 					when Rubyang::Xpath::Axis::CHILD
@@ -365,6 +536,7 @@ module Rubyang
 						raise "location_step.axis.name: #{location_step.axis.name} NOT implemented"
 					end
 				end
+
 				def evaluate_xpath_node_test location_step, current
 					case location_step.node_test.node_test_type
 					when Rubyang::Xpath::NodeTest::NodeTestType::NAME_TEST
@@ -390,19 +562,31 @@ module Rubyang
 						raise ""
 					end
 				end
+
 				def evaluate_xpath_predicates location_step, current
 					case location_step.predicates.size
 					when 0
 						[self]
 					else
-						location_step.predicates.inject([]){ |cs, predicate|
-							self.evaluate_xpath_predicate_expr predicate.expr, current
+						location_step.predicates.each{ |predicate|
+							self.evaluate_xpath_expr predicate.expr, current
 						}
+						[self]
 					end
 				end
-				def evaluate_xpath_predicate_expr expr, current
+
+				def evaluate_xpath_expr expr, current
 					case expr
-					when Rubyang::Xpath::Predicate::OrExpr
+					when Rubyang::Xpath::Expr
+						if Rubyang::Xpath::Parser::DEBUG
+							puts
+							puts "in Expr"
+							puts "op: #{expr.op}"
+							puts
+						end
+						op = expr.op
+						op_result = self.evaluate_xpath_expr( op, current )
+					when Rubyang::Xpath::OrExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in OrExpr"
@@ -412,14 +596,14 @@ module Rubyang
 						end
 						op1 = expr.op1
 						op2 = expr.op2
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						if op2 == nil
 							op1_result
 						else
-							op2_result = self.evaluate_xpath_predicate_expr( op2, current )
-							op1_result | op2_result
+							op2_result = self.evaluate_xpath_expr( op2, current )
+							Rubyang::Xpath::BasicType::Boolean
 						end
-					when Rubyang::Xpath::Predicate::AndExpr
+					when Rubyang::Xpath::AndExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in AndExpr"
@@ -429,14 +613,14 @@ module Rubyang
 						end
 						op1 = expr.op1
 						op2 = expr.op2
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						if op2 == nil
 							op1_result
 						else
-							op2_result = self.evaluate_xpath_predicate_expr( op2, current )
-							op1_result & op2_result
+							op2_result = self.evaluate_xpath_expr( op2, current )
+							Rubyang::Xpath::BasicType::Boolean
 						end
-					when Rubyang::Xpath::Predicate::EqualityExpr
+					when Rubyang::Xpath::EqualityExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in EqualityExpr"
@@ -448,26 +632,14 @@ module Rubyang
 						op1 = expr.op1
 						op2 = expr.op2
 						operator = expr.operator
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						if op2 == nil
 							op1_result
 						else
-							case operator
-							when /^\=$/
-								op2_result = self.evaluate_xpath_predicate_expr( op2, current )
-								if op1_result.size > 0 and op2_result.size >0
-									[self]
-								else
-									[]
-								end
-								#op1_result.select{ |a| op2_result.map{ |b| b.value }.include? a }
-							when /^\!\=$/
-								raise "Equality Expr: '!=' not implemented"
-							else
-								raise "Equality Expr: other than '=' and '!=' not implemented"
-							end
+							op2_result = self.evaluate_xpath_expr( op2, current )
+							Rubyang::Xpath::BasicType::Boolean
 						end
-					when Rubyang::Xpath::Predicate::RelationalExpr
+					when Rubyang::Xpath::RelationalExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in RelationalExpr"
@@ -479,24 +651,14 @@ module Rubyang
 						op1 = expr.op1
 						op2 = expr.op2
 						operator = expr.operator
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						if op2 == nil
 							op1_result
 						else
-							case operator
-							when /^\>$/
-								raise "Relational Expr: '>' not implemented"
-							when /^\<$/
-								raise "Relational Expr: '<' not implemented"
-							when /^\>\=$/
-								raise "Relational Expr: '>=' not implemented"
-							when /^\<\=$/
-								raise "Relational Expr: '<=' not implemented"
-							else
-								raise "Relational Expr: other than '>', '<', '>=' and '<=' not implemented"
-							end
+							op2_result = self.evaluate_xpath_expr( op2, current )
+							Rubyang::Xpath::BasicType::Boolean
 						end
-					when Rubyang::Xpath::Predicate::AdditiveExpr
+					when Rubyang::Xpath::AdditiveExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in AdditiveExpr"
@@ -508,20 +670,14 @@ module Rubyang
 						op1 = expr.op1
 						op2 = expr.op2
 						operator = expr.operator
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						if op2 == nil
 							op1_result
 						else
-							case operator
-							when /^\+$/
-								raise "Additive Expr: '+' not implemented"
-							when /^\-$/
-								raise "Additive Expr: '-' not implemented"
-							else
-								raise "Additive Expr: other than '+' and '-' not implemented"
-							end
+							op2_result = self.evaluate_xpath_expr( op2, current )
+							Rubyang::Xpath::BasicType::Number
 						end
-					when Rubyang::Xpath::Predicate::MultiplicativeExpr
+					when Rubyang::Xpath::MultiplicativeExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in MultiplicativeExpr"
@@ -533,20 +689,14 @@ module Rubyang
 						op1 = expr.op1
 						op2 = expr.op2
 						operator = expr.operator
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						if op2 == nil
 							op1_result
 						else
-							case operator
-							when /^\*$/
-								raise "Multiplicative Expr: '*' not implemented"
-							when /^\/$/
-								raise "Multiplicative Expr: '/' not implemented"
-							else
-								raise "Multiplicative Expr: other than '*' and '/' not implemented"
-							end
+							op2_result = self.evaluate_xpath_expr( op2, current )
+							Rubyang::Xpath::BasicType::Number
 						end
-					when Rubyang::Xpath::Predicate::UnaryExpr
+					when Rubyang::Xpath::UnaryExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in UnaryExpr"
@@ -556,16 +706,13 @@ module Rubyang
 						end
 						op1 = expr.op1
 						operator = expr.operator
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
-						case operator
-						when nil
+						op1_result = self.evaluate_xpath_expr( op1, current )
+						if operator == nil
 							op1_result
-						when /^\-$/
-							raise "Unary Expr: '-' not implemented"
 						else
-							raise "Unary Expr: other than '-' not implemented"
+							Rubyang::Xpath::BasicType::Number
 						end
-					when Rubyang::Xpath::Predicate::UnionExpr
+					when Rubyang::Xpath::UnionExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in UnionExpr"
@@ -577,18 +724,14 @@ module Rubyang
 						op1 = expr.op1
 						op2 = expr.op2
 						operator = expr.operator
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						if op2 == nil
 							op1_result
 						else
-							case operator
-							when /^\|$/
-								raise "Union Expr: '|' not implemented"
-							else
-								raise "Union Expr: other than '|' not implemented"
-							end
+							op2_result = self.evaluate_xpath_expr( op2, current )
+							Rubyang::Xpath::BasicType::NodeSet
 						end
-					when Rubyang::Xpath::Predicate::PathExpr
+					when Rubyang::Xpath::PathExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in PathExpr"
@@ -600,36 +743,21 @@ module Rubyang
 						op1 = expr.op1
 						op2 = expr.op2
 						operator = expr.operator
-						case op1
-						when Rubyang::Xpath::LocationSteps
-							op1_result = self.evaluate_xpath( op1, current )
-						when Rubyang::Xpath::Predicate::FilterExpr
-							op1_result = self.evaluate_xpath_predicate_expr( op1, current )
-							if op2 == nil
-								op1_result
-							else
-								case operator
-								when /^\/$/
-									case op2
-									when Rubyang::Xpath::LocationSteps
-										if !(op2[0].axis.name == Rubyang::Xpath::Axis::PARENT &&
-										     op2[0].node_test.node_test == Rubyang::Xpath::NodeTest::NodeType::NODE)
-											raise "unsupported path: #{op2}"
-										end
-										current.evaluate_xpath (op1_result + op2[1..-1]), current
-									else
-										raise "Path Expr: op1 is not LocationSteps"
-									end
-								when /^\/\/$/
-									raise "Path Expr: '//' not implemented"
-								else
-									raise "Path Expr: other than '/' and '//' not implemented"
-								end
-							end
+						op1_result = case op1
+							     when Rubyang::Xpath::LocationPath
+								     self.evaluate_xpath_path( op1, current )
+							     when Rubyang::Xpath::FilterExpr
+								     self.evaluate_xpath_expr( op1, current )
+							     else
+								     raise "PathExpr: #{op1} not supported"
+							     end
+						if op2 == nil
+							op1_result
 						else
-							raise ""
+							op2_result = self.evaluate_xpath_path( op2, current )
+							Rubyang::Xpath::BasicType::NodeSet
 						end
-					when Rubyang::Xpath::Predicate::FilterExpr
+					when Rubyang::Xpath::FilterExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in FilterExpr"
@@ -639,14 +767,14 @@ module Rubyang
 						end
 						op1 = expr.op1
 						op2 = expr.op2
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						if op2 == nil
 							op1_result
 						else
-							op2_result = self.evaluate_xpath_predicate_expr( op2.expr, current )
-							raise "Filter Expr: Filter Predicate not implemented"
+							op2_result = self.evaluate_xpath_expr( op2.expr, current )
+							Rubyang::Xpath::BasicType::NodeSet
 						end
-					when Rubyang::Xpath::Predicate::PrimaryExpr
+					when Rubyang::Xpath::PrimaryExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in PrimaryExpr"
@@ -655,16 +783,20 @@ module Rubyang
 						end
 						op1 = expr.op1
 						case op1
-						when Rubyang::Xpath::Predicate::Expr
-							raise "Primary Expr: '( Expr )' not implemented"
-						when Rubyang::Xpath::Predicate::FunctionCall
-							op1_result = self.evaluate_xpath_predicate_expr( op1, current )
-						when /^\$.*$/
-							raise "Primary Expr: 'Variable Reference' not implemented"
+						when Rubyang::Xpath::VariableReference
+							Rubyang::Xpath::BasicType::String
+						when Rubyang::Xpath::Expr
+							op1_result = self.evaluate_xpath_expr( op1, current )
+						when Rubyang::Xpath::Literal
+							Rubyang::Xpath::BasicType::String
+						when Rubyang::Xpath::Number
+							Rubyang::Xpath::BasicType::Boolean
+						when Rubyang::Xpath::FunctionCall
+							op1_result = self.evaluate_xpath_expr( op1, current )
 						else
-							raise "Primary Expr: 'Literal' and 'Number' not implemented"
+							raise "Primary Expr: '#{op1}' not implemented"
 						end
-					when Rubyang::Xpath::Predicate::FunctionCall
+					when Rubyang::Xpath::FunctionCall
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in FunctionCall"
@@ -674,145 +806,17 @@ module Rubyang
 						end
 						name = expr.name
 						case name
-						when Rubyang::Xpath::Predicate::FunctionCall::CURRENT
-							Rubyang::Xpath::LocationSteps.new
+						when Rubyang::Xpath::FunctionCall::CURRENT
+							Rubyang::Xpath::BasicType::NodeSet
 						else
 							raise "FunctionCall: #{name} not implemented"
 						end
 					else
-						raise "Unrecognized predicate: #{predicate}"
-					end
-				end
-			end
-
-			class InteriorSchemaNode < SchemaNode
-				attr_accessor :yangs, :arg, :yang, :parent, :children
-
-				def initialize yangs, arg, yang, parent, _module
-					super yangs, arg, yang, parent, _module
-					@children = []
-				end
-
-				def resolve_type type_stmt, yangs, current_module, typedef_list
-					case type_stmt.arg
-					when 'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'uint64'
-						type = IntegerType.new type_stmt.arg
-						type_stmt.substmts( Rubyang::Model::TypeBodyStmtList ).each{ |s|
-							case s
-							when Rubyang::Model::Range
-								type.update_range s.arg
-							else
-								raise ArgumentError, "#{s} is not valid"
-							end
-						}
-					when 'string'
-						type = StringType.new
-						type_stmt.substmts( Rubyang::Model::TypeBodyStmtList ).each{ |s|
-							case s
-							when Rubyang::Model::Length
-								type.update_length s.arg
-							when Rubyang::Model::Pattern
-								type.update_pattern s.arg
-							else
-								raise ArgumentError, "#{s} is not valid"
-							end
-						}
-					when 'boolean'
-						type = BooleanType.new
-						type_stmt.substmts( Rubyang::Model::TypeBodyStmtList ).each{ |s|
-							raise ArgumentError, "#{s} is not valid"
-						}
-					when 'enumeration'
-						type = EnumerationType.new
-						type_stmt.substmts( Rubyang::Model::TypeBodyStmtList ).each{ |s|
-							case s
-							when Rubyang::Model::Enum
-								type.update_enum s.arg
-							else
-								raise ArgumentError, "#{s} is not valid"
-							end
-						}
-					when 'bits'
-						type = BitsType.new
-						type_stmt.substmts( Rubyang::Model::TypeBodyStmtList ).each{ |s|
-							case s
-							when Rubyang::Model::Bit
-								type.update_bit s.arg
-							else
-								raise ArgumentError, "#{s} is not valid"
-							end
-						}
-					when 'binary'
-						type = BinaryType.new
-						type_stmt.substmts( Rubyang::Model::TypeBodyStmtList ).each{ |s|
-							case s
-							when Rubyang::Model::Length
-								type.update_length s.arg
-							else
-								raise ArgumentError, "#{s} is not valid"
-							end
-						}
-					when 'leafref'
-						type = LeafrefType.new self, type_stmt.substmt( 'path' )[0].arg
-					when 'empty'
-						type = EmptyType.new
-					when 'union'
-						type = UnionType.new
-						type_stmt.substmt( "type" ).each{ |s|
-							type.add_type( resolve_type s, yangs, current_module, typedef_list )
-						}
-					else
-						case type_stmt.arg
-						when /^[^:]+$/
-							arg = type_stmt.arg
-							if typedef_list.find{ |s| s.arg == arg }
-								typedef_stmt = typedef_list.find{ |s| s.arg == arg }
-								type = resolve_type typedef_stmt.substmt( 'type' )[0], yangs, current_module, typedef_list
-							else
-								include_submodule = current_module.substmt( 'include' ).map{ |s|
-									yangs.find{ |y| y.arg == s.arg }
-								}.find{ |s|
-									s.substmt( 'typedef' ).find{ |t| t.arg == arg }
-								}
-								typedef_stmt = include_submodule.substmt( 'typedef' ).find{ |s| s.arg == arg }
-								type = resolve_type typedef_stmt.substmt( 'type' )[0], yangs, include_submodule, include_submodule.substmt( 'typedef' )
-							end
-						when /^[^:]+:[^:]+$/
-							prefix, arg = type_stmt.arg.split(':')
-							case current_module
-							when Rubyang::Model::Module
-								case prefix
-								when current_module.substmt( 'prefix' )[0].arg
-									typedef_stmt = typedef_list.find{ |s| s.arg == arg }
-									type = resolve_type typedef_stmt.substmt( 'type' )[0], yangs, current_module, typedef_list
-								else
-									import_module = yangs.find{ |y|
-										y.arg == current_module.substmt( 'import' ).find{ |s| s.substmt( 'prefix' )[0].arg == prefix }.arg
-									}
-									typedef_stmt = import_module.substmt( 'typedef' ).find{ |s| s.arg == arg }
-									type = resolve_type typedef_stmt.substmt( 'type' )[0], yangs, import_module, import_module.substmt( 'typedef' )
-								end
-							when Rubyang::Model::Submodule
-								case prefix
-								when current_module.substmt( 'belongs-to' )[0].substmt( 'prefix' )[0].arg
-									typedef_stmt = typedef_list.find{ |s| s.arg == arg }
-									type = resolve_type typedef_stmt.substmt( 'type' )[0], yangs, current_module, typedef_list
-								else
-									import_module = yangs.find{ |y|
-										y.arg == current_module.substmt( 'import' ).find{ |s| s.substmt( 'prefix' )[0].arg == prefix }.arg
-									}
-									typedef_stmt = import_module.substmt( 'typedef' ).find{ |s| s.arg == arg }
-									type = resolve_type typedef_stmt.substmt( 'type' )[0], yangs, import_module, import_module.substmt( 'typedef' )
-								end
-							else
-								raise
-							end
-						end
+						raise "Unrecognized Expr: #{expr}"
 					end
-					type
 				end
 
-				def load_yang yang, yangs=@yangs, parent_module=yang, current_module=yang, grouping_list=[], typedef_list=[]
+				def load_yang yang, yangs=@yangs, parent_module=yang, current_module=yang, grouping_list=[], typedef_list=[], identity_list=[]
 					case yang
 					when Rubyang::Model::Module
 						yangs.push yang
@@ -821,47 +825,82 @@ module Rubyang
 						prefix_arg    = yang.substmt( 'prefix' )[0].arg
 						grouping_list += yang.substmt( 'grouping' )
 						typedef_list  += yang.substmt( 'typedef' )
+						identity_list += yang.substmt( 'identity' )
 						yang.substmt( 'include' ).each{ |i|
 							i.substmts( Rubyang::Model::DataDefStmtList ).each{ |s|
-								self.load_yang s, yangs, parent_module, i, i.substmt( 'grouping' ), i.substmt( 'typedef' )
+								self.load_yang s, yangs, parent_module, i, i.substmt( 'grouping' ), i.substmt( 'typedef' ), i.substmt( 'identity' )
 							}
 						}
 						yang.substmts( Rubyang::Model::DataDefStmtList ).each{ |s|
-							self.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list
+							self.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list
 						}
 					when Rubyang::Model::Submodule
 						yangs.push yang
+					when Rubyang::Model::Anyxml
+						arg = yang.arg
+						self.children.push Anyxml.new( yangs, arg, yang, self, parent_module )
 					when Rubyang::Model::Container
 						container_arg = yang.arg
 						grouping_list += yang.substmt( 'grouping' )
 						typedef_list  += yang.substmt( 'typedef' )
+						identity_list  += yang.substmt( 'identity' )
 						self.children.push Container.new( yangs, container_arg, yang, self, parent_module )
+						# when start
+						yang.substmt( "when" ).each{ |s|
+							self.children.last.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list
+						}
+						# end
+						# must start
+						yang.substmt( "must" ).each{ |s|
+							self.children.last.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list
+						}
+						# end
 						yang.substmts( Rubyang::Model::DataDefStmtList ).each{ |s|
-							self.children.last.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list
+							self.children.last.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list
 						}
 					when Rubyang::Model::Leaf
 						leaf_arg = yang.arg
-						type = self.resolve_type yang.substmt( 'type' )[0], yangs, current_module, typedef_list
-						self.children.push Leaf.new( yangs, leaf_arg, yang, self, parent_module, type )
+						self.children.push Leaf.new( yangs, leaf_arg, yang, self, parent_module, current_module, typedef_list, identity_list )
 					when Rubyang::Model::LeafList
 						leaf_arg = yang.arg
-						type = self.resolve_type yang.substmt( 'type' )[0], yangs, current_module, typedef_list
-						self.children.push LeafList.new( yangs, leaf_arg, yang, self, parent_module, type )
+						self.children.push LeafList.new( yangs, leaf_arg, yang, self, parent_module, current_module, typedef_list, identity_list )
+						# min-elements start
+						yang.substmt( "min-elements" ).each{ |s|
+							self.children.last.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list
+						}
+						# end
+						# max-elements start
+						yang.substmt( "max-elements" ).each{ |s|
+							self.children.last.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list
+						}
+						# end
 					when Rubyang::Model::List
 						list_arg = yang.arg
 						grouping_list += yang.substmt( 'grouping' )
 						typedef_list  += yang.substmt( 'typedef' )
+						identity_list  += yang.substmt( 'identity' )
 						self.children.push List.new( yangs, list_arg, yang, self, parent_module )
 						yang.substmts( Rubyang::Model::DataDefStmtList ).each{ |s|
-							self.children.last.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list
+							self.children.last.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list
+						}
+						# min-elements start
+						yang.substmt( "min-elements" ).each{ |s|
+							self.children.last.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list
 						}
+						# end
+						# max-elements start
+						yang.substmt( "max-elements" ).each{ |s|
+							self.children.last.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list
+						}
+						# end
 					when Rubyang::Model::Choice
 						choice_arg = yang.arg
 						grouping_list += yang.substmt( 'grouping' )
 						typedef_list  += yang.substmt( 'typedef' )
+						identity_list  += yang.substmt( 'identity' )
 						self.children.push Choice.new( yangs, choice_arg, yang, self, parent_module )
 						yang.substmts( Rubyang::Model::DataDefStmtList ).each{ |s|
-							self.children.last.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list
+							self.children.last.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list
 						}
 					when Rubyang::Model::Case
 						case_arg = yang.arg
@@ -869,19 +908,56 @@ module Rubyang
 						typedef_list  += yang.substmt( 'typedef' )
 						self.children.push Case.new( yangs, case_arg, yang, self, parent_module )
 						yang.substmts( Rubyang::Model::DataDefStmtList ).each{ |s|
-							self.children.last.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list
+							self.children.last.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list
 						}
 					when Rubyang::Model::Augment
 						target_node = self.resolve_node( yang.arg )
 						yang.substmts( Rubyang::Model::DataDefStmtList ).each{ |s|
-							target_node.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list
+							target_node.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list
 						}
 					when Rubyang::Model::Uses
-						self.resolve_uses( yang, yangs, parent_module, current_module, grouping_list, typedef_list )
+						self.resolve_uses( yang, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list )
+					# when start
+					when Rubyang::Model::When
+						require 'yaml'
+						puts ''
+						puts 'when statement'
+						puts ''
+						puts 'yang'
+						puts yang.to_yaml
+						self.whens.push When.new( self, yang )
+					# end
+					# must start
+					when Rubyang::Model::Must
+						@logger.debug yang
+						self.musts.push Must.new( self, yang )
+					# end
+					# min-elements start
+					when Rubyang::Model::MinElements
+						@logger.debug yang
+						self.min_elements.push MinElements.new( yang )
+					# end
+					# max-elements start
+					when Rubyang::Model::MaxElements
+						@logger.debug yang
+						self.max_elements.push MaxElements.new( yang )
+					# end
+					else
+						raise "#{yang.class} is not impletented yet"
 					end
 				end
+			end
 
-				def resolve_uses uses_stmt, yangs, parent_module, current_module, grouping_list, typedef_list
+			class InteriorSchemaNode < SchemaNode
+				attr_accessor :yangs, :arg, :yang, :parent, :children
+
+				def initialize yangs, arg, yang, parent, _module
+					super yangs, arg, yang, parent, _module
+					@children = []
+					@logger = Rubyang::Logger.instance
+				end
+
+				def resolve_uses uses_stmt, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list
 					case uses_stmt.arg
 					when /^[^:]+$/
 						arg = uses_stmt.arg
@@ -889,8 +965,9 @@ module Rubyang
 							grouping_stmt = grouping_list.find{ |s| s.arg == arg }
 							grouping_list += grouping_stmt.substmt( 'grouping' )
 							typedef_list  += grouping_stmt.substmt( 'typedef' )
+							identity_list += grouping_stmt.substmt( 'identity' )
 							grouping_stmt.substmts( Rubyang::Model::DataDefStmtList ).each{ |s|
-								self.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list
+								self.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list
 							}
 						else
 							include_submodule = current_module.substmt( 'include' ).map{ |s|
@@ -901,8 +978,9 @@ module Rubyang
 							grouping_stmt = include_submodule.substmt( 'grouping' ).find{ |s| s.arg == arg }
 							grouping_list = include_submodule.substmt( 'grouping' ) + grouping_stmt.substmt( 'grouping' )
 							typedef_list  = include_submodule.substmt( 'typedef' )  + grouping_stmt.substmt( 'typedef' )
+							identity_list = include_submodule.substmt( 'identity' )  + grouping_stmt.substmt( 'identity' )
 							grouping_stmt.substmt( Rubyang::Model::DataDefStmtList ).each{ |s|
-								self.load_yang s, yangs, parent_module, include_submodule, grouping_list, typedef_list
+								self.load_yang s, yangs, parent_module, include_submodule, grouping_list, typedef_list, identity_list
 							}
 						end
 					when /^[^:]+:[^:]+$/
@@ -914,8 +992,9 @@ module Rubyang
 								grouping_stmt = grouping_list.find{ |s| s.arg == arg }
 								grouping_list += grouping_stmt.substmt( 'grouping' )
 								typedef_list  += grouping_stmt.substmt( 'typedef' )
+								identity_list += grouping_stmt.substmt( 'identity' )
 								grouping_stmt.substmts( Rubyang::Model::DataDefStmtList ).each{ |s|
-									self.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list
+									self.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list
 								}
 							else
 								import_module = yangs.find{ |y|
@@ -924,8 +1003,9 @@ module Rubyang
 								grouping_stmt = import_module.substmt( 'grouping' ).find{ |s| s.arg == arg }
 								grouping_list = import_module.substmt( 'grouping' ) + grouping_stmt.substmt( 'grouping' )
 								typedef_list  = import_module.substmt( 'typedef' )  + grouping_stmt.substmt( 'typedef' )
+								identity_list = import_module.substmt( 'identity' )  + grouping_stmt.substmt( 'identity' )
 								grouping_stmt.substmts( Rubyang::Model::DataDefStmtList ).each{ |s|
-									self.load_yang s, yangs, parent_module, import_module, grouping_list, typedef_list
+									self.load_yang s, yangs, parent_module, import_module, grouping_list, typedef_list, identity_list
 								}
 							end
 						when Rubyang::Model::Submodule
@@ -934,8 +1014,9 @@ module Rubyang
 								grouping_stmt = grouping_list.find{ |s| s.arg == arg }
 								grouping_list += grouping_stmt.substmt( 'grouping' )
 								typedef_list  += grouping_stmt.substmt( 'typedef' )
+								identity_list += grouping_stmt.substmt( 'identity' )
 								grouping_stmt.substmts( Rubyang::Model::DataDefStmtList ).each{ |s|
-									self.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list
+									self.load_yang s, yangs, parent_module, current_module, grouping_list, typedef_list, identity_list
 								}
 							else
 								import_module = yangs.find{ |y|
@@ -944,8 +1025,9 @@ module Rubyang
 								grouping_stmt = import_module.substmt( 'grouping' ).find{ |s| s.arg == arg }
 								grouping_list = import_module.substmt( 'grouping' ) + grouping_stmt.substmt( 'grouping' )
 								typedef_list  = import_module.substmt( 'typedef' )  + grouping_stmt.substmt( 'typedef' )
+								identity_list = import_module.substmt( 'identity' )  + grouping_stmt.substmt( 'identity' )
 								grouping_stmt.substmts( Rubyang::Model::DataDefStmtList ).each{ |s|
-									self.load_yang s, yangs, parent_module, import_module, grouping_list, typedef_list
+									self.load_yang s, yangs, parent_module, import_module, grouping_list, typedef_list, identity_list
 								}
 							end
 						else
@@ -960,6 +1042,8 @@ module Rubyang
 							    self
 						    when '..'
 							    self
+						    when /[^:]+:[^:]+/
+							    @children.find{ |c| [c.prefix, c.model.arg].join(':') == path_splitted.first }
 						    else
 							    @children.find{ |c| c.model.arg == path_splitted.first }
 						    end
@@ -972,14 +1056,138 @@ module Rubyang
 			end
 
 			class LeafSchemaNode < SchemaNode
-				attr_reader :yangs, :arg, :yang, :parent, :module, :type
-				def initialize yangs, arg, yang, parent, _module, type
+				attr_reader :yangs, :arg, :yang, :parent, :module, :current_module, :typedef_list, :identity_list
+				def initialize yangs, arg, yang, parent, _module, current_module, typedef_list, identity_list
 					super yangs, arg, yang, parent, _module
-					@type = type
+					@type = self.resolve_type yang.substmt( 'type' )[0], yangs, current_module, typedef_list, identity_list
 				end
+
 				def type
 					@type
 				end
+
+				def resolve_type type_stmt, yangs, current_module, typedef_list, identity_list
+					case type_stmt.arg
+					when 'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'uint64'
+						type = IntegerType.new type_stmt.arg
+						type_stmt.substmts( Rubyang::Model::TypeBodyStmtList ).each{ |s|
+							case s
+							when Rubyang::Model::Range
+								type.update_range s.arg
+							else
+								raise ArgumentError, "#{s} is not valid"
+							end
+						}
+					when 'decimal64'
+						type = Decimal64Type.new type_stmt.arg
+					when 'string'
+						type = StringType.new
+						type_stmt.substmts( Rubyang::Model::TypeBodyStmtList ).each{ |s|
+							case s
+							when Rubyang::Model::Length
+								type.update_length s.arg
+							when Rubyang::Model::Pattern
+								type.update_pattern s.arg
+							else
+								raise ArgumentError, "#{s} is not valid"
+							end
+						}
+					when 'boolean'
+						type = BooleanType.new
+						type_stmt.substmts( Rubyang::Model::TypeBodyStmtList ).each{ |s|
+							raise ArgumentError, "#{s} is not valid"
+						}
+					when 'enumeration'
+						type = EnumerationType.new
+						type_stmt.substmts( Rubyang::Model::TypeBodyStmtList ).each{ |s|
+							case s
+							when Rubyang::Model::Enum
+								type.update_enum s.arg
+							else
+								raise ArgumentError, "#{s} is not valid"
+							end
+						}
+					when 'bits'
+						type = BitsType.new
+						type_stmt.substmts( Rubyang::Model::TypeBodyStmtList ).each{ |s|
+							case s
+							when Rubyang::Model::Bit
+								type.update_bit s.arg
+							else
+								raise ArgumentError, "#{s} is not valid"
+							end
+						}
+					when 'binary'
+						type = BinaryType.new
+						type_stmt.substmts( Rubyang::Model::TypeBodyStmtList ).each{ |s|
+							case s
+							when Rubyang::Model::Length
+								type.update_length s.arg
+							else
+								raise ArgumentError, "#{s} is not valid"
+							end
+						}
+					when 'leafref'
+						type = LeafrefType.new self, type_stmt.substmt( 'path' )[0].arg
+					when 'empty'
+						type = EmptyType.new
+					when 'union'
+						type = UnionType.new
+						type_stmt.substmt( "type" ).each{ |s|
+							type.add_type( resolve_type s, yangs, current_module, typedef_list, identity_list )
+						}
+					when 'identityref'
+						type = Identityref.new identity_list, type_stmt
+					else
+						case type_stmt.arg
+						when /^[^:]+$/
+							arg = type_stmt.arg
+							if typedef_list.find{ |s| s.arg == arg }
+								typedef_stmt = typedef_list.find{ |s| s.arg == arg }
+								type = resolve_type typedef_stmt.substmt( 'type' )[0], yangs, current_module, typedef_list, identity_list
+							else
+								include_submodule = current_module.substmt( 'include' ).map{ |s|
+									yangs.find{ |y| y.arg == s.arg }
+								}.find{ |s|
+									s.substmt( 'typedef' ).find{ |t| t.arg == arg }
+								}
+								typedef_stmt = include_submodule.substmt( 'typedef' ).find{ |s| s.arg == arg }
+								type = resolve_type typedef_stmt.substmt( 'type' )[0], yangs, include_submodule, include_submodule.substmt( 'typedef' ), include_submodule.substmt( 'identity' )
+							end
+						when /^[^:]+:[^:]+$/
+							prefix, arg = type_stmt.arg.split(':')
+							case current_module
+							when Rubyang::Model::Module
+								case prefix
+								when current_module.substmt( 'prefix' )[0].arg
+									typedef_stmt = typedef_list.find{ |s| s.arg == arg }
+									type = resolve_type typedef_stmt.substmt( 'type' )[0], yangs, current_module, typedef_list, identity_list
+								else
+									import_module = yangs.find{ |y|
+										y.arg == current_module.substmt( 'import' ).find{ |s| s.substmt( 'prefix' )[0].arg == prefix }.arg
+									}
+									typedef_stmt = import_module.substmt( 'typedef' ).find{ |s| s.arg == arg }
+									type = resolve_type typedef_stmt.substmt( 'type' )[0], yangs, import_module, import_module.substmt( 'typedef' ), import_module.substmt( 'identity' )
+								end
+							when Rubyang::Model::Submodule
+								case prefix
+								when current_module.substmt( 'belongs-to' )[0].substmt( 'prefix' )[0].arg
+									typedef_stmt = typedef_list.find{ |s| s.arg == arg }
+									type = resolve_type typedef_stmt.substmt( 'type' )[0], yangs, current_module, typedef_list, identity_list
+								else
+									import_module = yangs.find{ |y|
+										y.arg == current_module.substmt( 'import' ).find{ |s| s.substmt( 'prefix' )[0].arg == prefix }.arg
+									}
+									typedef_stmt = import_module.substmt( 'typedef' ).find{ |s| s.arg == arg }
+									type = resolve_type typedef_stmt.substmt( 'type' )[0], yangs, import_module, import_module.substmt( 'typedef' ), import_module.substmt( 'identity' )
+								end
+							else
+								raise
+							end
+						end
+					end
+					type
+				end
 			end
 
 			class Root < InteriorSchemaNode
@@ -1000,7 +1208,20 @@ module Rubyang
 				end
 			end
 
+			class Anyxml < SchemaNode
+				def initialize *args
+					super
+					@logger = Rubyang::Logger.instance
+				end
+			end
+
 			class Container < InteriorSchemaNode
+				attr_accessor :whens, :musts
+				def initialize *args
+					super
+					@whens = []
+					@musts = []
+				end
 				def to_json_recursive h
 					h['type'] = 'container'
 					h['arg'] = @arg
@@ -1030,12 +1251,33 @@ module Rubyang
 			end
 
 			class List < InteriorSchemaNode
+				# min-elements start
+				# max-elements start
+				attr_reader :min_elements, :max_elements
+				def initialize *args
+					super
+					@min_elements = []
+					@max_elements = []
+				end
+				# end
+				# end
+
 				def keys
 					@yang.substmt( 'key' )[0].arg.split( /[ \t]+/ )
 				end
 			end
 
 			class LeafList < LeafSchemaNode
+				# min-elements start
+				# max-elements start
+				attr_reader :min_elements, :max_elements
+				def initialize *args
+					super
+					@min_elements = []
+					@max_elements = []
+				end
+				# end
+				# end
 			end
 
 			class Choice < InteriorSchemaNode
@@ -1052,13 +1294,19 @@ module Rubyang
 			end
 			class Notification < SchemaNode
 			end
-			class Anyxml < SchemaNode
-			end
 
 			def initialize yangs
 				@yangs = yangs
 				@root  = Root.new @yangs
 			end
+			def to_s parent=true
+				head, vars, tail = "#<#{self.class.to_s}:0x#{(self.object_id << 1).to_s(16).rjust(14,'0')} ", Array.new, ">"
+				if parent
+					vars.push "@yangs=#{@yangs.to_s}"
+					vars.push "@root=#{@root.to_s( false )}"
+				end
+				head + vars.join(', ') + tail
+			end
 			def root
 				@root
 			end