Java Node类代码示例

import org.raml.yagi.framework.nodes.Node; //导入依赖的package包/类
@Override
public boolean handleSafely(ObjectNode node, YamlEmitter emitter) throws IOException {

    for (Node child : node.getChildren()) {

        String scalar = isScalar(node.getChildren().get(0));
        if ( scalar != null ) {

            emitter.writeObjectValue(scalar);
        } else {

            handlerList.handle(child, emitter);
        }
    }

    return true;
}
 

import org.raml.yagi.framework.nodes.Node; //导入依赖的package包/类
@Override
public ArrayList<String> getIs() {
	ArrayList<String>traits=new ArrayList<>();
	Node childNodeWithKey = this.getChildNodeWithKey("is");
	if (childNodeWithKey instanceof ArrayNode){
		ArrayNode rr=(ArrayNode) childNodeWithKey;
		
		for (Node n:rr.getChildren()){
			if (n instanceof TraitRefNode){
				TraitRefNode tr=(TraitRefNode) n;
				String value = tr.getValue();
				traits.add(value);
			}
		}
	}
	return traits;
}
 

import org.raml.yagi.framework.nodes.Node; //导入依赖的package包/类
@Override
public List<Annotation> annotations() {
	ArrayList<Annotation>results=new ArrayList<>();
	
	Node node=this.original;
	if (node==null){
		return Collections.emptyList();
	}
	if (node instanceof KeyValueNode){
		KeyValueNode kv=(KeyValueNode) node;
		node=kv.getValue();
	}
	for (Node n:node.getChildren()){
		if (n instanceof AnnotationNode){
			AnnotationNode mn=(AnnotationNode) n;
			Object val=TopLevelRamlModelBuilder.toObject(mn.getValue());
			String literalValue = mn.getKey().getLiteralValue();
			Annotation as = new Annotation(literalValue.substring(1, literalValue.length() - 1), val, null);
			TopLevelRamlModelBuilder.bindAnnotation(this.getTopLevel(), as);
			results.add(as);
		}
	}
	return results;
}
 

import org.raml.yagi.framework.nodes.Node; //导入依赖的package包/类
public List<String> getStringList(String key) {
	Node childNodeWithKey = this.getChildNodeWithKey(key);
	ArrayList<String>results=new ArrayList<>();
	if (childNodeWithKey!=null){
		if (childNodeWithKey instanceof SYStringNode){
			results.add(((SYStringNode) childNodeWithKey).getLiteralValue());
		}
		else for (Node n:childNodeWithKey.getChildren()){
			if (n instanceof SimpleTypeNode){
				SimpleTypeNode<?>tn=(SimpleTypeNode<?>) n;
				results.add(tn.getLiteralValue());
			}
			
		}
	}
	return results;
}
 

import org.raml.yagi.framework.nodes.Node; //导入依赖的package包/类
protected Node getChildNodeWithKey(String key) {
	Node nodeo=this.original;
	if (nodeo==null){
		return null;
	}
	if (nodeo instanceof KeyValueNode){
		KeyValueNode kv=(KeyValueNode) nodeo;
		nodeo=kv.getValue();
	}
	for (Node n:nodeo.getChildren()){
		if (n instanceof KeyValueNode){
			KeyValueNode node=(KeyValueNode) n;
			if (node.getKey() instanceof StringNode){
				StringNode nnm=(StringNode) node.getKey();
				if (nnm.getValue().equals(key)){
					Node value = node.getValue();
					return value;
				}
			}
		}
	}
	return null;
}
 

import org.raml.yagi.framework.nodes.Node; //导入依赖的package包/类
public ArrayList<SecuredByConfig> securedBy() {
	ArrayList<SecuredByConfig> results = new ArrayList<>();
	Node childNodeWithKey = this.getChildNodeWithKey("securedBy");
	if (childNodeWithKey != null) {
		for (Node n : childNodeWithKey.getChildren()) {
			if (n instanceof ErrorNode) {
				ErrorNode zz = (ErrorNode) n;
				Node source = zz.getSource();
				if (source instanceof org.raml.v2.internal.impl.commons.nodes.ParametrizedSecuritySchemeRefNode) {
					n = source;
				}
			}
			results.add(new SecuredByImpl(mdl, this, n));
		}
	}
	return results;
}
 

import org.raml.yagi.framework.nodes.Node; //导入依赖的package包/类
private void parseProperties(TopLevelRamlImpl topLevelRamlImpl, boolean register, AbstractType result,
		List<Node> ps, boolean useNames) {
	for (Node p : ps) {
		KeyValueNode pn = (KeyValueNode) p;
		Node value = pn.getValue();
		String name = getPropertyName(pn);
		AbstractType buildType = buildType(topLevelRamlImpl, useNames ? name : "", value, register);
		boolean required = isRequired(pn);

		if (name.startsWith("/") && name.endsWith("/") && name.length() != 1) {
			if (name.length() != 2) {
				result.declareMapProperty(name.substring(1, name.length() - 1), buildType);
			} else {
				result.declareAdditionalProperty(buildType);
			}
		} else {
			result.declareProperty(name, buildType, !required);
		}
	}
}
 

import org.raml.yagi.framework.nodes.Node; //导入依赖的package包/类
public LinkedHashMap<String, String> getUsesLocations() {
	LinkedHashMap<String, String> results = new LinkedHashMap<>();
	Node childNodeWithKey = getChildNodeWithKey("uses");
	if (childNodeWithKey != null) {
		for (Node ch : childNodeWithKey.getChildren()) {
			if (ch instanceof LibraryNode) {
				LibraryNode ln = (LibraryNode) ch;
				LibraryLinkNode lnv = (LibraryLinkNode) ln.getValue();
				if (lnv != null) {
					String path = lnv.getRefName();
					String key =( (SYStringNode) ln.getKey()).getLiteralValue();
					results.put(key, path);
				}
			}				
		}
	}
	return results;
}
 

import org.raml.yagi.framework.nodes.Node; //导入依赖的package包/类
@Test
public void pojoToRamlTypeBuilder() throws Exception {

    PojoToRamlImpl pojoToRaml = new PojoToRamlImpl(FieldClassParser.factory(), RamlAdjuster.NULL_ADJUSTER);
    Result types =  pojoToRaml.classToRaml(Fun.class);

    RamlDocumentBuilder ramlDocumentBuilder = RamlDocumentBuilder
            .document()
            .baseUri("http://google.com")
            .title("hello")
            .version("1")
            .withTypes(types.allTypes().toArray(new TypeDeclarationBuilder[0]));

    Api api = ramlDocumentBuilder.buildModel();

    final GrammarPhase grammarPhase = new GrammarPhase(RamlHeader.getFragmentRule(new RamlHeader(RAML_10, Default).getFragment()));
    Node node = ((NodeModel) api).getNode();
    Node checked = grammarPhase.apply(node);
    List<ErrorNode> errors = checked.findDescendantsWith(ErrorNode.class);
    for (ErrorNode error : errors) {
        System.err.println("error: " + error.getErrorMessage());
    }

    List<TypeDeclaration> buildTypes = api.types();

    assertEquals(2, buildTypes.size());
    assertEquals("Fun", buildTypes.get(0).name());
    assertEquals("SubFun", buildTypes.get(1).name());

}
 

import org.raml.yagi.framework.nodes.Node; //导入依赖的package包/类
public static NodeBuilder property(final String key, final String value) {

        return new NodeBuilder() {
            @Override
            public Node buildNode() {
                return new KeyValueNodeImpl(new StringNodeImpl(key), new StringNodeImpl(value));
            }
        };
    }
 

import org.raml.yagi.framework.nodes.Node; //导入依赖的package包/类
public static NodeBuilder arrayProperty(final String name, final String... values) {

        return new NodeBuilder() {
            @Override
            public Node buildNode() {
                SimpleArrayNode san = new SimpleArrayNode();
                for (String value : values) {
                    san.addChild(new StringNodeImpl(value));
                }
                return new KeyValueNodeImpl(new StringNodeImpl(name), san);
            }
        };
    }
 

import org.raml.yagi.framework.nodes.Node; //导入依赖的package包/类
@Override
protected Node createValueNode() {
    if ( types != null ) {

        return types.buildNode();
    } else {

        return super.createValueNode();
    }
}
 

import org.raml.yagi.framework.nodes.Node; //导入依赖的package包/类
public Api buildModel() {

        NodeModelFactory fac = binding.bindingOf(Api.class);
        Node node = buildNode();
        NodeModel model = fac.create(node);
        return  ModelProxyBuilder.createModel(Api.class, model, binding);
    }
 

import org.raml.yagi.framework.nodes.Node; //导入依赖的package包/类
@Override
protected Node createValueNode() {

    if ( string != null ) {

        return new StringNodeImpl(string);
    } else {
        return new NumberNode(number);
    }
}
 

import org.raml.yagi.framework.nodes.Node; //导入依赖的package包/类
public static<T> T buildModel(ModelBindingConfiguration binding, Node node, Class<T> cls) {
    NodeModelFactory fac = binding.bindingOf(cls);
    NodeModel model = fac.create(node);
    T m =  ModelProxyBuilder.createModel(cls, model, binding);

    final GrammarPhase grammarPhase = new GrammarPhase(RamlHeader.getFragmentRule(new RamlHeader(RAML_10, Default).getFragment()));
    Node newNode = ((NodeModel) m).getNode().copy();
    grammarPhase.apply(newNode);

    return m;

}