• Home
• com.yahoo.vespa
• configgen
• 7.379.1
• source code
• CppClassBuilder.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.yahoo.config.codegen.CppClassBuilder Maven / Gradle / Ivy

// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.config.codegen;

import java.io.FileWriter;
import java.io.File;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.FileReader;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Map;
import java.util.HashMap;
import java.util.Collections;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.stream.Collectors;

/**
 * This class autogenerates C++ code for the C++ config, based on a CNode tree given.
 */
public class CppClassBuilder implements ClassBuilder {

    private final CNode root;
    private final NormalizedDefinition nd;
    private final File rootDir;
    private final String relativePathUnderRoot;
    private static final Map vectorTypeDefs;
    static {
        Map map = new HashMap();
        map.put("bool", "BoolVector");
        map.put("int32_t", "IntVector");
        map.put("int64_t", "LongVector");
        map.put("double", "DoubleVector");
        map.put("vespalib::string", "StringVector");
        vectorTypeDefs = Collections.unmodifiableMap(map);
    }
    private static final Map mapTypeDefs;
    static {
        Map map = new HashMap<>();
        map.put("bool", "BoolMap");
        map.put("int32_t", "IntMap");
        map.put("int64_t", "LongMap");
        map.put("double", "DoubleMap");
        map.put("vespalib::string", "StringMap");
        mapTypeDefs = Collections.unmodifiableMap(map);
    }
    private static final Map slimeTypeMap;
    static {
        Map map = new HashMap();
        map.put("bool", "Bool");
        map.put("int", "Long");
        map.put("long", "Long");
        map.put("double", "Double");
        map.put("string", "String");
        map.put("enum", "String");
        map.put("file", "String");
        map.put("reference", "String");
        slimeTypeMap = Collections.unmodifiableMap(map);
    }

    public CppClassBuilder(CNode root, NormalizedDefinition nd, File rootDir, String relativePathUnderRoot) {
        this.root = root;
        this.nd = nd;
        this.rootDir = rootDir;
        this.relativePathUnderRoot = relativePathUnderRoot;
    }

    public void createConfigClasses() {
        generateConfig(root, nd);
    }

    String readFile(File f) throws IOException {
        if (!f.isFile()) return null;
        StringBuilder sb = new StringBuilder();
        try (BufferedReader sr = new BufferedReader(new FileReader(f))) {
            while (true) {
                String line = sr.readLine();
                if (line == null) break;
                sb.append(line).append("\n");
            }
            return sb.toString();
        }
    }

    void writeFile(File f, String content) throws IOException {
        FileWriter fw = new FileWriter(f);
        fw.write(content);
        fw.close();
    }

    void generateConfig(CNode root, NormalizedDefinition nd) {
        try{
            StringWriter headerWriter = new StringWriter();
            StringWriter bodyWriter = new StringWriter();
            writeHeaderFile(headerWriter, root);
            writeBodyFile(bodyWriter, root, relativePathUnderRoot, nd);

            String newHeader = headerWriter.toString();
            String newBody = bodyWriter.toString();

            File headerFile = new File(rootDir, relativePathUnderRoot + "/" + getFileName(root, "h"));
            File bodyFile = new File(rootDir, relativePathUnderRoot + "/" + getFileName(root, "cpp"));

            writeFile(headerFile, newHeader);
            writeFile(bodyFile, newBody);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    String getFileName(CNode node, String extension) {
        return "config-" + node.getName() + "." + extension;
    }

    static String removeDashesAndUpperCaseAllFirstChars(String source, boolean capitalizeFirst) {
        // Create upper case chars after each dash
        String parts[] = source.split("[-_]");
        StringBuilder sb = new StringBuilder();
        for (String s : parts) {
            sb.append(s.substring(0, 1).toUpperCase()).append(s.substring(1));
        }
        String result = sb.toString();
        if (!capitalizeFirst) {
            result = result.substring(0,1).toLowerCase() + result.substring(1);
        }
        return result;
    }

    /** Convert name of type to the name we want to use in macro ifdefs in file. */
    String getDefineName(String name) {
        return name.toUpperCase().replace("-", "");
    }

    /** Convert name of type to the name we want to use as type name in the generated code. */
    static String getTypeName(String name) {
        return removeDashesAndUpperCaseAllFirstChars(name, true);
    }

    /** Convert name of an identifier from value in def file to name to use in C++ file. */
    String getIdentifier(String name) {
        return removeDashesAndUpperCaseAllFirstChars(name, false);
    }

    /**
     * Class to generate noexcept specifier if default constructor, copy constructor or copy assignment is non-throwing
     */
    private static class NoExceptSpecifier {
        private boolean enabled;

        public NoExceptSpecifier(CNode node) {
                enabled = checkNode(node);
        }

        private static boolean checkNode(CNode node) {
            if (node instanceof InnerCNode) {
                for (CNode child: node.getChildren()) {
                    if (child.isArray || child.isMap) {
                        return false;
                    }
                    if (!checkNode(child)) {
                        return false;
                    }
                }
            }
            return true;
        }

        public String toString() {
            if (enabled) {
                return " noexcept";
            } else {
                return "";
            }
        }
    }

    void writeHeaderFile(Writer w, CNode root) throws IOException {
        writeHeaderHeader(w, root);
        writeHeaderPublic(w, root);
        writeHeaderFooter(w, root);
    }

    void writeHeaderPublic(Writer w, CNode root) throws IOException {
        w.write("public:\n");
        writeHeaderTypeDefs(w, root, "    ");
        writeTypeDeclarations(w, root, "    ");
        writeHeaderFunctionDeclarations(w, getTypeName(root, false), root, "    ");
        writeStaticMemberDeclarations(w, "    ");
        writeMembers(w, root, "    ");
    }

    String [] generateCppNameSpace(CNode root) {
        String namespace = root.getNamespace();
        if (namespace.contains(".")) {
            return namespace.split("\\.");
        }
        return new String[]{namespace};
    }

    String generateCppNameSpaceString(String[] namespaceList) {
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < namespaceList.length - 1; i++) {
            str.append(namespaceList[i]);
            str.append("::");
        }
        str.append(namespaceList[namespaceList.length - 1]);
        return str.toString();
    }

    String generateCppNameSpaceDefine(String[] namespaceList) {
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < namespaceList.length - 1; i++) {
            str.append(namespaceList[i].toUpperCase());
            str.append("_");
        }
        str.append(namespaceList[namespaceList.length - 1].toUpperCase());
        return str.toString();
    }

    void writeNameSpaceBegin(Writer w, String [] namespaceList) throws IOException {
        w.write("namespace ");
        w.write(getNestedNameSpace(namespaceList));
        w.write(" {\n");
    }

    String getNestedNameSpace(String [] namespaceList) {
        return Arrays.stream(namespaceList).map(String::toString).collect(Collectors.joining("::"));
    }

    void writeNameSpaceEnd(Writer w, String [] namespaceList) throws IOException {
        w.write("} // namespace ");
        w.write(getNestedNameSpace(namespaceList));
        w.write("\n");
    }

    void writeHeaderHeader(Writer w, CNode root) throws IOException {
        String [] namespaceList = generateCppNameSpace(root);
        String namespacePrint = generateCppNameSpaceString(namespaceList);
        String namespaceDefine = generateCppNameSpaceDefine(namespaceList);
        String className = getTypeName(root, false);
        String defineName = namespaceDefine + "_" + getDefineName(className);
        w.write(""
                + "/**\n"
                + " * @class " + namespacePrint + "::" + className + "\n"
                + " * @ingroup config\n"
                + " *\n"
                + " * @brief This is an autogenerated class for handling VESPA config.\n"
                + " *\n"
                + " * This class is autogenerated by vespa from a config definition file.\n"
                + " * To subscribe to config, you need to include the config/config.h header, \n"
                + " * and create a ConfigSubscriber in order to subscribe for config.\n"
                );
        if (root.getComment().length() > 0) {
            w.write(" *\n");
            StringTokenizer st = new StringTokenizer(root.getComment(), "\n");
            while (st.hasMoreTokens()) {
                w.write(" * " + st.nextToken() + "\n");
            }
        }
        w.write(""
                + " */\n"
                + "#ifndef CLOUD_CONFIG_" + defineName + "_H\n"
                + "#define CLOUD_CONFIG_" + defineName + "_H\n"
                + "\n"
                + "#include \n"
                + "#include \n"
                + "#include \n"
                + "#include