From 04022756e5c4e883035606feafe822951f7e5127 Mon Sep 17 00:00:00 2001
From: Josh Holtrop <jholtrop+git@gmail.com>
Date: Wed, 6 Oct 2010 15:41:47 +0000
Subject: [PATCH] added NodeRef typedef

git-svn-id: svn://anubis/fart/branches/scene-file-scripting@336 7f9b0f55-74a9-4bce-be96-3c2cd072584d
---
 parser/nodes.cc |   4 +-
 parser/nodes.h  | 102 ++++++++++++++++++++++++------------------------
 2 files changed, 54 insertions(+), 52 deletions(-)

diff --git a/parser/nodes.cc b/parser/nodes.cc
index e073c05..f7c55de 100644
--- a/parser/nodes.cc
+++ b/parser/nodes.cc
@@ -8,12 +8,12 @@
 
 using namespace std;
 
-void Node::addChildren(refptr<Node> other)
+void Node::addChildren(NodeRef other)
 {
     if (other.isNull())
         return;
 
-    for (vector< refptr<Node> >::const_iterator it = other->m_children.begin();
+    for (vector<NodeRef>::const_iterator it = other->m_children.begin();
          it != other->m_children.end();
          it++)
     {
diff --git a/parser/nodes.h b/parser/nodes.h
index 4dffee1..b6ee582 100644
--- a/parser/nodes.h
+++ b/parser/nodes.h
@@ -70,6 +70,8 @@ class Node
         std::vector< refptr<Node> > m_children;
 };
 
+typedef refptr<Node> NodeRef;
+
 
 class IntegerNode : public Node
 {
@@ -90,7 +92,7 @@ class NumberNode : public Node
             m_number = number;
             m_direct = true;
         }
-        NumberNode(refptr<Node> expr)
+        NumberNode(NodeRef expr)
         {
             m_expr = expr;
             m_direct = false;
@@ -102,18 +104,18 @@ class NumberNode : public Node
 
     protected:
         double m_number;
-        refptr<Node> m_expr;
+        NodeRef m_expr;
         bool m_direct;
 };
 
 class VectorNode : public Node
 {
     public:
-        VectorNode(refptr<Node> a, refptr<Node> b, refptr<Node> c)
+        VectorNode(NodeRef a, NodeRef b, NodeRef c)
             : m_a(a), m_b(b), m_c(c), m_direct(true)
         {
         }
-        VectorNode(refptr<Node> node)
+        VectorNode(NodeRef node)
             : m_a(node), m_direct(false)
         {
         }
@@ -126,7 +128,7 @@ class VectorNode : public Node
                 : m_a->getVector();
         }
     protected:
-        refptr<Node> m_a, m_b, m_c;
+        NodeRef m_a, m_b, m_c;
         bool m_direct;
 };
 
@@ -134,7 +136,7 @@ class VectorNode : public Node
 class AmbientNode : public VectorNode
 {
     public:
-        AmbientNode(refptr<Node> vector) : VectorNode(vector) {}
+        AmbientNode(NodeRef vector) : VectorNode(vector) {}
 };
 
 class AmbientOcclusionNode : public IntegerNode
@@ -156,7 +158,7 @@ class CameraNode : public Node
 class ColorNode : public VectorNode
 {
     public:
-        ColorNode(refptr<Node> vector) : VectorNode(vector) {}
+        ColorNode(NodeRef vector) : VectorNode(vector) {}
 };
 
 class CylNode : public Node
@@ -168,13 +170,13 @@ class CylNode : public Node
 class DiffuseNode : public VectorNode
 {
     public:
-        DiffuseNode(refptr<Node> vector) : VectorNode(vector) {}
+        DiffuseNode(NodeRef vector) : VectorNode(vector) {}
 };
 
 class ExposureNode : public NumberNode
 {
     public:
-        ExposureNode(refptr<Node> e) : NumberNode(e) {}
+        ExposureNode(NodeRef e) : NumberNode(e) {}
 };
 
 class ExtrudeNode : public Node
@@ -211,7 +213,7 @@ class ItemsNode : public Node
 class JitterNode : public NumberNode
 {
     public:
-        JitterNode(refptr<Node> e) : NumberNode(e) {}
+        JitterNode(NodeRef e) : NumberNode(e) {}
         int getInteger() { return getNumber(); }
 };
 
@@ -222,7 +224,7 @@ class LightNode : public Node
 class LookAtNode : public VectorNode
 {
     public:
-        LookAtNode(refptr<Node> vector) : VectorNode(vector) {}
+        LookAtNode(NodeRef vector) : VectorNode(vector) {}
 };
 
 class MaterialNode : public Node
@@ -259,14 +261,14 @@ class MultisampleNode : public IntegerNode
 class NGonNode : public NumberNode
 {
     public:
-        NGonNode(refptr<Node> e) : NumberNode(e) {}
+        NGonNode(NodeRef e) : NumberNode(e) {}
         int getInteger() { return getNumber(); }
 };
 
 class OffsetNode : public NumberNode
 {
     public:
-        OffsetNode(refptr<Node> e) : NumberNode(e) {}
+        OffsetNode(NodeRef e) : NumberNode(e) {}
 };
 
 class OptionsNode : public Node
@@ -282,7 +284,7 @@ class PlaneNode : public Node
 class PlanePositionNode : public VectorNode
 {
     public:
-        PlanePositionNode(refptr<Node> vec_node, refptr<Node> dist)
+        PlanePositionNode(NodeRef vec_node, NodeRef dist)
             : VectorNode(vec_node)
         {
             m_dist = dist;
@@ -290,7 +292,7 @@ class PlanePositionNode : public VectorNode
         double getNumber() { return m_dist->getNumber(); }
 
     protected:
-        refptr<Node> m_dist;
+        NodeRef m_dist;
 };
 
 class PolygonNode : public Node
@@ -300,25 +302,25 @@ class PolygonNode : public Node
 class PositionNode : public VectorNode
 {
     public:
-        PositionNode(refptr<Node> vector) : VectorNode(vector) {}
+        PositionNode(NodeRef vector) : VectorNode(vector) {}
 };
 
 class RadiusNode : public NumberNode
 {
     public:
-        RadiusNode(refptr<Node> e) : NumberNode(e) {}
+        RadiusNode(NodeRef e) : NumberNode(e) {}
 };
 
 class ReflectanceNode : public NumberNode
 {
     public:
-        ReflectanceNode(refptr<Node> e) : NumberNode(e) {}
+        ReflectanceNode(NodeRef e) : NumberNode(e) {}
 };
 
 class RotateNode : public VectorNode
 {
     public:
-        RotateNode(refptr<Node> angle, refptr<Node> vec_node)
+        RotateNode(NodeRef angle, NodeRef vec_node)
             : VectorNode(vec_node)
         {
             m_angle = angle;
@@ -326,13 +328,13 @@ class RotateNode : public VectorNode
         double getNumber() { return m_angle->getNumber(); }
 
     protected:
-        refptr<Node> m_angle;
+        NodeRef m_angle;
 };
 
 class RotateBlockNode : public RotateNode
 {
     public:
-        RotateBlockNode(refptr<Node> angle, refptr<Node> vec_node)
+        RotateBlockNode(NodeRef angle, NodeRef vec_node)
             : RotateNode(angle, vec_node) {}
         bool isTransformBlock() { return true; }
 };
@@ -340,20 +342,20 @@ class RotateBlockNode : public RotateNode
 class ScaleNode : public VectorNode
 {
     public:
-        ScaleNode(refptr<Node> vector) : VectorNode(vector) {}
+        ScaleNode(NodeRef vector) : VectorNode(vector) {}
 };
 
 class ScaleBlockNode : public ScaleNode
 {
     public:
-        ScaleBlockNode(refptr<Node> vector) : ScaleNode(vector) {}
+        ScaleBlockNode(NodeRef vector) : ScaleNode(vector) {}
         bool isTransformBlock() { return true; }
 };
 
 class ScaleScalarNode : public Node
 {
     public:
-        ScaleScalarNode(refptr<Node> expr)
+        ScaleScalarNode(NodeRef expr)
             : m_expr(expr)
         {
         }
@@ -363,7 +365,7 @@ class ScaleScalarNode : public Node
             return new Vector(x, x, x);
         }
     protected:
-        refptr<Node> m_expr;
+        NodeRef m_expr;
 };
 
 class SceneNode : public Node
@@ -386,19 +388,19 @@ class ShapeRefNode : public IdentifierNode
 class ShininessNode : public NumberNode
 {
     public:
-        ShininessNode(refptr<Node> e) : NumberNode(e) {}
+        ShininessNode(NodeRef e) : NumberNode(e) {}
 };
 
 class SizeNode : public VectorNode
 {
     public:
-        SizeNode(refptr<Node> vector) : VectorNode(vector) {}
+        SizeNode(NodeRef vector) : VectorNode(vector) {}
 };
 
 class SpecularNode : public VectorNode
 {
     public:
-        SpecularNode(refptr<Node> vector) : VectorNode(vector) {}
+        SpecularNode(NodeRef vector) : VectorNode(vector) {}
 };
 
 class SphereNode : public Node
@@ -416,20 +418,20 @@ class SubtractNode : public Node
 class TranslateNode : public VectorNode
 {
     public:
-        TranslateNode(refptr<Node> vector) : VectorNode(vector) {}
+        TranslateNode(NodeRef vector) : VectorNode(vector) {}
 };
 
 class TranslateBlockNode : public TranslateNode
 {
     public:
-        TranslateBlockNode(refptr<Node> vector) : TranslateNode(vector) {}
+        TranslateBlockNode(NodeRef vector) : TranslateNode(vector) {}
         bool isTransformBlock() { return true; }
 };
 
 class TransparencyNode : public NumberNode
 {
     public:
-        TransparencyNode(refptr<Node> e) : NumberNode(e) {}
+        TransparencyNode(NodeRef e) : NumberNode(e) {}
 };
 
 class UnionNode : public Node
@@ -441,13 +443,13 @@ class UnionNode : public Node
 class UpNode : public VectorNode
 {
     public:
-        UpNode(refptr<Node> vector) : VectorNode(vector) {}
+        UpNode(NodeRef vector) : VectorNode(vector) {}
 };
 
 class VFOVNode : public NumberNode
 {
     public:
-        VFOVNode(refptr<Node> e) : NumberNode(e) {}
+        VFOVNode(NodeRef e) : NumberNode(e) {}
 };
 
 class WidthNode : public IntegerNode
@@ -469,7 +471,7 @@ class ExpressionNode : public Node
 class AssignmentNode : public ExpressionNode
 {
     public:
-        AssignmentNode(refptr<Node> varref, refptr<Node> expr)
+        AssignmentNode(NodeRef varref, NodeRef expr)
             : m_varref(varref), m_expr(expr)
         {
         }
@@ -481,14 +483,14 @@ class AssignmentNode : public ExpressionNode
             return n;
         }
     protected:
-        refptr<Node> m_varref;
-        refptr<Node> m_expr;
+        NodeRef m_varref;
+        NodeRef m_expr;
 };
 
 class LocalAssignmentNode : public ExpressionNode
 {
     public:
-        LocalAssignmentNode(refptr<Node> varref, refptr<Node> expr)
+        LocalAssignmentNode(NodeRef varref, NodeRef expr)
             : m_varref(varref), m_expr(expr)
         {
         }
@@ -500,49 +502,49 @@ class LocalAssignmentNode : public ExpressionNode
             return n;
         }
     protected:
-        refptr<Node> m_varref;
-        refptr<Node> m_expr;
+        NodeRef m_varref;
+        NodeRef m_expr;
 };
 
 class LocalDeclNode : public ExpressionNode
 {
     public:
-        LocalDeclNode(refptr<Node> varref) : m_varref(varref) { }
+        LocalDeclNode(NodeRef varref) : m_varref(varref) { }
         double getNumber()
         {
             parser_scope->putLocal(m_varref->getString(), 0.0);
             return 0.0;
         }
     protected:
-        refptr<Node> m_varref;
+        NodeRef m_varref;
 };
 
 class BinOpNode : public ExpressionNode
 {
     public:
-        BinOpNode(char op, refptr<Node> one, refptr<Node> two)
+        BinOpNode(char op, NodeRef one, NodeRef two)
             : m_op(op), one(one), two(two)
         {
         }
         virtual double getNumber();
     protected:
         char m_op;
-        refptr<Node> one;
-        refptr<Node> two;
+        NodeRef one;
+        NodeRef two;
 };
 
 class BoolExpressionNode : public Node
 {
     public:
-        BoolExpressionNode(char op, refptr<Node> one, refptr<Node> two)
+        BoolExpressionNode(char op, NodeRef one, NodeRef two)
             : m_op(op), one(one), two(two)
         {
         }
         int getInteger();
     protected:
         char m_op;
-        refptr<Node> one;
-        refptr<Node> two;
+        NodeRef one;
+        NodeRef two;
 };
 
 class VarRefNode : public Node
@@ -567,13 +569,13 @@ class VarRefNode : public Node
 class ForNode : public Node
 {
     public:
-        ForNode(refptr<Node> e1, refptr<Node> e2, refptr<Node> e3)
+        ForNode(NodeRef e1, NodeRef e2, NodeRef e3)
         {
             m_nodes[0] = e1;
             m_nodes[1] = e2;
             m_nodes[2] = e3;
         }
-        refptr<Node> getNode(int idx)
+        NodeRef getNode(int idx)
         {
             if (0 <= idx && idx <= 2)
             {
@@ -582,7 +584,7 @@ class ForNode : public Node
             return NULL;
         }
     protected:
-        refptr<Node> m_nodes[3];
+        NodeRef m_nodes[3];
 };
 
 #endif