public static GenericFrame CopyAndPreserveHeirarchy(GenericFrame oval)
        {
            ScopeFrame     SCF = new ScopeFrame();
            StructureFrame SF  = new StructureFrame();
            ArrayFrame     AF  = new ArrayFrame();
            GenericFrame   GF  = new GenericFrame();

            if (GF.GetType() == oval.GetType())
            {
                return(oval);
            }
            else if (AF.GetType() == oval.GetType())
            {
                AF = (ArrayFrame)oval;
                return(AF);
            }
            else if (SF.GetType() == oval.GetType())
            {
                SF = (StructureFrame)oval;
                return(SF);
            }
            else
            {
                SCF = (ScopeFrame)oval;
                return(SCF);
            }
        }
    public bool TryGetGeneric(IDPacket packet, out GenericFrame value)
    {
        ScopeFrame scope;

        FindNameScope(packet, out scope);
        return(scope.Generics.TryGetValue(packet.Name, out value));
    }
        public void Merge(GenericFrame merge)
        {
            //Copy primitives

            if (Primitives.Numbers != null && merge.Primitives.Numbers != null)
            {
                foreach (string key in merge.Primitives.Numbers.Keys)
                {
                    double val;
                    merge.Primitives.Numbers.TryGetValue(key, out val);
                    Primitives.Numbers.Add(key, val);
                }
            }

            if (Primitives.Booleans != null && merge.Primitives.Booleans != null)
            {
                foreach (string key in merge.Primitives.Booleans.Keys)
                {
                    bool val;
                    merge.Primitives.Booleans.TryGetValue(key, out val);
                    Primitives.Booleans.Add(key, val);
                }
            }

            if (Primitives.Text != null && merge.Primitives.Text != null)
            {
                foreach (string key in merge.Primitives.Text.Keys)
                {
                    string val;
                    merge.Primitives.Text.TryGetValue(key, out val);
                    Primitives.Text.Add(key, val);
                }
            }

            //copy structures
            if (Generics != null && merge.Generics != null)
            {
                foreach (string key in merge.Generics.Keys)
                {
                    GenericFrame oval;
                    merge.Generics.TryGetValue(key, out oval);
                    //TODO Preserve the heirarchy

                    GenericFrame cval = GenericFrame.CopyAndPreserveHeirarchy(oval);                     //new GenericFrame (oval);
                    Generics.Add(key, cval);
                }
            }

            //copy functions
            if (Functions != null && merge.Functions != null)
            {
                foreach (string key in merge.Functions.Keys)
                {
                    FunctionFrame oval;
                    merge.Functions.TryGetValue(key, out oval);
                    FunctionFrame cval = new FunctionFrame(oval);
                    Functions.Add(key, cval);
                }
            }
        }
        public static ScopeFrame Appropriate(string name, GenericFrame gframe)
        {
            ScopeFrame scope = new ScopeFrame();

            scope.Type = ScopeFrame.FrameTypes.Structure;
            scope.Name = name;

            scope.Primitives = gframe.Primitives;
            scope.Generics   = gframe.Generics;
            scope.Functions  = gframe.Functions;

            return(scope);
        }
    public void PutGeneric(IDPacket packet, GenericFrame structure)
    {
        ScopeFrame scope;

        FindNameScope(packet, out scope);
        GenericFrame trash;

        if (TryGetGeneric(packet, out trash))
        {
            scope.Generics [packet.Name] = structure;
        }
        else
        {
            scope.Generics.Add(packet.Name, structure);
        }
    }
 public ArrayFrame(GenericFrame original) : base(original)
 {
 }
 public GenericFrame(GenericFrame original)
 {
     Merge(original);
 }
 public bool TryGetParseStructure(string name, out GenericFrame value)
 {
     return(current_scope.Generics.TryGetValue(name, out value));
 }
 public bool TryGetParseStructure(string name, out GenericFrame value)
 {
     return current_scope.Generics.TryGetValue (name, out value);
 }
 public void PutGeneric(IDPacket packet, GenericFrame structure)
 {
     ScopeFrame scope;
     FindNameScope (packet, out scope);
     GenericFrame trash;
     if (TryGetGeneric (packet, out trash))
         scope.Generics [packet.Name] = structure;
     else
         scope.Generics.Add (packet.Name, structure);
 }
 public bool TryGetGeneric(IDPacket packet, out GenericFrame value)
 {
     ScopeFrame scope;
     FindNameScope (packet, out scope);
     return scope.Generics.TryGetValue (packet.Name, out value);
 }
        public static ScopeFrame Appropriate(string name, GenericFrame gframe)
        {
            ScopeFrame scope = new ScopeFrame ();
            scope.Type = ScopeFrame.FrameTypes.Structure;
            scope.Name = name;

            scope.Primitives = gframe.Primitives;
            scope.Generics = gframe.Generics;
            scope.Functions = gframe.Functions;

            return scope;
        }
        public void Merge(GenericFrame merge)
        {
            //Copy primitives

            if (Primitives.Numbers != null && merge.Primitives.Numbers != null) {
                foreach (string key in merge.Primitives.Numbers.Keys) {
                    double val;
                    merge.Primitives.Numbers.TryGetValue (key, out val);
                    Primitives.Numbers.Add (key, val);
                }
            }

            if (Primitives.Booleans != null && merge.Primitives.Booleans != null) {
                foreach (string key in merge.Primitives.Booleans.Keys) {
                    bool val;
                    merge.Primitives.Booleans.TryGetValue (key, out val);
                    Primitives.Booleans.Add (key, val);
                }
            }

            if (Primitives.Text != null && merge.Primitives.Text != null) {
                foreach (string key in merge.Primitives.Text.Keys) {
                    string val;
                    merge.Primitives.Text.TryGetValue (key, out val);
                    Primitives.Text.Add (key, val);
                }
            }

            //copy structures
            if (Generics != null && merge.Generics != null) {
                foreach (string key in merge.Generics.Keys) {
                    GenericFrame oval;
                    merge.Generics.TryGetValue (key, out oval);
                    //TODO Preserve the heirarchy

                    GenericFrame cval = GenericFrame.CopyAndPreserveHeirarchy (oval);//new GenericFrame (oval);
                    Generics.Add (key, cval);
                }
            }

            //copy functions
            if (Functions != null && merge.Functions != null) {
                foreach (string key in merge.Functions.Keys) {
                    FunctionFrame oval;
                    merge.Functions.TryGetValue (key, out oval);
                    FunctionFrame cval = new FunctionFrame (oval);
                    Functions.Add (key, cval);
                }
            }
        }
        public static GenericFrame CopyAndPreserveHeirarchy(GenericFrame oval)
        {
            ScopeFrame SCF = new ScopeFrame ();
            StructureFrame SF = new StructureFrame ();
            ArrayFrame AF = new ArrayFrame ();
            GenericFrame GF = new GenericFrame ();

            if (GF.GetType () == oval.GetType ()) {
                return oval;
            } else if (AF.GetType () == oval.GetType ()) {
                AF = (ArrayFrame)oval;
                return AF;
            } else if (SF.GetType () == oval.GetType ()) {
                SF = (StructureFrame)oval;
                return SF;
            } else {
                SCF = (ScopeFrame)oval;
                return SCF;
            }
        }
 public GenericFrame(GenericFrame original)
 {
     Merge(original);
 }
 public ArrayFrame(GenericFrame original)
     : base(original)
 {
 }