diff --git a/Algorithms/StronglyConnectedComponents.h b/Algorithms/StronglyConnectedComponents.h
index 30c830ff6..9a5a65626 100644
--- a/Algorithms/StronglyConnectedComponents.h
+++ b/Algorithms/StronglyConnectedComponents.h
@@ -152,52 +152,48 @@ class TarjanSCC
         DeallocatingVector<TarjanEdge> edge_list;
         for (const NodeBasedEdge &input_edge : input_edges)
         {
-            if (input_edge.source() == input_edge.target())
+            if (input_edge.source == input_edge.target)
             {
                 continue;
             }
 
             TarjanEdge edge;
-            if (input_edge.isForward())
+            if (input_edge.forward)
             {
-                edge.source = input_edge.source();
-                edge.target = input_edge.target();
-                edge.data.forward = input_edge.isForward();
-                edge.data.backward = input_edge.isBackward();
+                edge.source = input_edge.source;
+                edge.target = input_edge.target;
+                edge.data.forward = input_edge.forward;
+                edge.data.backward = input_edge.backward;
             }
             else
             {
-                edge.source = input_edge.target();
-                edge.target = input_edge.source();
-                edge.data.backward = input_edge.isForward();
-                edge.data.forward = input_edge.isBackward();
+                edge.source = input_edge.target;
+                edge.target = input_edge.source;
+                edge.data.backward = input_edge.forward;
+                edge.data.forward = input_edge.backward;
             }
 
-            edge.data.distance = (std::max)((int)input_edge.weight(), 1);
+            edge.data.distance = (std::max)((int)input_edge.weight, 1);
             BOOST_ASSERT(edge.data.distance > 0);
             edge.data.shortcut = false;
-            // edge.data.roundabout = input_edge.isRoundabout();
-            // edge.data.ignoreInGrid = input_edge.ignoreInGrid();
-            edge.data.name_id = input_edge.name();
-            edge.data.type = input_edge.type();
-            // edge.data.isAccessRestricted = input_edge.isAccessRestricted();
+            edge.data.name_id = input_edge.name;
+            edge.data.type = input_edge.type;
             edge.data.reversedEdge = false;
             edge_list.push_back(edge);
             if (edge.data.backward)
             {
                 std::swap(edge.source, edge.target);
-                edge.data.forward = input_edge.isBackward();
-                edge.data.backward = input_edge.isForward();
+                edge.data.forward = input_edge.backward;
+                edge.data.backward = input_edge.forward;
                 edge.data.reversedEdge = true;
                 edge_list.push_back(edge);
             }
         }
-        std::vector<NodeBasedEdge>().swap(input_edges);
+        input_edges.shrink_to_fit();
         BOOST_ASSERT_MSG(0 == input_edges.size() && 0 == input_edges.capacity(),
                          "input edge vector not properly deallocated");
 
         std::sort(edge_list.begin(), edge_list.end());
-
         m_node_based_graph = std::make_shared<TarjanDynamicGraph>(number_of_nodes, edge_list);
     }
 
diff --git a/DataStructures/ImportEdge.cpp b/DataStructures/ImportEdge.cpp
index dbc584a01..301564243 100644
--- a/DataStructures/ImportEdge.cpp
+++ b/DataStructures/ImportEdge.cpp
@@ -29,19 +29,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 bool NodeBasedEdge::operator<(const NodeBasedEdge &e) const
 {
-    if (source() == e.source())
+    if (source == e.source)
     {
-        if (target() == e.target())
+        if (target == e.target)
         {
-            if (weight() == e.weight())
+            if (weight == e.weight)
             {
-                return (isForward() && isBackward() && ((!e.isForward()) || (!e.isBackward())));
+                return (forward && backward && ((!e.forward) || (!e.backward)));
             }
-            return (weight() < e.weight());
+            return (weight < e.weight);
         }
-        return (target() < e.target());
+        return (target < e.target);
     }
-    return (source() < e.source());
+    return (source < e.source);
 }
 
     NodeBasedEdge::NodeBasedEdge(NodeID s,
@@ -56,8 +56,8 @@ bool NodeBasedEdge::operator<(const NodeBasedEdge &e) const
                            bool ar,
                            bool cf,
                            bool is_split)
-        : _source(s), _target(t), _name(n), _weight(w), _type(ty), forward(f), backward(b),
-          _roundabout(ra), _ignoreInGrid(ig), _accessRestricted(ar), _contraFlow(cf),
+        : source(s), target(t), name(n), weight(w), type(ty), forward(f), backward(b),
+          roundabout(ra), ignoreInGrid(ig), accessRestricted(ar), contraFlow(cf),
           is_split(is_split)
     {
         if (ty < 0)
@@ -66,24 +66,6 @@ bool NodeBasedEdge::operator<(const NodeBasedEdge &e) const
         }
     }
 
-    NodeID NodeBasedEdge::target() const { return _target; }
-    NodeID NodeBasedEdge::source() const { return _source; }
-    NodeID NodeBasedEdge::name() const { return _name; }
-    EdgeWeight NodeBasedEdge::weight() const { return _weight; }
-    short NodeBasedEdge::type() const
-    {
-        BOOST_ASSERT_MSG(_type >= 0, "type of ImportEdge invalid");
-        return _type;
-    }
-    bool NodeBasedEdge::isBackward() const { return backward; }
-    bool NodeBasedEdge::isForward() const { return forward; }
-    bool NodeBasedEdge::isLocatable() const { return _type != 14; }
-    bool NodeBasedEdge::isRoundabout() const { return _roundabout; }
-    bool NodeBasedEdge::ignoreInGrid() const { return _ignoreInGrid; }
-    bool NodeBasedEdge::isAccessRestricted() const { return _accessRestricted; }
-    bool NodeBasedEdge::isContraFlow() const { return _contraFlow; }
-    bool NodeBasedEdge::IsSplit() const { return is_split; }
-
     bool EdgeBasedEdge::operator<(const EdgeBasedEdge &e) const
     {
         if (source() == e.source())
diff --git a/DataStructures/ImportEdge.h b/DataStructures/ImportEdge.h
index 066e423e3..f4759f2ef 100644
--- a/DataStructures/ImportEdge.h
+++ b/DataStructures/ImportEdge.h
@@ -52,32 +52,17 @@ class NodeBasedEdge
                            bool cf,
                            bool is_split);
 
-    NodeID target() const;
-    NodeID source() const;
-    NodeID name() const;
-    EdgeWeight weight() const;
-    short type() const;
-    bool isBackward() const;
-    bool isForward() const;
-    bool isLocatable() const;
-    bool isRoundabout() const;
-    bool ignoreInGrid() const;
-    bool isAccessRestricted() const;
-    bool isContraFlow() const;
-    bool IsSplit() const;
-
-    // TODO: names need to be fixed.
-    NodeID _source;
-    NodeID _target;
-    NodeID _name;
-    EdgeWeight _weight;
-    short _type;
+    NodeID source;
+    NodeID target;
+    NodeID name;
+    EdgeWeight weight;
+    short type;
     bool forward : 1;
     bool backward : 1;
-    bool _roundabout : 1;
-    bool _ignoreInGrid : 1;
-    bool _accessRestricted : 1;
-    bool _contraFlow : 1;
+    bool roundabout : 1;
+    bool ignoreInGrid : 1;
+    bool accessRestricted : 1;
+    bool contraFlow : 1;
     bool is_split : 1;
 
     NodeBasedEdge() = delete;
diff --git a/DataStructures/NodeBasedGraph.h b/DataStructures/NodeBasedGraph.h
index 9f2d63086..9b015a009 100644
--- a/DataStructures/NodeBasedGraph.h
+++ b/DataStructures/NodeBasedGraph.h
@@ -60,19 +60,19 @@ NodeBasedDynamicGraphFromImportEdges(int number_of_nodes, std::vector<ImportEdge
     for (const ImportEdge &import_edge : input_edge_list)
     {
         // TODO: give ImportEdge a proper c'tor to use emplace_back's below
-        if (!import_edge.isForward())
+        if (!import_edge.forward)
         {
-            edge.source = import_edge.target();
-            edge.target = import_edge.source();
-            edge.data.backward = import_edge.isForward();
-            edge.data.forward = import_edge.isBackward();
+            edge.source = import_edge.target;
+            edge.target = import_edge.source;
+            edge.data.backward = import_edge.forward;
+            edge.data.forward = import_edge.backward;
         }
         else
         {
-            edge.source = import_edge.source();
-            edge.target = import_edge.target();
-            edge.data.forward = import_edge.isForward();
-            edge.data.backward = import_edge.isBackward();
+            edge.source = import_edge.source;
+            edge.target = import_edge.target;
+            edge.data.forward = import_edge.forward;
+            edge.data.backward = import_edge.backward;
         }
 
         if (edge.source == edge.target)
@@ -80,18 +80,18 @@ NodeBasedDynamicGraphFromImportEdges(int number_of_nodes, std::vector<ImportEdge
             continue;
         }
 
-        edge.data.distance = (std::max)((int)import_edge.weight(), 1);
+        edge.data.distance = (std::max)((int)import_edge.weight, 1);
         BOOST_ASSERT(edge.data.distance > 0);
         edge.data.shortcut = false;
-        edge.data.roundabout = import_edge.isRoundabout();
-        edge.data.ignore_in_grid = import_edge.ignoreInGrid();
-        edge.data.nameID = import_edge.name();
-        edge.data.type = import_edge.type();
-        edge.data.isAccessRestricted = import_edge.isAccessRestricted();
-        edge.data.contraFlow = import_edge.isContraFlow();
+        edge.data.roundabout = import_edge.roundabout;
+        edge.data.ignore_in_grid = import_edge.ignoreInGrid;
+        edge.data.nameID = import_edge.name;
+        edge.data.type = import_edge.type;
+        edge.data.isAccessRestricted = import_edge.accessRestricted;
+        edge.data.contraFlow = import_edge.contraFlow;
         edges_list.push_back(edge);
 
-        if (!import_edge.IsSplit())
+        if (!import_edge.is_split)
         {
             using std::swap; // enable ADL
             swap(edge.source, edge.target);
diff --git a/Util/GraphLoader.h b/Util/GraphLoader.h
index 0aecf8e23..f0faa2ea4 100644
--- a/Util/GraphLoader.h
+++ b/Util/GraphLoader.h
@@ -207,52 +207,52 @@ NodeID readBinaryOSRMGraphFromStream(std::istream &input_stream,
     tbb::parallel_sort(edge_list.begin(), edge_list.end());
     for (unsigned i = 1; i < edge_list.size(); ++i)
     {
-        if ((edge_list[i - 1].target() == edge_list[i].target()) &&
-            (edge_list[i - 1].source() == edge_list[i].source()))
+        if ((edge_list[i - 1].target == edge_list[i].target) &&
+            (edge_list[i - 1].source == edge_list[i].source))
         {
             const bool edge_flags_equivalent =
-                (edge_list[i - 1].isForward() == edge_list[i].isForward()) &&
-                (edge_list[i - 1].isBackward() == edge_list[i].isBackward());
+                (edge_list[i - 1].forward == edge_list[i].forward) &&
+                (edge_list[i - 1].backward == edge_list[i].backward);
             const bool edge_flags_are_superset1 =
-                (edge_list[i - 1].isForward() && edge_list[i - 1].isBackward()) &&
-                (edge_list[i].isBackward() != edge_list[i].isBackward());
+                (edge_list[i - 1].forward && edge_list[i - 1].backward) &&
+                (edge_list[i].backward != edge_list[i].backward);
             const bool edge_flags_are_superset_2 =
-                (edge_list[i].isForward() && edge_list[i].isBackward()) &&
-                (edge_list[i - 1].isBackward() != edge_list[i - 1].isBackward());
+                (edge_list[i].forward && edge_list[i].backward) &&
+                (edge_list[i - 1].backward != edge_list[i - 1].backward);
 
             if (edge_flags_equivalent)
             {
-                edge_list[i]._weight = std::min(edge_list[i - 1].weight(), edge_list[i].weight());
-                edge_list[i - 1]._source = UINT_MAX;
+                edge_list[i].weight = std::min(edge_list[i - 1].weight, edge_list[i].weight);
+                edge_list[i - 1].source = UINT_MAX;
             }
             else if (edge_flags_are_superset1)
             {
-                if (edge_list[i - 1].weight() <= edge_list[i].weight())
+                if (edge_list[i - 1].weight <= edge_list[i].weight)
                 {
                     // edge i-1 is smaller and goes in both directions. Throw away the other edge
-                    edge_list[i]._source = UINT_MAX;
+                    edge_list[i].source = UINT_MAX;
                 }
                 else
                 {
                     // edge i-1 is open in both directions, but edge i is smaller in one direction.
                     // Close edge i-1 in this direction
-                    edge_list[i - 1].forward = !edge_list[i].isForward();
-                    edge_list[i - 1].backward = !edge_list[i].isBackward();
+                    edge_list[i - 1].forward = !edge_list[i].forward;
+                    edge_list[i - 1].backward = !edge_list[i].backward;
                 }
             }
             else if (edge_flags_are_superset_2)
             {
-                if (edge_list[i - 1].weight() <= edge_list[i].weight())
+                if (edge_list[i - 1].weight <= edge_list[i].weight)
                 {
                     // edge i-1 is smaller for one direction. edge i is open in both. close edge i
                     // in the other direction
-                    edge_list[i].forward = !edge_list[i - 1].isForward();
-                    edge_list[i].backward = !edge_list[i - 1].isBackward();
+                    edge_list[i].forward = !edge_list[i - 1].forward;
+                    edge_list[i].backward = !edge_list[i - 1].backward;
                 }
                 else
                 {
                     // edge i is smaller and goes in both direction. Throw away edge i-1
-                    edge_list[i - 1]._source = UINT_MAX;
+                    edge_list[i - 1].source = UINT_MAX;
                 }
             }
         }
@@ -260,7 +260,7 @@ NodeID readBinaryOSRMGraphFromStream(std::istream &input_stream,
     const auto new_end_iter = std::remove_if(edge_list.begin(),
                                        edge_list.end(),
                                        [](const EdgeT &edge)
-                                       { return edge.source() == UINT_MAX; });
+                                       { return edge.source == SPECIAL_NODEID; });
     ext_to_int_id_map.clear();
     edge_list.erase(new_end_iter, edge_list.end()); // remove excess candidates.
     edge_list.shrink_to_fit();