diff --git a/ApplicationCore.cpp b/ApplicationCore.cpp
index 56a3d65..964878c 100644
--- a/ApplicationCore.cpp
+++ b/ApplicationCore.cpp
@@ -39,7 +39,7 @@ CApplication::CApplication( EDebugLevel pLogLevel )
     LogOutput   = OUT_NORMAL;
 
     // Create Configuration
-    DataTree        = new CDataTree();
+    DataTree        = new CDataMember();
     JSONparser      = new CJSONparse( DataTree );
 
     // Selector
@@ -145,14 +145,14 @@ bool  CApplication::SaveConfig()
 
 bool  CApplication::LoadConfigData()
 {
-    TDataMember     * TempMember;
+    CDataMember     * TempMember;
     EDebugLevel     pLogLevel;
     int             pLogOutput;
     char            * TempStr;
 
     // Get debug level
     pLogLevel = dlNone;
-    TempStr = (char*)DataTree->GetStr( ConfigMember, "Log/Level", "Medium", true );
+    TempStr = (char*)ConfigMember->GetChildStr( "Log/Level", "Medium", true );
     if (TempStr)
     {
         if (!strcasecmp( TempStr, "Low" ))
@@ -165,32 +165,35 @@ bool  CApplication::LoadConfigData()
 
     // Set debug output
     pLogOutput = 0;
-    TempMember = DataTree->GetFirstChild( ConfigMember, "Log/Output", true );
-    while (TempMember)
+    if ((TempMember = ConfigMember->GetMember( "Log/Output", true )))
     {
-        if (TempMember->Value)
+        TempMember = TempMember->GetFirstChild();
+        while (TempMember)
         {
-            if (!strcasecmp( TempMember->Value, "Normal"))
-                pLogOutput |= OUT_NORMAL;
-            else if (!strcasecmp( TempMember->Value, "Bin"))
-                pLogOutput |= OUT_BIN;
-            else if (!strcasecmp( TempMember->Value, "Hex"))
-                pLogOutput |= OUT_HEX;
-            else if (!strcasecmp( TempMember->Value, "Count"))
-                pLogOutput |= OUT_COUNT;
-            else if (!strcasecmp( TempMember->Value, "AsIs"))
-                pLogOutput |= OUT_ASIS;
-            else if (!strcasecmp( TempMember->Value, "CRLF"))
-                pLogOutput |= OUT_CRLF;
-        }
+            if ((TempStr = (char*)TempMember->GetStr()))
+            {
+                if (!strcasecmp( TempStr, "Normal"))
+                    pLogOutput |= OUT_NORMAL;
+                else if (!strcasecmp( TempStr, "Bin"))
+                    pLogOutput |= OUT_BIN;
+                else if (!strcasecmp( TempStr, "Hex"))
+                    pLogOutput |= OUT_HEX;
+                else if (!strcasecmp( TempStr, "Count"))
+                    pLogOutput |= OUT_COUNT;
+                else if (!strcasecmp( TempStr, "AsIs"))
+                    pLogOutput |= OUT_ASIS;
+                else if (!strcasecmp( TempStr, "CRLF"))
+                    pLogOutput |= OUT_CRLF;
+            }
 
-        // Next
-        TempMember = DataTree->GetNextChild( TempMember );
+            // Next
+            TempMember = TempMember->GetNextPeer();
+        }
     }
     SetLogParam( pLogLevel, pLogOutput );
 
     // Load Address List
-    if ((AddressFile = (char*)DataTree->GetStr( ConfigMember, "AddressList/Path", NULL )))
+    if ((AddressFile = (char*)ConfigMember->GetChildStr( "AddressList/Path", NULL )))
     {
         if (JSONparser->ReadFromFile( "address", AddressFile )) {
             if (Log) Log->Message( dlLow, dlLow, "%s: Address file loaded (%s)", ProcessName, AddressFile );
@@ -201,10 +204,10 @@ bool  CApplication::LoadConfigData()
     }
 
     // Configure Selector
-    if ((TempMember = DataTree->GetMember( ConfigMember, "Selector" )))
+    if ((TempMember = ConfigMember->GetMember( "Selector" )))
     {
         // Create Selector
-        Selector = new CSelect( (int)DataTree->GetInt( TempMember, "Wait", 5, true ), LogLevel );
+        Selector = new CSelect( (int)TempMember->GetChildInt( "Wait", 5, true ), LogLevel );
     }
     return true;
 }
@@ -232,7 +235,7 @@ bool  CApplication::Init()
 bool  CApplication::InitConfig( const char * pConfigPath )
 {
     // Check if Datatree exists
-    if (!DataTree || !(ConfigMember = DataTree->GetMember( NULL, pConfigPath ))) {
+    if (!DataTree || !(ConfigMember = DataTree->GetMember( pConfigPath ))) {
         return false;
     }
 
@@ -247,32 +250,32 @@ bool  CApplication::InitConfig( const char * pConfigPath )
 bool  CApplication::InitFunctions( const char * pConfigPath )
 {
     CFunctionCore   * Function;
-    TDataMember     * TempMember;
+    CDataMember     * TempMember;
     char            * Type;
 
     // Check of path exists
-    if (!DataTree || !(FunctionConfigMember = DataTree->GetMember( NULL, pConfigPath )))
+    if (!DataTree || !(FunctionConfigMember = DataTree->GetMember( pConfigPath )))
         return false;
 
     // Process each Channel
-    TempMember = DataTree->GetFirstChild( FunctionConfigMember );
+    TempMember = FunctionConfigMember->GetFirstChild();
     while (TempMember)
     {
         // Get function parameters
-        Type = (char*)DataTree->GetStr( TempMember, "Type", "Custom", true );
+        Type = (char*)TempMember->GetChildStr( "Type", "Custom", true );
 
         // Get or create function
         if (!strcasecmp( Type, "WatchdogClient" )) {
-            Function = new CWatchdogCore( TempMember->Name );
+            Function = new CWatchdogCore( TempMember->GetName() );
         }
         else if (!strcasecmp( Type, "Selectable" )) {
-            Function = new CSelectableCore( TempMember->Name );
+            Function = new CSelectableCore( TempMember->GetName() );
         }
         else if (!strcasecmp( Type, "File" )) {
-            Function = new CFileCore( TempMember->Name );
+            Function = new CFileCore( TempMember->GetName() );
         }
         else {
-            Function = GetFunction( TempMember->Name );
+            Function = GetFunction( TempMember->GetName() );
         }
 
         // Load Function configuration and Initialise
@@ -281,7 +284,7 @@ bool  CApplication::InitFunctions( const char * pConfigPath )
         }
 
         // Next
-        TempMember = TempMember->Next;
+        TempMember = TempMember->GetNextPeer();
     }
 
     return true;
@@ -291,10 +294,10 @@ bool  CApplication::InitFunctions( const char * pConfigPath )
 bool  CApplication::InitFunctionLinks( const char * pConfigPath )
 {
     TFunctionItem   * FunctionItem;
-    TDataMember     * TempMember;
+    CDataMember     * TempMember;
 
     // Check of path exists
-    if (!DataTree || !(LinkConfigMember = DataTree->GetMember( NULL, pConfigPath )))
+    if (!DataTree || !(LinkConfigMember = DataTree->GetMember( pConfigPath )))
         return false;
 
     // Process each Channel
@@ -302,7 +305,7 @@ bool  CApplication::InitFunctionLinks( const char * pConfigPath )
     while (FunctionItem)
     {
         // Build links for function
-        if ((TempMember = DataTree->GetMember( LinkConfigMember, FunctionItem->Function->GetName() )))
+        if ((TempMember = LinkConfigMember->GetMember( FunctionItem->Function->GetName() )))
             FunctionItem->Function->InitChannelLinks( TempMember );
 
         // Next
diff --git a/ApplicationCore.h b/ApplicationCore.h
index cc5c389..561ba0e 100644
--- a/ApplicationCore.h
+++ b/ApplicationCore.h
@@ -52,15 +52,15 @@ protected:
     int             LogOutput;
 
     // Configuration
-    TDataMember     * ConfigMember;
-    TDataMember     * FunctionConfigMember;
-    TDataMember     * LinkConfigMember;
+    CDataMember     * ConfigMember;
+    CDataMember     * FunctionConfigMember;
+    CDataMember     * LinkConfigMember;
 
     bool  LoadConfigData();
 
 public:
     // Public function vars
-    CDataTree       * DataTree;
+    CDataMember     * DataTree;
     CLogCore        * Log;
     CSelect         * Selector;
     CJSONparse      * JSONparser  = NULL;
diff --git a/DataTreeCore.cpp b/DataTreeCore.cpp
index beb5fa1..3c52474 100644
--- a/DataTreeCore.cpp
+++ b/DataTreeCore.cpp
@@ -14,111 +14,126 @@
 
 //---------------------------------------------------------------------------
 
-CDataTree::CDataTree()
+CDataMember::CDataMember( const char * pName, const int pLen )
 {
-    // Create Root member of tree
-    RootMember = CreateMember( NULL, NULL, NULL );
-    RootMember->Type = jtObject;
-}
-//---------------------------------------------------------------------------
-
-CDataTree::~CDataTree()
-{
-    // Destroy Members
-    DeleteAll();
-    DestroyMember( &RootMember );
-}
-//---------------------------------------------------------------------------
-
-TDataMember *  CDataTree::CreateMember( TDataMember * Parent, TDataMember * PrevChild, const char * Name, const int Len )
-{
-    TDataMember    * Member;
-
-    // Create data structure
-    Member  = (TDataMember *)calloc( 1, sizeof(TDataMember) );
-
-    // Set name
-    if (Name)
-    {
-        Member->NameLen  = (Len == -1)? strlen( Name ) : Len ;
-        Member->Name = (char *)malloc( Member->NameLen+1 );
-        memcpy( Member->Name, Name, Member->NameLen );
-        Member->Name[ Member->NameLen ] = 0;
+    if (Name) {
+        NameLen  = (pLen == -1)? strlen( pName ) : pLen ;
+        Name = (char *)malloc( NameLen+1 );
+        memcpy( Name, pName, NameLen );
+        Name[ NameLen ] = 0;
     }
 
-    // Update Parent
-    if (Parent) {
-        Member->Parent = Parent;
+    Type        = jtNull;
+
+    Value       = NULL;
+    Len         = 0;
+
+    FirstChild  = NULL;
+    LastChild   = NULL;
+
+    Parent      = NULL;
+    PrevPeer        = NULL;
+    NextPeer        = NULL;
+}
+//---------------------------------------------------------------------------
+
+CDataMember::CDataMember( CDataMember * pParent, const char * pName, const int pLen )
+{
+    if (pName) {
+        NameLen  = (pLen == -1)? strlen( pName ) : pLen ;
+        Name = (char *)malloc( NameLen+1 );
+        memcpy( Name, pName, NameLen );
+        Name[ NameLen ] = 0;
+    }
+
+    Type        = jtNull;
+
+    Value       = NULL;
+    Len         = 0;
+
+    FirstChild  = NULL;
+    LastChild   = NULL;
+
+    if (!pParent) {
+        Parent  = NULL;
+        PrevPeer    = NULL;
+        NextPeer    = NULL;
+    }
+    else {
+        // Clear/reset parent if not object
+        Parent = pParent;
+        if ((Parent->Type != jtNull) && (Parent->Type != jtObject) && (Parent->Type != jtArray)) {
+            Parent->Clear();
+        }
+
+        // Insert into Parent & Peer lists
         Parent->Len++;
+        if (!Parent->FirstChild) {
+            Parent->FirstChild = this;
+            Parent->LastChild = this;
+        }
+        else {
+            PrevPeer = Parent->LastChild;
+            Parent->LastChild->NextPeer = this;
+            Parent->LastChild = this;
+        }
     }
-
-    // Set Sibling links
-    Member->Prev   = PrevChild;
-    Member->Next   = NULL;
-
-    return Member;
 }
 //---------------------------------------------------------------------------
 
-bool  CDataTree::DestroyMember( TDataMember ** Member )
+CDataMember::~CDataMember()
 {
-    TDataMember    * NextMember;
-
-    // Validate
-    if (!Member || !*Member)
-        return false;
-
-    // Get next param in list
-    NextMember = (*Member)->Next;
-
-    // Update Parent
-    if ((*Member)->Parent)
-        (*Member)->Parent->Len--;
-
-    // Destroy
-    if ((*Member)->Name)
-        free( (*Member)->Name );
-    if ((*Member)->Value)
-        free( (*Member)->Value );
-    while ((*Member)->FirstChild) {
-        DestroyMember( &((*Member)->FirstChild) );
+    // Remove from parent
+    if (Parent)
+        Parent->Len--;
+    if (this == Parent->LastChild) {
+        Parent->LastChild = PrevPeer;
     }
+    PrevPeer->NextPeer = NextPeer;
+    NextPeer->PrevPeer = PrevPeer;
 
-    free( *Member );
+    // Destroy value/children
+    Clear();
 
-    // Restore list integrity
-    *Member = NextMember;
+    // Destroy member
+    if (Name)
+        free( Name );
+    if (Value)
+        free( Value );
+}
+//---------------------------------------------------------------------------
+
+CDataMember *  CDataMember::CreateChild( const char * Name, const int Len )
+{
+   CDataMember  * Member;
+   Member = new CDataMember( this, Name, Len );
+   return Member;
+}
+//---------------------------------------------------------------------------
+
+bool  CDataMember::Clear()
+{
+    if (Value) {
+        free( Value );
+        Value = NULL;
+    }
+    while (FirstChild) {
+        delete FirstChild;
+//        FirstChild = NULL;
+//        LastChild  = NULL;
+//        Len = 0;
+    }
+    Type = jtNull;
 
     return true;
 }
 //---------------------------------------------------------------------------
 
-bool  CDataTree::DestroyValue( TDataMember * Member )
+CDataMember *  CDataMember::GetMember( const char * Path, bool Create )
 {
-    // Validate
-    if (!Member)
-        return false;
-
-    // Destroy values
-    if (Member->Value) {
-        free( Member->Value );
-        Member->Value = NULL;
-    }
-
-    // Destroy Children
-    while (Member->FirstChild) {
-        DestroyMember( &(Member->FirstChild) );
-    }
-
-    return true;
-}
-//---------------------------------------------------------------------------
-
-TDataMember **  CDataTree::GetMemberPtr( TDataMember * BaseMember, const char * Path, bool Create, TDataMember ** Parent )
-{
-    TDataMember     * Member;
-    TDataMember     ** Child;
-    TDataMember     * PrevChild;
+    CDataMember     * Member;
+    CDataMember     ** Child;
+    CDataMember     * PrevChild;
     char            * Pos;
     char            * EndPos;
     char            * Key;
@@ -129,14 +144,12 @@ TDataMember **  CDataTree::GetMemberPtr( TDataMember * BaseMember, const char *
 
     // Validate
     if (!Path || !*Path) {
-        if (Parent)  *Parent = NULL;
-        return NULL;
+        return this;
     }
 
     // Set init references
-    if (Parent)  *Parent = NULL;
     Child   = NULL;
-    Member  = (BaseMember)? BaseMember : RootMember;
+    Member  = this;
 
     // Split path
     Pos = (char*)Path;
@@ -182,7 +195,7 @@ TDataMember **  CDataTree::GetMemberPtr( TDataMember * BaseMember, const char *
                 Child = &(Member->FirstChild);
                 while (*Child) {
                     PrevChild = *Child;
-                    Child = &((*Child)->Next);
+                    Child = &((*Child)->NextPeer);
                 }
             }
             else {
@@ -197,7 +210,7 @@ TDataMember **  CDataTree::GetMemberPtr( TDataMember * BaseMember, const char *
                 Count = 0;
                 while (*Child && (Count < Index)) {
                     PrevChild = *Child;
-                    Child = &((*Child)->Next);
+                    Child = &((*Child)->NextPeer);
                     Count++;
                 }
             }
@@ -205,7 +218,7 @@ TDataMember **  CDataTree::GetMemberPtr( TDataMember * BaseMember, const char *
             // Create element if needed
             if (!*Child && Create) {
                 if ((Index == -1) || (Index = Count + 1)) {
-                    *Child = CreateMember( Member, PrevChild, NULL );
+                    *Child = new CDataMember( Member, NULL );
                 }
             }
         }
@@ -242,53 +255,55 @@ TDataMember **  CDataTree::GetMemberPtr( TDataMember * BaseMember, const char *
             Child = &(Member->FirstChild);
             while (*Child && (((*Child)->NameLen != KeyLen) || strncasecmp( (*Child)->Name, Key, KeyLen ))) {
                 PrevChild = *Child;
-                Child = &((*Child)->Next);
+                Child = &((*Child)->NextPeer);
             }
             if (!*Child && Create) {
-                *Child = CreateMember( Member, PrevChild, Key, KeyLen );
+                *Child = new CDataMember( this, Key, KeyLen );
             }
         }
 
-        // Set Parent
-        if (Last && Parent) {
-            *Parent = Member;
-        }
-
         // Next level
         Member  = *Child;
     }
-    return Child;
+    return *Child;
 }
 //---------------------------------------------------------------------------
 
-TDataMember *  CDataTree::GetMember( TDataMember * BaseMember, const char * Path, bool Create )
+CDataMember * CDataMember::GetFirstChild( const char * Path )
 {
-    TDataMember     ** Member;
+    CDataMember     * Member    = NULL;
 
-    // Get Child
-    if (!Path || !*Path) {
-        return ((BaseMember)? BaseMember : NULL);
-    } else {
-        Member = GetMemberPtr( BaseMember, Path, Create );
-        return ((Member)? *Member : NULL);
+    // Find member
+    Member = (!Path || !*Path)? this : GetMember( Path, false );
+
+    // Check if valid type
+    if (!Member || ((Member->Type != jtObject) && (Member->Type != jtNull))) {
+        return NULL;
     }
+
+    return Member->FirstChild;
 }
 //---------------------------------------------------------------------------
 
-TDataMember * CDataTree::GetIndexChild( TDataMember * Parent, const int Index )
+CDataMember * CDataMember::GetElement( const char * Path, const int Index )
 {
-    TDataMember     * Child;
+    CDataMember     * Member    = NULL;
+    CDataMember     * Child     = NULL;
     int             Count;
 
-    // Get Parent
-    if (!Parent)
-        return NULL;
+    // Find Member
+    Member = (!Path || !*Path)? this : GetMember( Path, false );
 
-    // Get Indexed child
+    // Check if valid type
+    if (!Member || ((Member->Type != jtArray) && (Member->Type != jtNull))) {
+        return NULL;
+    }
+
+    // Find element at position
     Count = 0;
-    Child = Parent->FirstChild;
+    Child = Member->FirstChild;
     while (Child && (Count < Index)) {
-        Child = Child->Next;
+        Child = Child->NextPeer;
         Count++;
     }
 
@@ -297,38 +312,18 @@ TDataMember * CDataTree::GetIndexChild( TDataMember * Parent, const int Index )
 }
 //---------------------------------------------------------------------------
 
-TDataMember * CDataTree::GetFirstChild( TDataMember * BaseMember, const char * Path, bool Create )
+bool  CDataMember::Delete( const char * Path )
 {
-    TDataMember     * Member;
-
-    // Validate
-    if (!(Member = GetMember( BaseMember, Path, Create ))) {
-        return NULL;
-    }
-
-    // Return child
-    return Member->FirstChild;
-}
-//---------------------------------------------------------------------------
-
-bool  CDataTree::Delete( TDataMember * BaseMember, const char * Path )
-{
-    TDataMember     * Parent;
-    TDataMember     ** Member;
-
-    // Validate
-    if (!BaseMember && (!Path || !*Path)) {
-        return false;
-    }
+    CDataMember     * Member;
 
     if (!Path || !*Path) {
         // No path - destroy value
-        DestroyValue( BaseMember );
+        Clear();
         return true;
     }
-    else if ((Member = GetMemberPtr( BaseMember, Path, false, &Parent ))) {
+    else if ((Member = GetMember( Path, false ))) {
         // If valid path, destroy member
-        DestroyMember( Member );
+        delete Member;
         return true;
     }
     else {
@@ -337,197 +332,185 @@ bool  CDataTree::Delete( TDataMember * BaseMember, const char * Path )
 }
 //---------------------------------------------------------------------------
 
-bool  CDataTree::DeleteAll()
+bool  CDataMember::SetValue( EDataType pType, const char * pValue, int pLen )
 {
-    // Delete all except root member
-    while (RootMember->FirstChild) {
-        DestroyMember( &(RootMember->FirstChild) );
-    }
-    return true;
-}
-//---------------------------------------------------------------------------
+    Clear();
+    Type  = pType;
 
-bool  CDataTree::SetValuePtr( TDataMember * Member, EDataType Type, char * Value, int Len )
-{
-    // Clear previous value
-    if (Member->Value != NULL || (Member->FirstChild != NULL)) {
-        DestroyValue( Member );
-    }
-
-    // Set type
-    Member->Type    = Type;
-    Member->Value   = Value;
-    Member->Len     = Len;
-    return true;
-}
-//---------------------------------------------------------------------------
-
-bool  CDataTree::SetValue( TDataMember * Member, EDataType Type, const char * Value, int Len )
-{
-    char *  NewValue    = NULL;
-
-    if ((Type == jtString) || (Type == jtFloat) || (Type == jtInt) || (Type == jtBool))
+    if ((pType == jtString) || (pType == jtFloat) || (pType == jtInt) || (pType == jtBool))
     {
-        // Validate
-        if (!Value) {
-            return false;
-        }
-
-        // Check Length
-        if (Len == -1) {
-            Len = strlen(Value);
-        }
-
-        // Create copy of value
-        NewValue = (char*)malloc( Len+1 );
-        if (Value) {
-            memcpy( NewValue, Value, Len );
-        } else {
-            memset( NewValue, 0, Len );
-        }
-        NewValue[Len] = 0;
-        SetValuePtr( Member, Type, NewValue, Len );
-    }
-    else {
-        // Set null value
-        SetValuePtr( Member, Type, NULL, 0 );
+        Len   = (pLen == -1)? strlen(pValue) : pLen;
+        Value = (char*)malloc( Len+1 );
+        memcpy( Value, pValue, Len );
+        Value[Len] = 0;
     }
     return true;
 }
 //---------------------------------------------------------------------------
 
-bool  CDataTree::SetObject( TDataMember * BaseMember, const char * Path )
+bool  CDataMember::SetChildObject( const char * Path )
 {
-    TDataMember     * Member;
+    CDataMember     * Member;
 
     // Validate
-    if (!(Member = GetMember( BaseMember, Path, true ))) {
+    if (!(Member = GetMember( Path, true ))) {
         return false;
     }
 
     // Set as Object
-    SetValue( Member, jtObject, NULL );
+    Member->SetValue( jtObject, NULL );
     return true;
 }
 //---------------------------------------------------------------------------
 
-bool  CDataTree::SetArray( TDataMember * BaseMember, const char * Path )
+bool  CDataMember::SetChildArray( const char * Path )
 {
-    TDataMember     * Member;
+    CDataMember     * Member;
 
     // Validate
-    if (!(Member = GetMember( BaseMember, Path, true ))) {
+    if (!(Member = GetMember( Path, true ))) {
         return false;
     }
 
     // Set as Object
-    SetValue( Member, jtArray, NULL );
+    Member->SetValue( jtArray, NULL );
     return true;
 }
 //---------------------------------------------------------------------------
 
-bool  CDataTree::SetStr( TDataMember * BaseMember, const char * Path, const char * Value, const int Len )
+bool  CDataMember::SetChildStr( const char * Path, const char * Value, const int Len )
 {
-    TDataMember     * Member;
+    CDataMember     * Member;
 
     // Validate
-    if (!(Member = GetMember( BaseMember, Path, true ))) {
+    if (!(Member = GetMember( Path, true ))) {
         return false;
     }
 
     // Create Value
-    SetValue( Member, jtString, Value, Len );
+    if (!Value) {
+        Member->SetValue( jtString, "", 0 );
+    }
+    else {
+        Member->SetValue( jtString, Value, Len );
+    }
     return true;
 }
 //---------------------------------------------------------------------------
 
-bool  CDataTree::SetInt( TDataMember * BaseMember, const char * Path, const long Value, const char * Mask )
+bool  CDataMember::SetChildInt( const char * Path, const long Value, const char * Mask )
 {
-    TDataMember     * Member;
+    CDataMember     * Member;
     char            ValueStr[20];
 
     // Validate
-    if (!(Member = GetMember( BaseMember, Path, true ))) {
+    if (!(Member = GetMember( Path, true ))) {
         return false;
     }
 
     // Create Value
     sprintf( ValueStr, ((Mask)? Mask : "%ld"), Value );
-    SetValue( Member, jtInt, ValueStr );
+    Member->SetValue( jtInt, ValueStr );
     return true;
 }
 //---------------------------------------------------------------------------
 
-bool  CDataTree::SetFloat( TDataMember * BaseMember, const char * Path, const double Value, const char * Mask )
+bool  CDataMember::SetChildFloat( const char * Path, const double Value, const char * Mask )
 {
-    TDataMember     * Member;
+    CDataMember     * Member;
     char            ValueStr[20];
 
     // Validate
-    if (!(Member = GetMember( BaseMember, Path, true ))) {
+    if (!(Member = GetMember( Path, true ))) {
         return false;
     }
 
     // Create Value
     sprintf( ValueStr, ((Mask)? Mask : "%lf"), Value );
-    SetValue( Member, jtFloat, ValueStr );
+    Member->SetValue( jtFloat, ValueStr );
     return true;
 }
 //---------------------------------------------------------------------------
 
-bool  CDataTree::SetBool( TDataMember * BaseMember, const char * Path, const bool Value )
+bool  CDataMember::SetChildBool( const char * Path, const bool Value )
 {
-    TDataMember     * Member;
+    CDataMember     * Member;
 
     // Validate
-    if (!(Member = GetMember( BaseMember, Path, true ))) {
+    if (!(Member = GetMember( Path, true ))) {
         return false;
     }
 
     // Create Value
-    SetValue( Member, jtBool, ((Value == 0)? "0" : "1") );
+    Member->SetValue( jtBool, ((Value == 0)? "0" : "1") );
     return true;
 }
 //---------------------------------------------------------------------------
 
-bool  CDataTree::SetNull( TDataMember * BaseMember, const char * Path )
+bool  CDataMember::SetChildNull( const char * Path )
 {
-    TDataMember     * Member;
+    CDataMember     * Member;
 
     // Validate
-    if (!(Member = GetMember( BaseMember, Path, true ))) {
+    if (!(Member = GetMember( Path, true ))) {
         return false;
     }
 
     // Create Value
-    SetValue( Member, jtNull, NULL );
+    Member->SetValue( jtNull, NULL );
     return true;
 }
 //---------------------------------------------------------------------------
 
-EDataType CDataTree::GetType( TDataMember * BaseMember, const char * Path )
+const char *  CDataMember::GetName( const char * Path )
 {
-    TDataMember     * Member;
+    CDataMember     * Member;
 
     // Validate
-    if (!(Member = GetMember( BaseMember, Path, false ))) {
+    if (!(Member = GetMember( Path, false ))) {
+        return NULL;
+    }
+    return Member->Name;
+}
+//---------------------------------------------------------------------------
+
+EDataType CDataMember::GetType( const char * Path )
+{
+    CDataMember     * Member;
+
+    // Validate
+    if (!(Member = GetMember( Path, false ))) {
         return jtNull;
     }
     return Member->Type;
 }
 //---------------------------------------------------------------------------
 
-const char * CDataTree::GetStr( TDataMember * BaseMember, const char * Path, const char * Default, bool Create )
+const int  CDataMember::GetLen( const char * Path )
 {
-    TDataMember     * Member;
+    CDataMember     * Member;
 
     // Validate
-    if ((Member = GetMember( BaseMember, Path, Create )) &&
+    if ((Member = GetMember( Path, false ))) {
+        return Member->Len;
+    }
+    else {
+        return 0;
+    }
+}
+//---------------------------------------------------------------------------
+
+const char * CDataMember::GetChildStr( const char * Path, const char * Default, bool Create )
+{
+    CDataMember     * Member;
+
+    // Validate
+    if ((Member = GetMember( Path, Create )) &&
             ((Member->Type == jtString) || (Member->Type == jtFloat) || (Member->Type == jtInt) || (Member->Type == jtBool)) ) {
         return Member->Value;
     }
     else if (Member && Create && (Member->Type == jtNull)) {
-        SetValue( Member, jtString, Default );
+        Member->SetValue( jtString, Default );
         return Member->Value;
     }
     else {
@@ -536,18 +519,18 @@ const char * CDataTree::GetStr( TDataMember * BaseMember, const char * Path, con
 }
 //---------------------------------------------------------------------------
 
-const char * CDataTree::GetStr( TDataMember * BaseMember, const char * Path, int &Len, const char * Default, bool Create )
+const char * CDataMember::GetChildStr( const char * Path, int &Len, const char * Default, bool Create )
 {
-    TDataMember     * Member;
+    CDataMember     * Member;
 
     // Validate
-    if ((Member = GetMember( BaseMember, Path, Create )) &&
+    if ((Member = GetMember( Path, Create )) &&
             ((Member->Type == jtString) || (Member->Type == jtFloat) || (Member->Type == jtInt) || (Member->Type == jtBool)) ) {
         Len = Member->Len;
         return Member->Value;
     }
     else if (Member && Create && (Member->Type == jtNull)) {
-        SetValue( Member, jtString, Default );
+        Member->SetValue( jtString, Default );
         Len = Member->Len;
         return Member->Value;
     }
@@ -558,34 +541,19 @@ const char * CDataTree::GetStr( TDataMember * BaseMember, const char * Path, int
 }
 //---------------------------------------------------------------------------
 
-const int  CDataTree::GetLen(   TDataMember * BaseMember, const char * Path )
+const long  CDataMember::GetChildInt( const char * Path, long Default, bool Create, const char * Mask )
 {
-    TDataMember     * Member;
+    CDataMember     * Member;
 
     // Validate
-    if ((Member = GetMember( BaseMember, Path, false )) &&
-            ((Member->Type == jtString) || (Member->Type == jtFloat) || (Member->Type == jtInt) || (Member->Type == jtBool)) ) {
-        return Member->Len;
-    }
-    else {
-        return 0;
-    }
-}
-//---------------------------------------------------------------------------
-
-const long  CDataTree::GetInt( TDataMember * BaseMember, const char * Path, long Default, bool Create, const char * Mask )
-{
-    TDataMember     * Member;
-
-    // Validate
-    if ((Member = GetMember( BaseMember, Path, Create )) &&
+    if ((Member = GetMember( Path, Create )) &&
             ((Member->Type == jtString) || (Member->Type == jtFloat) || (Member->Type == jtInt) || (Member->Type == jtBool)) ) {
         return strtol( Member->Value, NULL, 10 );
     }
     else if (Member && Create && (Member->Type == jtNull)) {
         char TempStr[20];
         sprintf( TempStr, ((Mask)? Mask : "%ld"), Default );
-        SetValue( Member, jtInt, TempStr );
+        Member->SetValue( jtInt, TempStr );
         return Default;
     }
     else {
@@ -594,19 +562,19 @@ const long  CDataTree::GetInt( TDataMember * BaseMember, const char * Path, long
 }
 //---------------------------------------------------------------------------
 
-const double  CDataTree::GetFloat( TDataMember * BaseMember, const char * Path, double Default, bool Create, const char * Mask )
+const double  CDataMember::GetChildFloat( const char * Path, double Default, bool Create, const char * Mask )
 {
-    TDataMember     * Member;
+    CDataMember     * Member;
 
     // Validate
-    if ((Member = GetMember( BaseMember, Path, Create )) &&
+    if ((Member = GetMember( Path, Create )) &&
             ((Member->Type == jtString) || (Member->Type == jtFloat) || (Member->Type == jtInt) || (Member->Type == jtBool)) ) {
         return strtod( Member->Value, NULL );
     }
     else if (Member && Create && (Member->Type == jtNull)) {
         char TempStr[20];
         sprintf( TempStr, ((Mask)? Mask : "%lf"), Default );
-        SetValue( Member, jtFloat, TempStr );
+        Member->SetValue( jtFloat, TempStr );
         return Default;
     }
     else {
@@ -615,12 +583,12 @@ const double  CDataTree::GetFloat( TDataMember * BaseMember, const char * Path,
 }
 //---------------------------------------------------------------------------
 
-const bool  CDataTree::GetBool( TDataMember * BaseMember, const char * Path, bool Default, bool Create )
+const bool  CDataMember::GetChildBool( const char * Path, bool Default, bool Create )
 {
-    TDataMember     * Member;
+    CDataMember     * Member;
 
     // Validate
-    if ((Member = GetMember( BaseMember, Path, Create ))) {
+    if ((Member = GetMember( Path, Create ))) {
         if (Member->Type == jtString) {
             return ((!*Member->Value)? false : true);
         }
@@ -634,7 +602,7 @@ const bool  CDataTree::GetBool( TDataMember * BaseMember, const char * Path, boo
             return ((!strcasecmp( Member->Value, "0" ))? false : true );
         }
         else if ((Member->Type == jtNull) && Create) {
-            SetValue( Member, jtBool, ((Default)? "1" : "0") );
+            Member->SetValue( jtBool, ((Default)? "1" : "0") );
             return Default;
         }
         else {
diff --git a/DataTreeCore.h b/DataTreeCore.h
index e13bc8b..b8dae02 100644
--- a/DataTreeCore.h
+++ b/DataTreeCore.h
@@ -20,77 +20,94 @@ typedef enum { jtNull = 0, jtBool = 1, jtInt = 2, jtFloat = 3, jtString = 4, jtA
 
 //---------------------------------------------------------------------------
 
-// Structure prototypes
-typedef struct SDataMember TDataMember;
-
 // One Config Members
-struct SDataMember
+class CDataMember
 {
     char            * Name;
     unsigned short  NameLen;
     EDataType       Type;
 
-    TDataMember     * FirstChild;
     char            * Value;
     unsigned short  Len;
 
-    TDataMember     * Parent;
-    TDataMember     * Prev;
-    TDataMember     * Next;
-};
+    CDataMember     * FirstChild;
+    CDataMember     * LastChild;
 
-//---------------------------------------------------------------------------
-
-class CDataTree
-{
-private:
-    TDataMember     * RootMember;
+    CDataMember     * Parent;
+    CDataMember     * PrevPeer;
+    CDataMember     * NextPeer;
 
     // Manage Members
-    TDataMember *   CreateMember( TDataMember * Parent, TDataMember * PrevChild, const char * Name, const int Len = -1 );
-    bool            DestroyMember( TDataMember ** Member );
-    bool            DestroyValue( TDataMember * Member );
-
-    // Find Member
-    TDataMember *   GetRootMember()  { return RootMember; };
-    TDataMember **  GetMemberPtr( TDataMember * BaseMember, const char * Path, bool Create, TDataMember ** Parent = NULL );
+    CDataMember *   CreateChild( const char * Name, const int Len = -1 );
 
     // Set Member value
-    bool SetValue(    TDataMember * Member, EDataType Type, const char * Value = NULL, int Len = -1 );
-    bool SetValuePtr( TDataMember * Member, EDataType Type, char * Value, int Len );
+    bool SetValue( EDataType Type, const char * Value = NULL, int Len = -1 );
 
 public:
-    CDataTree();
-    ~CDataTree();
+    CDataMember( const char * pName = NULL, const int pLen = -1 );
+    CDataMember( CDataMember * pParent, const char * pName = NULL, const int pLen = -1 );
+    ~CDataMember();
 
-    EDataType     GetType(   TDataMember * BaseMember, const char * Path );
-    TDataMember * GetMember( TDataMember * BaseMember, const char * Path, bool Create = false );
+    EDataType     GetType() { return Type; };
+    EDataType     GetType( const char * Path );
 
-    TDataMember *       GetIndexChild( TDataMember * Parent, const int Index );
-    TDataMember *       GetFirstChild( TDataMember * Parent, const char * Path, bool Create = false  );
+    inline bool   isNull()      { return (Type == jtNull); };
+    inline bool   isBool()      { return (Type == jtBool); };
+    inline bool   isInt()       { return (Type == jtInt); };
+    inline bool   isFloat()     { return (Type == jtFloat); };
+    inline bool   isString()    { return (Type == jtString); };
+    inline bool   isArray()     { return (Type == jtArray); };
+    inline bool   isObject()    { return (Type == jtObject); };
 
-    inline TDataMember *    GetParent( TDataMember * Child )        { return ((Child)?  Child->Parent : NULL); };
-    inline TDataMember *    GetFirstChild( TDataMember * Parent )   { return ((Parent)? Parent->FirstChild : NULL); };
-    inline TDataMember *    GetPrevChild( TDataMember * Child )     { return ((Child)?  Child->Prev : NULL); };
-    inline TDataMember *    GetNextChild( TDataMember * Child )     { return ((Child)?  Child->Next : NULL); };
+    const char *  GetName() { return Name; };
+    const char *  GetName( const char * Path );
 
-    const char *    GetStr(   TDataMember * BaseMember, const char * Path, const char * Default = NULL, bool Create = false );
-    const char *    GetStr(   TDataMember * BaseMember, const char * Path, int &Len, const char * Default = NULL, bool Create = false );
-    const int       GetLen(   TDataMember * BaseMember, const char * Path );
-    const long      GetInt(   TDataMember * BaseMember, const char * Path, long Default = 0, bool Create = false, const char * Mask = NULL );
-    const double    GetFloat( TDataMember * BaseMember, const char * Path, double Default = 0.0, bool Create = false, const char * Mask = NULL );
-    const bool      GetBool(  TDataMember * BaseMember, const char * Path, bool Default = false, bool Create = false );
+    const int     GetLen()  { return Len; };
+    const int     GetLen( const char * Path );
 
-    bool SetObject( TDataMember * BaseMember, const char * Path );
-    bool SetArray(  TDataMember * BaseMember, const char * Path );
-    bool SetStr(    TDataMember * BaseMember, const char * Path, const char * Value = NULL, const int Len = -1 );   // Use Len param if Value contains NULL values
-    bool SetInt(    TDataMember * BaseMember, const char * Path, const long Value, const char * Mask = NULL );
-    bool SetFloat(  TDataMember * BaseMember, const char * Path, const double Value, const char * Mask = NULL );
-    bool SetBool(   TDataMember * BaseMember, const char * Path, const bool Value );
-    bool SetNull(   TDataMember * BaseMember, const char * Path );
+    CDataMember *  GetMember( const char * Path, bool Create = false );
+    CDataMember *  GetFirstChild( const char * Path );
+    CDataMember *  GetElement( const char * Path, const int Index );
 
-    bool Delete( TDataMember * BaseMember, const char * Path );
-    bool DeleteAll();
+    inline CDataMember *    GetFirstChild()                { return FirstChild; };
+    inline CDataMember *    GetElement( const int Index )  { return GetElement( NULL, Index ); };
+
+    inline CDataMember *    GetParent()     { return Parent; };
+    inline CDataMember *    GetPrevPeer()   { return PrevPeer; };
+    inline CDataMember *    GetNextPeer()   { return NextPeer; };
+
+    const char *    GetChildStr(   const char * Path, const char * Default = NULL, bool Create = false );
+    const char *    GetChildStr(   const char * Path, int &Len, const char * Default = NULL, bool Create = false );
+    const bool      GetChildBool(  const char * Path, bool Default = false, bool Create = false );
+    const long      GetChildInt(   const char * Path, long Default = 0, bool Create = false, const char * Mask = NULL );
+    const double    GetChildFloat( const char * Path, double Default = 0.0, bool Create = false, const char * Mask = NULL );
+
+    inline const char *    GetStr( const char * Default = NULL, bool Create = false )                       { return GetChildStr( NULL, Default, Create ); };
+    inline const char *    GetStr( int &Len, const char * Default = NULL, bool Create = false )             { return GetChildStr( NULL, Len, Default, Create ); };
+    inline const bool      GetBool( bool Default = false, bool Create = false )                             { return GetChildBool( NULL, Default, Create ); };
+    inline const long      GetInt( long Default = 0, bool Create = false, const char * Mask = NULL   )      { return GetChildInt( NULL, Default, Create, Mask ); };
+    inline const double    GetFloat( double Default = 0.0, bool Create = false, const char * Mask = NULL )  { return GetChildFloat( NULL, Default, Create, Mask ); };
+
+    bool SetChildBool(  const char * Path, const bool Value );
+    bool SetChildInt(   const char * Path, const long Value, const char * Mask = NULL );
+    bool SetChildFloat( const char * Path, const double Value, const char * Mask = NULL );
+    bool SetChildStr(   const char * Path, const char * Value = NULL, const int Len = -1 );   // Use Len param if Value contains NULL values
+
+    inline bool SetBool(  const bool Value )                              { return SetChildBool(  NULL, Value ); };
+    inline bool SetInt(   const long Value, const char * Mask = NULL )    { return SetChildInt(   NULL, Value, Mask ); };
+    inline bool SetFloat( const double Value, const char * Mask = NULL )  { return SetChildFloat( NULL, Value, Mask ); };
+    inline bool SetStr(   const char * Value = NULL, const int Len = -1 ) { return SetChildStr(   NULL, Value, Len ); };
+
+    bool SetChildNull(   const char * Path );
+    bool SetChildObject( const char * Path );
+    bool SetChildArray(  const char * Path );
+
+    inline bool SetNull()       { return SetChildNull( NULL ); };
+    inline bool SetObject()     { return SetChildObject( NULL ); };
+    inline bool SetArray()      { return SetChildArray( NULL ); };
+
+    bool Clear();
+    bool Delete( const char * Path );
 
     friend class CJSONparse;
 };
diff --git a/FunctionCore.cpp b/FunctionCore.cpp
index 60aca62..61e4cb6 100644
--- a/FunctionCore.cpp
+++ b/FunctionCore.cpp
@@ -113,14 +113,14 @@ CFunctionCore::~CFunctionCore()
 
 bool  CFunctionCore::LoadConfigData()
 {
-    TDataMember     * TempMember;
+    CDataMember     * TempMember;
     EDebugLevel     pLogLevel;
     int             pLogOutput;
     char            * TempStr;
 
     // Get debug level
     pLogLevel = dlNone;
-    TempStr = (char*)DataTree->GetStr( ConfigMember, "Log/Level", "Medium", true );
+    TempStr = (char*)ConfigMember->GetChildStr( "Log/Level", "Medium", true );
     if (TempStr)
     {
         if (!strcasecmp( TempStr, "Low" ))
@@ -133,44 +133,47 @@ bool  CFunctionCore::LoadConfigData()
 
     // Set debug output
     pLogOutput = 0;
-    TempMember = DataTree->GetFirstChild( ConfigMember, "Log/Output", true );
-    while (TempMember)
+    if ((TempMember = ConfigMember->GetMember( "Log/Output", true )))
     {
-        if (TempMember->Value)
+        TempMember = TempMember->GetFirstChild();
+        while (TempMember)
         {
-            if (!strcasecmp( TempMember->Value, "Normal"))
-                pLogOutput |= OUT_NORMAL;
-            else if (!strcasecmp( TempMember->Value, "Bin"))
-                pLogOutput |= OUT_BIN;
-            else if (!strcasecmp( TempMember->Value, "Hex"))
-                pLogOutput |= OUT_HEX;
-            else if (!strcasecmp( TempMember->Value, "Count"))
-                pLogOutput |= OUT_COUNT;
-            else if (!strcasecmp( TempMember->Value, "AsIs"))
-                pLogOutput |= OUT_ASIS;
-            else if (!strcasecmp( TempMember->Value, "CRLF"))
-                pLogOutput |= OUT_CRLF;
-        }
+            if ((TempStr = (char*)TempMember->GetStr()))
+            {
+                if (!strcasecmp( TempStr, "Normal"))
+                    pLogOutput |= OUT_NORMAL;
+                else if (!strcasecmp( TempStr, "Bin"))
+                    pLogOutput |= OUT_BIN;
+                else if (!strcasecmp( TempStr, "Hex"))
+                    pLogOutput |= OUT_HEX;
+                else if (!strcasecmp( TempStr, "Count"))
+                    pLogOutput |= OUT_COUNT;
+                else if (!strcasecmp( TempStr, "AsIs"))
+                    pLogOutput |= OUT_ASIS;
+                else if (!strcasecmp( TempStr, "CRLF"))
+                    pLogOutput |= OUT_CRLF;
+            }
 
-        // Next
-        TempMember = DataTree->GetNextChild( TempMember );
+            // Next
+            TempMember = TempMember->GetNextPeer();
+        }
     }
 
     // Set Logging
     SetLogParam( pLogLevel, pLogOutput );
 
     // Load Channels
-    TempMember = DataTree->GetFirstChild( ConfigMember, "Channels" );
+    TempMember = ConfigMember->GetFirstChild( "Channels" );
     while (TempMember)
     {
-        if (TempMember->Name) {
-            AddChannel( TempMember->Name,
-                        DataTree->GetBool( TempMember, "InputEnabled", true, true ),
-                        DataTree->GetBool( TempMember, "OutputEnabled", false, true ));
+        if (TempMember->GetName()) {
+            AddChannel( TempMember->GetName(),
+                        TempMember->GetChildBool( "InputEnabled", true, true ),
+                        TempMember->GetChildBool( "OutputEnabled", false, true ));
         }
 
         // Next
-        TempMember = DataTree->GetNextChild( TempMember );
+        TempMember = TempMember->GetNextPeer();
     }
 
     return true;
@@ -180,29 +183,29 @@ bool  CFunctionCore::LoadConfigData()
 bool  CFunctionCore::LoadChannelLinkData()
 {
     TChannel        * Channel;
-    TDataMember     * ChannelMember;
-    TDataMember     * FunctionMember;
+    CDataMember     * ChannelMember;
+    CDataMember     * FunctionMember;
 
     // Process each Channel
-    ChannelMember = DataTree->GetFirstChild( LinkConfigMember );
+    ChannelMember = LinkConfigMember->GetFirstChild();
     while (ChannelMember)
     {
-        if ((Channel = GetChannel( ChannelMember->Name )))
+        if ((Channel = GetChannel( ChannelMember->GetName() )))
         {
-            FunctionMember = DataTree->GetFirstChild( ChannelMember );
+            FunctionMember = ChannelMember->GetFirstChild();
             while (FunctionMember)
             {
                 // Get Parameters
                 LinkOutputChannel( Channel->Name,
-                                   DataTree->GetStr( FunctionMember, "Function" ),
-                                   DataTree->GetStr( FunctionMember, "Channel" ),
-                                   DataTree->GetBool( FunctionMember, "Bidirectional" ) );
+                                   FunctionMember->GetChildStr( "Function" ),
+                                   FunctionMember->GetChildStr( "Channel" ),
+                                   FunctionMember->GetChildBool( "Bidirectional" ) );
                 // Next
-                FunctionMember = DataTree->GetNextChild( FunctionMember );
+                FunctionMember = FunctionMember->GetNextPeer();
             }
         }
         // Next
-        ChannelMember = DataTree->GetNextChild( ChannelMember );
+        ChannelMember = ChannelMember->GetNextPeer();
     }
 
     return true;
@@ -221,7 +224,7 @@ bool  CFunctionCore::Init()
 bool  CFunctionCore::InitConfig( const char * pConfigPath )
 {
     // Validate
-    if (!DataTree || !(ConfigMember = DataTree->GetMember( NULL, pConfigPath, true )))
+    if (!DataTree || !(ConfigMember = DataTree->GetMember( pConfigPath, true )))
         return false;
 
     // Load configuration
@@ -232,7 +235,7 @@ bool  CFunctionCore::InitConfig( const char * pConfigPath )
 }
 //---------------------------------------------------------------------------
 
-bool  CFunctionCore::InitConfig( TDataMember * pBaseMember )
+bool  CFunctionCore::InitConfig( CDataMember * pBaseMember )
 {
     // Validate
     if (!DataTree || !(ConfigMember = pBaseMember ))
@@ -249,7 +252,7 @@ bool  CFunctionCore::InitConfig( TDataMember * pBaseMember )
 bool  CFunctionCore::InitChannelLinks( const char * pLinkConfigPath )
 {
     // Validate
-    if (!DataTree || !(LinkConfigMember = DataTree->GetMember( NULL, pLinkConfigPath, true )))
+    if (!DataTree || !(LinkConfigMember = DataTree->GetMember( pLinkConfigPath, true )))
         return false;
 
     // Load configuration
@@ -259,7 +262,7 @@ bool  CFunctionCore::InitChannelLinks( const char * pLinkConfigPath )
 }
 //---------------------------------------------------------------------------
 
-bool  CFunctionCore::InitChannelLinks( TDataMember *pLinkConfigMember )
+bool  CFunctionCore::InitChannelLinks( CDataMember *pLinkConfigMember )
 {
     // Validate
     if (!DataTree || !(LinkConfigMember = pLinkConfigMember))
diff --git a/FunctionCore.h b/FunctionCore.h
index a48e8eb..3817137 100644
--- a/FunctionCore.h
+++ b/FunctionCore.h
@@ -56,9 +56,9 @@ protected:
     char    * Type;
 
     // Configuration
-    CDataTree   * DataTree;
-    TDataMember * ConfigMember;
-    TDataMember * LinkConfigMember;
+    CDataMember * DataTree;
+    CDataMember * ConfigMember;
+    CDataMember * LinkConfigMember;
 
     // Channels
     TChannel     * FirstChannel;
@@ -98,10 +98,10 @@ public:
     virtual bool  Init();
 
     bool  InitConfig( const char * pConfigPath );
-    bool  InitConfig( TDataMember * pConfigMember );
+    bool  InitConfig( CDataMember * pConfigMember );
 
     bool  InitChannelLinks( const char * pLinkConfigPath );
-    bool  InitChannelLinks( TDataMember *pLinkConfigMember );
+    bool  InitChannelLinks( CDataMember *pLinkConfigMember );
 
     // Set Parameters Manually
     bool  SetLogParam( EDebugLevel pDebugLevel, int pOutputDisplay );
diff --git a/JSONparseCore.cpp b/JSONparseCore.cpp
index cc86530..2271ad1 100644
--- a/JSONparseCore.cpp
+++ b/JSONparseCore.cpp
@@ -15,7 +15,7 @@
 
 //---------------------------------------------------------------------------
 
-CJSONparse::CJSONparse( CDataTree * pDataTree )
+CJSONparse::CJSONparse( CDataMember * pDataTree )
 {
     // Object tree
     DataTree        = pDataTree;
@@ -120,7 +120,7 @@ bool CJSONparse::WriteToFile( const char * BasePath, const char * FilePath, cons
 
 bool CJSONparse::WriteToHandle( const char * BasePath, const int Handle, const int Indent )
 {
-    TDataMember    * BaseMember;
+    CDataMember    * Member;
 
     // Validate
     if (!DataTree) {
@@ -136,17 +136,14 @@ bool CJSONparse::WriteToHandle( const char * BasePath, const int Handle, const i
     OutputHandle = Handle;
 
     // Get Root object
-    if (!BasePath || !*BasePath) {
-        BaseMember = DataTree->GetRootMember();
-    }
-    else if (!(BaseMember = DataTree->GetMember( NULL, BasePath ))) {
+    if (!(Member = DataTree->GetMember( BasePath ))) {
         Error = true;
         sprintf( ErrorText, "Invalid root object path" );
         return false;
     }
 
     // Print to file
-    PrintObject( BaseMember, Indent );
+    PrintObject( Member, Indent );
     write( OutputHandle, "\n", 1 );
 
     OutputHandle = -1;
@@ -279,7 +276,7 @@ bool CJSONparse::ReadFromString( const char * BasePath, const char * InString, c
 
 bool CJSONparse::ReadFromBuffer( const char * BasePath )
 {
-    TDataMember    * BaseMember     = NULL;
+    CDataMember    * BaseMember     = NULL;
 
     // Validate
     if (!DataTree || !Buffer) {
@@ -290,17 +287,14 @@ bool CJSONparse::ReadFromBuffer( const char * BasePath )
     Error = false;
 
     // Get/Create Root object
-    if (!BasePath || !*BasePath) {
-        BaseMember = DataTree->GetRootMember();
-    }
-    else if (!(BaseMember = DataTree->GetMember( NULL, BasePath, true ))) {
+    if (!(BaseMember = DataTree->GetMember( BasePath, true ))) {
         Error = true;
         sprintf( ErrorText, "Invalid root object path" );
         return false;
     }
 
     // Delete existing object contents
-    DataTree->Delete( BaseMember, NULL );
+    BaseMember->Clear();
 
     // Position Counters
     LineNo          = 1;
@@ -537,9 +531,9 @@ bool CJSONparse::ParseString( char ** Value, int &Len )
 }
 //---------------------------------------------------------------------------
 
-bool CJSONparse::ParseObject( TDataMember * Object )
+bool CJSONparse::ParseObject( CDataMember * Object )
 {
-    TDataMember    * Member         = NULL;
+    CDataMember    * Member         = NULL;
     char           * MemberName     = NULL;
     int             Len             = 0;
 
@@ -550,7 +544,7 @@ bool CJSONparse::ParseObject( TDataMember * Object )
     BufPos++;
 
     // Set Type
-    DataTree->SetValue( Object, jtObject );
+    Object->SetValue( jtObject );
 
     while (true)
     {
@@ -574,7 +568,7 @@ bool CJSONparse::ParseObject( TDataMember * Object )
         }
 
         // Check if Member exists
-        Member = DataTree->GetMember( Object, MemberName, true );
+        Member = Object->GetMember( MemberName, true );
 
         // Check for delimiter
         SkipWhiteSpace();
@@ -590,7 +584,7 @@ bool CJSONparse::ParseObject( TDataMember * Object )
         if (!ParseObject( Member ) && !Error && !ParseArray( Member ) && !Error && !ParseString( Member ) && !Error && !ParsePrimitive( Member ) ) {}
         if (Error) {
             // Destroy member
-            DataTree->Delete( Object, MemberName );
+            Object->Delete( MemberName );
             return false;
         }
 
@@ -619,10 +613,9 @@ bool CJSONparse::ParseObject( TDataMember * Object )
 }
 //---------------------------------------------------------------------------
 
-bool CJSONparse::ParseArray( TDataMember * Array )
+bool CJSONparse::ParseArray( CDataMember * Array )
 {
-    TDataMember     ** Member;
-    TDataMember     * PrevMember;
+    CDataMember     ** Member;
 
     // Check for start of Object
     if (*BufPos != '[') {
@@ -631,9 +624,8 @@ bool CJSONparse::ParseArray( TDataMember * Array )
     BufPos++;
 
     // Set Type
-    DataTree->SetValue( Array, jtArray );
+    Array->SetValue( jtArray );
     Member = &(Array->FirstChild);
-    PrevMember = NULL;
     while (true)
     {
         // Look for Member Name
@@ -643,18 +635,17 @@ bool CJSONparse::ParseArray( TDataMember * Array )
         }
 
         // Add new element
-        *Member = DataTree->CreateMember( Array, PrevMember, NULL );
+        *Member = new CDataMember( Array );
 
         // Get Value
         SkipWhiteSpace();
         if (!ParseObject( *Member ) && !Error && !ParseArray( *Member ) && !Error && !ParseString( *Member ) && !Error && !ParsePrimitive( *Member ) ) {}
         if (Error) {
-            DataTree->DestroyMember( Member );
+            delete Member;
             return false;
         }
         else {
-            PrevMember = *Member;
-            Member = &((*Member)->Next);
+            Member = &((*Member)->NextPeer);
         }
 
         // Check if more parameters to follow
@@ -679,7 +670,7 @@ bool CJSONparse::ParseArray( TDataMember * Array )
 }
 //---------------------------------------------------------------------------
 
-bool CJSONparse::ParseString( TDataMember * Member )
+bool CJSONparse::ParseString( CDataMember * Member )
 {
     char    * Value     = NULL;
     int     Len         = 0;
@@ -690,13 +681,13 @@ bool CJSONparse::ParseString( TDataMember * Member )
     }
 
     // Set string
-    DataTree->SetValuePtr( Member, jtString, Value, Len );
+    Member->SetValue( jtString, Value, Len );
     return true;
 }
 //---------------------------------------------------------------------------
 
 
-bool CJSONparse::ParsePrimitive( TDataMember * Member )
+bool CJSONparse::ParsePrimitive( CDataMember * Member )
 {
     char    * Value     = NULL;
     int     Len         = 0;
@@ -721,13 +712,13 @@ bool CJSONparse::ParsePrimitive( TDataMember * Member )
 
     // Check for primitive values
     if ((Len == 4) && !strncasecmp( Mark, "null", 4 )) {
-        DataTree->SetValuePtr( Member, jtNull, NULL, -1 );
+        Member->SetValue( jtNull, NULL, -1 );
     }
     else if ((Len == 4) && !strncasecmp( Mark, "true", 4 )) {
-        DataTree->SetValue( Member, jtBool, "1" );
+        Member->SetValue( jtBool, "1" );
     }
     else if ((Len == 5) && !strncasecmp( Mark, "false", 5 )) {
-        DataTree->SetValue( Member, jtBool, "0" );
+        Member->SetValue( jtBool, "0" );
     }
     else {
         // Try conversion to int
@@ -736,7 +727,7 @@ bool CJSONparse::ParsePrimitive( TDataMember * Member )
             Value = (char*)malloc( Len+1 );
             memcpy( Value, Mark, Len );
             Value[Len] = 0;
-            DataTree->SetValuePtr( Member, jtInt, Value, Len );
+            Member->SetValue( jtInt, Value, Len );
         }
         else {
             // Try conversion to float
@@ -745,7 +736,7 @@ bool CJSONparse::ParsePrimitive( TDataMember * Member )
                 Value = (char*)malloc( Len+1 );
                 memcpy( Value, Mark, Len );
                 Value[Len] = 0;
-                DataTree->SetValuePtr( Member, jtFloat, Value, Len );
+                Member->SetValue( jtFloat, Value, Len );
             }
             else {
                 Error = true;
@@ -806,9 +797,9 @@ bool CJSONparse::PrintString( char * String, int Len )
 }
 //---------------------------------------------------------------------------
 
-bool CJSONparse::PrintObject( TDataMember * Object, const int Indent )
+bool CJSONparse::PrintObject( CDataMember * Object, const int Indent )
 {
-    TDataMember     * Member;
+    CDataMember     * Member;
     bool            First       = true;
     bool            Last        = false;
     int             Count       = 0;
@@ -824,7 +815,7 @@ bool CJSONparse::PrintObject( TDataMember * Object, const int Indent )
     }
 
     // Save parameters
-    for (Member = Object->FirstChild; Member != NULL; (Member = Member->Next))
+    for (Member = Object->FirstChild; Member != NULL; (Member = Member->NextPeer))
     {
         // Whitespace around first bracket
         if (Indent) {
@@ -895,9 +886,9 @@ bool CJSONparse::PrintObject( TDataMember * Object, const int Indent )
 }
 //---------------------------------------------------------------------------
 
-bool CJSONparse::PrintArray( TDataMember * Array, const int Indent )
+bool CJSONparse::PrintArray( CDataMember * Array, const int Indent )
 {
-    TDataMember     * Member;
+    CDataMember     * Member;
     bool            First       = true;
     bool            Last        = false;
     int             Count       = 0;
@@ -913,7 +904,7 @@ bool CJSONparse::PrintArray( TDataMember * Array, const int Indent )
     }
 
     // Save parameters
-    for (Member = Array->FirstChild; Member != NULL; (Member = Member->Next))
+    for (Member = Array->FirstChild; Member != NULL; (Member = Member->NextPeer))
     {
         // Whitespace around brace
         if (Indent) {
diff --git a/JSONparseCore.h b/JSONparseCore.h
index 2f1a2a0..1938c86 100644
--- a/JSONparseCore.h
+++ b/JSONparseCore.h
@@ -21,7 +21,7 @@
 class CJSONparse
 {
 private:
-    CDataTree   * DataTree;
+    CDataMember     * DataTree;
 
     // File operation
     int     InputHandle;
@@ -47,17 +47,17 @@ private:
     // Parsing functions
     void SkipWhiteSpace();
     bool ParseString( char ** Value, int &pLen );
-    bool ParseObject( TDataMember * Object );
-    bool ParseArray( TDataMember * Array );
-    bool ParseString( TDataMember * Member );
-    bool ParsePrimitive( TDataMember * Member );
+    bool ParseObject( CDataMember * Object );
+    bool ParseArray( CDataMember * Array );
+    bool ParseString( CDataMember * Member );
+    bool ParsePrimitive( CDataMember * Member );
 
     bool PrintString( char * String, int Len );
-    bool PrintObject( TDataMember * Object, const int Indent );
-    bool PrintArray( TDataMember * Object, const int Indent );
+    bool PrintObject( CDataMember * Object, const int Indent );
+    bool PrintArray( CDataMember * Object, const int Indent );
 
 public:
-    CJSONparse( CDataTree * pDataTree );
+    CJSONparse( CDataMember * pDataTree );
     ~CJSONparse();
 
     // Buffer operation
diff --git a/SelectableCore.cpp b/SelectableCore.cpp
index 2f95a3c..63d54e1 100644
--- a/SelectableCore.cpp
+++ b/SelectableCore.cpp
@@ -65,8 +65,8 @@ CSelectableCore::~CSelectableCore()
 
 bool  CSelectableCore::LoadConfigData()
 {
-    TDataMember     * TempMember;
-    TDataMember     * SerialConfig;
+    CDataMember     * TempMember;
+    CDataMember     * SerialConfig;
     THandle         * Handle;
     char            * Type;
     char            * Name;
@@ -83,33 +83,35 @@ bool  CSelectableCore::LoadConfigData()
     CFunctionCore::LoadConfigData();
 
     // Load Handles
-    TempMember = DataTree->GetFirstChild( DataTree->GetMember( ConfigMember, "Handles", false ) );
+    if ((TempMember = ConfigMember->GetMember( "Handles", false ))) {
+        TempMember = TempMember->GetFirstChild();
+    }
     while (TempMember)
     {
         // Check if name is valid
-        if (!TempMember->Name || !*TempMember->Name)
+        if (!TempMember->GetName() || !*TempMember->GetName())
             continue;
 
         // Create Handle and channel link
-        Handle = CreateHandle( TempMember->Name, false );
-        Handle->Channel = GetChannel( DataTree->GetStr( TempMember, "Channel" ) );
+        Handle = CreateHandle( TempMember->GetName(), false );
+        Handle->Channel = GetChannel( TempMember->GetChildStr( "Channel" ) );
 
-        Type = (char*)DataTree->GetStr( TempMember, "Type", "TCPclient", true );
+        Type = (char*)TempMember->GetChildStr( "Type", "TCPclient", true );
         if (!strcasecmp( Type, "Serial" ))
         {
-            if ((Name = (char*)DataTree->GetStr( TempMember, "Port/Name", NULL ))) {
+            if ((Name = (char*)TempMember->GetChildStr( "Port/Name", NULL ))) {
                 sprintf( Path, "Address/%s/Address", Name );
-                Address = (char*)DataTree->GetStr( NULL, Path, Address, true );                // Get address list value
+                Address = (char*)DataTree->GetChildStr( Path, NULL, true );                // Get address list value
             }
             else {
-                Address = (char*)DataTree->GetStr( TempMember, "Port/Address", NULL, true );   // Get default value
+                Address = (char*)TempMember->GetChildStr( "Port/Address", NULL, true );   // Get default value
             }
             SetSerialHandle( Handle, Address );
 
             // Update configuration if specified
-            if ((SerialConfig = DataTree->GetMember( TempMember, "Port/SerialConfig", false )))
+            if ((SerialConfig = TempMember->GetMember( "Port/SerialConfig", false )))
             {
-                ParityText = (char*)DataTree->GetStr( SerialConfig, "Parity",   "none", true );
+                ParityText = (char*)SerialConfig->GetChildStr( "Parity",   "none", true );
                 if (!strcasecmp( ParityText, "none" ))
                     Parity = NO_PARITY;
                 else if (!strcasecmp( ParityText, "odd" ))
@@ -119,7 +121,7 @@ bool  CSelectableCore::LoadConfigData()
                 else if (!strcasecmp( ParityText, "mark" ))
                     Parity = MARK_PARITY;
 
-                FlowCtrlText = (char*)DataTree->GetStr( SerialConfig, "FlowCtrl", "none", true );
+                FlowCtrlText = (char*)SerialConfig->GetChildStr( "FlowCtrl", "none", true );
                 if (!strcasecmp( FlowCtrlText, "none" ))
                     FlowCtrl = NO_FLOWCTRL;
                 else if (!strcasecmp( FlowCtrlText, "hardware" ))
@@ -128,73 +130,73 @@ bool  CSelectableCore::LoadConfigData()
                     FlowCtrl = SW_FLOWCTRL;
 
                 Handle->SerialConfig = true;
-                SetSerialHandleConfig( Handle, DataTree->GetInt( SerialConfig, "BaudRate", 19200, true ),
-                                     DataTree->GetInt( SerialConfig, "DataBits", 8, true ),
-                                     Parity, DataTree->GetInt( SerialConfig, "StopBits", 1, true ),
-                                     FlowCtrl, DataTree->GetInt( SerialConfig, "DataWait", 0, true ));
+                SetSerialHandleConfig( Handle, SerialConfig->GetChildInt( "BaudRate", 19200, true ),
+                                       SerialConfig->GetChildInt( "DataBits", 8, true ),
+                                       Parity, SerialConfig->GetChildInt( "StopBits", 1, true ),
+                                       FlowCtrl, SerialConfig->GetChildInt( "DataWait", 0, true ));
             }
         }
         else if (!strcasecmp( Type, "LinePrinter" ))
         {
-            if ((Name = (char*)DataTree->GetStr( TempMember, "Port/Name", NULL ))) {
+            if ((Name = (char*)TempMember->GetChildStr( "Port/Name", NULL ))) {
                 sprintf( Path, "Address/%s/Address", Name );
-                Address = (char*)DataTree->GetStr( NULL, Path, NULL, true );                   // Get address list value
+                Address = (char*)DataTree->GetChildStr( Path, NULL, true );                   // Get address list value
             }
             else {
-                Address = (char*)DataTree->GetStr( TempMember, "Port/Address", NULL, true );   // Get default value
+                Address = (char*)TempMember->GetChildStr( "Port/Address", NULL, true );   // Get default value
             }
             SetLinePrinterHandle( Handle, Address );
         }
         else if (!strcasecmp( Type, "TCPserver" ))
         {
-            if ((Name = (char*)DataTree->GetStr( TempMember, "Socket/Name", NULL ))) {
+            if ((Name = (char*)TempMember->GetChildStr( "Socket/Name", NULL ))) {
                 sprintf( Path, "Address/%s/Address", Name );
-                Address = (char*)DataTree->GetStr( NULL, Path, NULL, true );                  // Get AddressList Address value
+                Address = (char*)DataTree->GetChildStr( Path, NULL, true );                  // Get AddressList Address value
                 sprintf( Path, "Address/%s/Port", Name );
-                Port = (char*)DataTree->GetStr( NULL, Path, "0", true );                      // Get AddressList Port value
+                Port = (char*)DataTree->GetChildStr( Path, "0", true );                      // Get AddressList Port value
             }
             else {
-                Address = (char*)DataTree->GetStr( TempMember, "Socket/Address", NULL, true ); // Get default Address value
-                Port = (char*)DataTree->GetStr( TempMember, "Socket/Port", "0", true );        // Get default Port value
+                Address = (char*)TempMember->GetChildStr( "Socket/Address", NULL, true ); // Get default Address value
+                Port = (char*)TempMember->GetChildStr( "Socket/Port", "0", true );        // Get default Port value
             }
-            Delay = DataTree->GetInt( TempMember, "Socket/ResolveDelay", 0, true );
+            Delay = TempMember->GetChildInt( "Socket/ResolveDelay", 0, true );
             SetSocketHandle( Handle, ctServer, Address, strlcase(Port), Delay );
         }
         else if (!strcasecmp( Type, "TCPclient" ))
         {
-            if ((Name = (char*)DataTree->GetStr( TempMember, "Socket/Name", NULL ))) {
+            if ((Name = (char*)TempMember->GetChildStr( "Socket/Name", NULL ))) {
                 sprintf( Path, "Address/%s/Address", Name );
-                Address = (char*)DataTree->GetStr( NULL, Path, NULL, true );                  // Get AddressList Address value
+                Address = (char*)DataTree->GetChildStr( Path, NULL, true );                  // Get AddressList Address value
                 sprintf( Path, "Address/%s/Port", Name );
-                Port = (char*)DataTree->GetStr( NULL, Path, "0", true );                      // Get AddressList Port value
+                Port = (char*)DataTree->GetChildStr( Path, "0", true );                      // Get AddressList Port value
             }
             else {
-                Address = (char*)DataTree->GetStr( TempMember, "Socket/Address", NULL, true ); // Get default Address value
-                Port = (char*)DataTree->GetStr( TempMember, "Socket/Port", "0", true );        // Get default Port value
+                Address = (char*)TempMember->GetChildStr( "Socket/Address", NULL, true ); // Get default Address value
+                Port = (char*)TempMember->GetChildStr( "Socket/Port", "0", true );        // Get default Port value
             }
-            Delay = DataTree->GetInt( TempMember, "Socket/ResolveDelay", 0, true );
+            Delay = TempMember->GetChildInt( "Socket/ResolveDelay", 0, true );
             SetSocketHandle( Handle, ctClient, Address, strlcase(Port), Delay );
         }
         else if (!strcasecmp( Type, "ForkPipe" )) {
-            Address = (char*)DataTree->GetStr( TempMember, "Fork/ExecPath", NULL, true );      // Get default value
+            Address = (char*)TempMember->GetChildStr( "Fork/ExecPath", NULL, true );      // Get default value
             SetForkPipeHandle( Handle, Address );
         }
 
         // Set Auto Mange
-        SetAutoManage( Handle, DataTree->GetBool( TempMember, "AutoManage/Enabled", true, true ),
-                               DataTree->GetBool( TempMember, "AutoManage/Persistent", false, true ),
-                               DataTree->GetInt( TempMember, "AutoManage/ReopenDelay", 2000, true ),
-                               DataTree->GetInt( TempMember, "AutoManage/CloseTimeout", 2000, true ));
+        SetAutoManage( Handle, TempMember->GetChildBool( "AutoManage/Enabled", true, true ),
+                               TempMember->GetChildBool( "AutoManage/Persistent", false, true ),
+                               TempMember->GetChildInt( "AutoManage/ReopenDelay", 2000, true ),
+                               TempMember->GetChildInt( "AutoManage/CloseTimeout", 2000, true ));
 
         // Input buffer
-        SetInBuffer( Handle, DataTree->GetInt( TempMember, "InputBuffer/Size", 0 ),
-                             DataTree->GetInt( TempMember, "InputBuffer/Timeout", 250 ),
-                             DataTree->GetStr( TempMember, "InputBuffer/Marker", "" ),
-                             DataTree->GetInt( TempMember, "InputBuffer/MarkerLen", 0 ) );
-        SetOutBuffer( Handle, DataTree->GetInt( TempMember, "OutputBuffer/Size", 0 ) );
+        SetInBuffer( Handle, TempMember->GetChildInt( "InputBuffer/Size", 0 ),
+                             TempMember->GetChildInt( "InputBuffer/Timeout", 250 ),
+                             TempMember->GetChildStr( "InputBuffer/Marker", "" ),
+                             TempMember->GetChildInt( "InputBuffer/MarkerLen", 0 ) );
+        SetOutBuffer( Handle, TempMember->GetChildInt( "OutputBuffer/Size", 0 ) );
 
         // Next
-        TempMember = DataTree->GetNextChild( TempMember );
+        TempMember = TempMember->GetNextPeer();
     }
 
     return true;
diff --git a/WatchdogCore.cpp b/WatchdogCore.cpp
index 8e47b3c..73a53ec 100644
--- a/WatchdogCore.cpp
+++ b/WatchdogCore.cpp
@@ -50,7 +50,7 @@ bool  CWatchdogCore::LoadConfigData()
     CSelectableCore::LoadConfigData();
 
     // Set specific parameters
-    SetInterval( DataTree->GetInt( ConfigMember, "Parameters/PingInterval", 500, true ));
+    SetInterval( ConfigMember->GetChildInt( "Parameters/PingInterval", 500, true ));
 
     return true;
 }