diff --git a/src/CTree.cpp b/src/CTree.cpp
deleted file mode 100644
index 6840697..0000000
--- a/src/CTree.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright (C) 2018 CESNET, https://photonics.cesnet.cz/
- * Copyright (C) 2018 FIT CVUT, https://fit.cvut.cz/
- *
- * Written by Václav Kubernát <kubervac@fit.cvut.cz>
- *
-*/
-
-#include <iostream>
-#include "CTree.hpp"
-#include "utils.hpp"
-
-InvalidNodeException::~InvalidNodeException() = default;
-
-
-std::string pathToString(const path_& path)
-{
-   std::string res;
-   for (const auto it : path.m_nodes)
-       res = joinPaths(res, boost::apply_visitor(nodeToString(), it));
-   return res;
-}
-
-CTree::CTree()
-{
-    m_nodes.emplace("", std::unordered_map<std::string, NodeType>());
-}
-
-const std::unordered_map<std::string, NodeType>& CTree::children(const std::string& name) const
-{
-    return m_nodes.at(name);
-}
-
-bool CTree::nodeExists(const std::string& location, const std::string& name) const
-{
-    if (name.empty())
-        return true;
-    const auto& childrenRef = children(location);
-
-    return childrenRef.find(name) != childrenRef.end();
-}
-
-bool CTree::isContainer(const path_& location, const std::string& name) const
-{
-    std::string locationString = pathToString(location);
-    if (!nodeExists(locationString, name))
-        return false;
-
-    return children(locationString).at(name).type() == typeid(schema::container);
-}
-
-void CTree::addContainer(const std::string& location, const std::string& name)
-{
-    m_nodes.at(location).emplace(name, schema::container{});
-
-    //create a new set of children for the new node
-    std::string key = joinPaths(location, name);
-    m_nodes.emplace(key, std::unordered_map<std::string, NodeType>());
-}
-
-
-bool CTree::listHasKey(const path_& location, const std::string& name, const std::string& key) const
-{
-    std::string locationString = pathToString(location);
-    assert(isList(location, name));
-
-    const auto& child = children(locationString).at(name);
-    const auto& list = boost::get<schema::list>(child);
-    return list.m_keys.find(key) != list.m_keys.end();
-}
-
-const std::set<std::string>& CTree::listKeys(const path_& location, const std::string& name) const
-{
-    std::string locationString = pathToString(location);
-    assert(isList(location, name));
-
-    const auto& child = children(locationString).at(name);
-    const auto& list = boost::get<schema::list>(child);
-    return list.m_keys;
-}
-
-bool CTree::isList(const path_& location, const std::string& name) const
-{
-    std::string locationString = pathToString(location);
-    if (!nodeExists(locationString, name))
-        return false;
-    const auto& child = children(locationString).at(name);
-    if (child.type() != typeid(schema::list))
-        return false;
-
-    return true;
-}
-
-void CTree::addList(const std::string& location, const std::string& name, const std::set<std::string>& keys)
-{
-    m_nodes.at(location).emplace(name, schema::list{keys});
-
-    m_nodes.emplace(name, std::unordered_map<std::string, NodeType>());
-}
-
diff --git a/src/ast.cpp b/src/ast.cpp
index 9c96bd2..9345192 100644
--- a/src/ast.cpp
+++ b/src/ast.cpp
@@ -40,5 +40,3 @@
 {
     return this->m_path == b.m_path;
 }
-
-
diff --git a/src/ast.hpp b/src/ast.hpp
index 0c257d0..90e007a 100644
--- a/src/ast.hpp
+++ b/src/ast.hpp
@@ -21,14 +21,14 @@
 namespace x3 = boost::spirit::x3;
 namespace ascii = boost::spirit::x3::ascii;
 
-using x3::alpha;
-using x3::alnum;
-using x3::lit;
-using x3::char_;
-using x3::_attr;
-using x3::lexeme;
-using x3::expect;
 using ascii::space;
+using x3::_attr;
+using x3::alnum;
+using x3::alpha;
+using x3::char_;
+using x3::expect;
+using x3::lexeme;
+using x3::lit;
 using boost::fusion::operator<<;
 
 
@@ -41,7 +41,7 @@
 struct nodeup_ {
     bool operator==(const nodeup_&) const
     {
-       return true;
+        return true;
     }
 };
 
diff --git a/src/ast_handlers.hpp b/src/ast_handlers.hpp
index ce8a196..0c7f1c3 100644
--- a/src/ast_handlers.hpp
+++ b/src/ast_handlers.hpp
@@ -8,20 +8,20 @@
 
 #pragma once
 
-#include "CTree.hpp"
 #include "parser_context.hpp"
+#include "schema.hpp"
 
 struct keyValue_class {
     template <typename T, typename Iterator, typename Context>
     void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
     {
         auto& parserContext = x3::get<parser_context_tag>(context);
-        const CTree& tree = parserContext.m_tree;
+        const Schema& schema = parserContext.m_schema;
 
         if (parserContext.m_tmpListKeys.find(ast.first) != parserContext.m_tmpListKeys.end()) {
             _pass(context) = false;
             parserContext.m_errorMsg = "Key \"" + ast.first + "\" was entered more than once.";
-        } else if (tree.listHasKey(parserContext.m_curPath, parserContext.m_tmpListName, ast.first)) {
+        } else if (schema.listHasKey(parserContext.m_curPath, parserContext.m_tmpListName, ast.first)) {
             parserContext.m_tmpListKeys.insert(ast.first);
         } else {
             _pass(context) = false;
@@ -36,9 +36,9 @@
     void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
     {
         auto& parserContext = x3::get<parser_context_tag>(context);
-        const CTree& tree = parserContext.m_tree;
+        const Schema& schema = parserContext.m_schema;
 
-        if (tree.isList(parserContext.m_curPath, ast)) {
+        if (schema.isList(parserContext.m_curPath, ast)) {
             parserContext.m_tmpListName = ast;
         } else {
             _pass(context) = false;
@@ -51,9 +51,9 @@
     void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
     {
         auto& parserContext = x3::get<parser_context_tag>(context);
-        const CTree& tree = parserContext.m_tree;
+        const Schema& schema = parserContext.m_schema;
 
-        const auto& keysNeeded = tree.listKeys(parserContext.m_curPath, parserContext.m_tmpListName);
+        const auto& keysNeeded = schema.listKeys(parserContext.m_curPath, parserContext.m_tmpListName);
         std::set<std::string> keysSupplied;
         for (const auto& it : ast)
             keysSupplied.insert(it.first);
@@ -119,9 +119,9 @@
     void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
     {
         auto& parserContext = x3::get<parser_context_tag>(context);
-        const auto& tree = parserContext.m_tree;
+        const auto& schema = parserContext.m_schema;
 
-        if (tree.isContainer(parserContext.m_curPath, ast.m_name)) {
+        if (schema.isContainer(parserContext.m_curPath, ast.m_name)) {
             parserContext.m_curPath.m_nodes.push_back(ast);
         } else {
             _pass(context) = false;
diff --git a/src/main.cpp b/src/main.cpp
index 607115e..c40f2ae 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -10,9 +10,9 @@
 #include <docopt.h>
 #include <iostream>
 #include <string>
-#include "CParser.hpp"
-#include "CTree.hpp"
 #include "NETCONF_CLI_VERSION.h"
+#include "parser.hpp"
+#include "schema.hpp"
 
 
 static const char usage[] =
@@ -28,16 +28,16 @@
 namespace ascii = boost::spirit::x3::ascii;
 
 using Cmd = std::vector<std::string>;
-using x3::alpha;
-using x3::lit;
-using x3::char_;
-using x3::_attr;
-using x3::lexeme;
 using ascii::space;
+using x3::_attr;
+using x3::alpha;
+using x3::char_;
+using x3::lexeme;
+using x3::lit;
 
-void interpret(cd_ command, CParser& tree)
+void interpret(cd_ command, Parser& parser)
 {
-    tree.changeNode(command.m_path);
+    parser.changeNode(command.m_path);
 }
 
 int main(int argc, char* argv[])
@@ -49,17 +49,17 @@
                                true);
     std::cout << "Welcome to netconf-cli" << std::endl;
 
-    CTree tree;
-    tree.addContainer("", "a");
-    tree.addContainer("", "b");
-    tree.addContainer("a", "a2");
-    tree.addContainer("b", "b2");
-    tree.addContainer("a/a2", "a3");
-    tree.addContainer("b/b2", "b3");
-    tree.addList("", "list", {"number"});
-    tree.addContainer("list", "contInList");
-    tree.addList("", "twoKeyList", {"number", "name"});
-    CParser parser(tree);
+    Schema schema;
+    schema.addContainer("", "a");
+    schema.addContainer("", "b");
+    schema.addContainer("a", "a2");
+    schema.addContainer("b", "b2");
+    schema.addContainer("a/a2", "a3");
+    schema.addContainer("b/b2", "b3");
+    schema.addList("", "list", {"number"});
+    schema.addContainer("list", "contInList");
+    schema.addList("", "twoKeyList", {"number", "name"});
+    Parser parser(schema);
 
     while (true) {
         std::cout << parser.currentNode() << ">";
diff --git a/src/CParser.cpp b/src/parser.cpp
similarity index 81%
rename from src/CParser.cpp
rename to src/parser.cpp
index cb81de0..87ed317 100644
--- a/src/CParser.cpp
+++ b/src/parser.cpp
@@ -6,22 +6,22 @@
  *
 */
 #include <ostream>
-#include "CParser.hpp"
+#include "parser.hpp"
 
 TooManyArgumentsException::~TooManyArgumentsException() = default;
 
 InvalidCommandException::~InvalidCommandException() = default;
 
 
-CParser::CParser(const CTree& tree)
-    : m_tree(tree)
+Parser::Parser(const Schema& schema)
+    : m_schema(schema)
 {
 }
 
-cd_ CParser::parseCommand(const std::string& line, std::ostream& errorStream)
+cd_ Parser::parseCommand(const std::string& line, std::ostream& errorStream)
 {
     cd_ parsedCommand;
-    ParserContext ctx(m_tree, m_curDir);
+    ParserContext ctx(m_schema, m_curDir);
     auto it = line.begin();
 
     boost::spirit::x3::error_handler<std::string::const_iterator> errorHandler(it, line.end(), errorStream);
@@ -39,7 +39,7 @@
     return parsedCommand;
 }
 
-void CParser::changeNode(const path_& name)
+void Parser::changeNode(const path_& name)
 {
     for (const auto& it : name.m_nodes) {
         if (it.type() == typeid(nodeup_))
@@ -49,7 +49,7 @@
     }
 }
 
-std::string CParser::currentNode() const
+std::string Parser::currentNode() const
 {
     std::string res;
     for (const auto& it : m_curDir.m_nodes) {
diff --git a/src/CParser.hpp b/src/parser.hpp
similarity index 92%
rename from src/CParser.hpp
rename to src/parser.hpp
index bf21300..feb7911 100644
--- a/src/CParser.hpp
+++ b/src/parser.hpp
@@ -12,12 +12,12 @@
 namespace x3 = boost::spirit::x3;
 namespace ascii = boost::spirit::x3::ascii;
 using Cmd = std::vector<std::string>;
-using x3::alpha;
-using x3::lit;
-using x3::char_;
-using x3::_attr;
-using x3::lexeme;
 using ascii::space;
+using x3::_attr;
+using x3::alpha;
+using x3::char_;
+using x3::lexeme;
+using x3::lit;
 
 class InvalidCommandException : public std::invalid_argument {
 public:
@@ -32,14 +32,14 @@
 };
 
 
-class CParser {
+class Parser {
 public:
-    CParser(const CTree& tree);
+    Parser(const Schema& schema);
     cd_ parseCommand(const std::string& line, std::ostream& errorStream);
     void changeNode(const path_& name);
     std::string currentNode() const;
 
 private:
-    const CTree& m_tree;
+    const Schema& m_schema;
     path_ m_curDir;
 };
diff --git a/src/parser_context.cpp b/src/parser_context.cpp
index db2bb43..d3b4a90 100644
--- a/src/parser_context.cpp
+++ b/src/parser_context.cpp
@@ -7,8 +7,8 @@
 */
 
 #include "parser_context.hpp"
-ParserContext::ParserContext(const CTree& tree, const path_ curDir)
-        : m_tree(tree)
+ParserContext::ParserContext(const Schema& schema, const path_ curDir)
+    : m_schema(schema)
 {
     m_curPath = curDir;
 }
diff --git a/src/parser_context.hpp b/src/parser_context.hpp
index 2c90120..99c1a63 100644
--- a/src/parser_context.hpp
+++ b/src/parser_context.hpp
@@ -6,10 +6,10 @@
  *
 */
 
-#include "CTree.hpp"
+#include "schema.hpp"
 struct ParserContext {
-    ParserContext(const CTree& tree, const path_ curDir);
-    const CTree& m_tree;
+    ParserContext(const Schema& schema, const path_ curDir);
+    const Schema& m_schema;
     path_ m_curPath;
     std::string m_errorMsg;
     std::string m_tmpListName;
diff --git a/src/schema.cpp b/src/schema.cpp
new file mode 100644
index 0000000..aaaab8b
--- /dev/null
+++ b/src/schema.cpp
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2018 CESNET, https://photonics.cesnet.cz/
+ * Copyright (C) 2018 FIT CVUT, https://fit.cvut.cz/
+ *
+ * Written by Václav Kubernát <kubervac@fit.cvut.cz>
+ *
+*/
+
+#include <iostream>
+#include "schema.hpp"
+#include "utils.hpp"
+
+InvalidNodeException::~InvalidNodeException() = default;
+
+
+std::string pathToString(const path_& path)
+{
+    std::string res;
+    for (const auto it : path.m_nodes)
+        res = joinPaths(res, boost::apply_visitor(nodeToString(), it));
+    return res;
+}
+
+Schema::Schema()
+{
+    m_nodes.emplace("", std::unordered_map<std::string, NodeType>());
+}
+
+const std::unordered_map<std::string, NodeType>& Schema::children(const std::string& name) const
+{
+    return m_nodes.at(name);
+}
+
+bool Schema::nodeExists(const std::string& location, const std::string& name) const
+{
+    if (name.empty())
+        return true;
+    const auto& childrenRef = children(location);
+
+    return childrenRef.find(name) != childrenRef.end();
+}
+
+bool Schema::isContainer(const path_& location, const std::string& name) const
+{
+    std::string locationString = pathToString(location);
+    if (!nodeExists(locationString, name))
+        return false;
+
+    return children(locationString).at(name).type() == typeid(yang::container);
+}
+
+void Schema::addContainer(const std::string& location, const std::string& name)
+{
+    m_nodes.at(location).emplace(name, yang::container{});
+
+    //create a new set of children for the new node
+    std::string key = joinPaths(location, name);
+    m_nodes.emplace(key, std::unordered_map<std::string, NodeType>());
+}
+
+
+bool Schema::listHasKey(const path_& location, const std::string& name, const std::string& key) const
+{
+    std::string locationString = pathToString(location);
+    assert(isList(location, name));
+
+    const auto& child = children(locationString).at(name);
+    const auto& list = boost::get<yang::list>(child);
+    return list.m_keys.find(key) != list.m_keys.end();
+}
+
+const std::set<std::string>& Schema::listKeys(const path_& location, const std::string& name) const
+{
+    std::string locationString = pathToString(location);
+    assert(isList(location, name));
+
+    const auto& child = children(locationString).at(name);
+    const auto& list = boost::get<yang::list>(child);
+    return list.m_keys;
+}
+
+bool Schema::isList(const path_& location, const std::string& name) const
+{
+    std::string locationString = pathToString(location);
+    if (!nodeExists(locationString, name))
+        return false;
+    const auto& child = children(locationString).at(name);
+    if (child.type() != typeid(yang::list))
+        return false;
+
+    return true;
+}
+
+void Schema::addList(const std::string& location, const std::string& name, const std::set<std::string>& keys)
+{
+    m_nodes.at(location).emplace(name, yang::list{keys});
+
+    m_nodes.emplace(name, std::unordered_map<std::string, NodeType>());
+}
diff --git a/src/CTree.hpp b/src/schema.hpp
similarity index 77%
rename from src/CTree.hpp
rename to src/schema.hpp
index 8b42371..a414dc9 100644
--- a/src/CTree.hpp
+++ b/src/schema.hpp
@@ -14,12 +14,12 @@
 #include <unordered_map>
 #include "ast.hpp"
 
-namespace schema {
-    struct container {
-    };
-    struct list {
-        std::set<std::string> m_keys;
-    };
+namespace yang {
+struct container {
+};
+struct list {
+    std::set<std::string> m_keys;
+};
 }
 
 struct nodeToString : public boost::static_visitor<std::string> {
@@ -34,7 +34,7 @@
     }
 };
 
-using NodeType = boost::variant<schema::container, schema::list>;
+using NodeType = boost::variant<yang::container, yang::list>;
 
 
 class InvalidNodeException : public std::invalid_argument {
@@ -43,15 +43,12 @@
     ~InvalidNodeException() override;
 };
 
-/*! \class CTree
- *     \brief The class representing the tree, that the user traverses.
- *
- *         This class holds the current position in the tree and handles changing the position,
- *         including checking what nodes are available.
+/*! \class Schema
+ *     \brief The class representing the schema, that the user traverses.
  *         */
-class CTree {
+class Schema {
 public:
-    CTree();
+    Schema();
     bool nodeExists(const std::string& location, const std::string& name) const;
 
     bool isContainer(const path_& location, const std::string& name) const;